SDK Reference

Use TGraph Backend Generator programmatically in your own scripts and build pipelines.

Installation 

npm install --save-dev @tgraph/backend-generator

Basic Usage 

import { ApiGenerator, DashboardGenerator, DtoGenerator } from '@tgraph/backend-generator';
import type { Config } from '@tgraph/backend-generator';

// Define your configuration
const config: Config = {
  schemaPath: 'prisma/schema.prisma',
  dashboardPath: 'src/dashboard/src',
  dtosPath: 'src/dtos/generated',
  suffix: 'Tg',
  isAdmin: true,
  updateDataProvider: true,
  nonInteractive: false,
};

(async () => {
  // Generate API files
  const api = new ApiGenerator(config);
  await api.generate();

  // Generate dashboard
  const dashboard = new DashboardGenerator(config);
  await dashboard.generate();

  // Generate DTOs
  const dtos = new DtoGenerator(config);
  dtos.generate();
})();

Exported Modules

Generators

ApiGenerator

Generates NestJS API files: controllers, services, DTOs, and updates AppModule.

Constructor:

new ApiGenerator(config: Config)

Methods:

async generate(): Promise<void>

Example:

import { ApiGenerator } from '@tgraph/backend-generator';

const config = {
  schemaPath: 'prisma/schema.prisma',
  dashboardPath: 'src/dashboard/src',
  dtosPath: 'src/dtos/generated',
  suffix: 'Admin',
  isAdmin: true,
  updateDataProvider: true,
  nonInteractive: false,
};

const generator = new ApiGenerator(config);
await generator.generate();

What it generates:

  • Controllers with REST endpoints
  • Services with CRUD operations
  • Create/Update DTOs with validation
  • Module files if missing
  • AppModule import updates
  • Data provider endpoint mappings (if enabled)

DashboardGenerator

Generates React Admin dashboard resources.

Constructor:

new DashboardGenerator(config: Config)

Methods:

async generate(): Promise<void>

Example:

import { DashboardGenerator } from '@tgraph/backend-generator';

const config = {
  schemaPath: 'prisma/schema.prisma',
  dashboardPath: 'src/dashboard/src',
  dtosPath: 'src/dtos/generated',
  suffix: 'Tg',
  isAdmin: true,
  updateDataProvider: true,
  nonInteractive: false,
};

const generator = new DashboardGenerator(config);
await generator.generate();

What it generates:

  • List, Edit, Create, Show, Studio components
  • Field directive metadata
  • App.tsx resource registrations
  • App.tsx studio routes

DtoGenerator

Generates response DTO files.

Constructor:

new DtoGenerator(config: Config)

Methods:

generate(): void

Example:

import { DtoGenerator } from '@tgraph/backend-generator';

const config = {
  schemaPath: 'prisma/schema.prisma',
  dtosPath: 'src/dtos/generated',
  suffix: 'Response',
  isAdmin: false,
};

const generator = new DtoGenerator(config);
generator.generate();

Utilities

ModulePathResolver

Locates NestJS module files in your project.

Constructor:

new ModulePathResolver();

Methods:

resolve(modelName: string): Promise<ModulePathInfo | null>

Example:

import { ModulePathResolver } from '@tgraph/backend-generator';

const resolver = new ModulePathResolver();
const moduleInfo = await resolver.resolve('User');

if (moduleInfo) {
  console.log('Module path:', moduleInfo.path);
  console.log('Module type:', moduleInfo.type); // e.g., 'features', 'modules', 'domains', etc.
  console.log('Folder name:', moduleInfo.folderName);
}

Return Type:

interface ModulePathInfo {
  path: string; // e.g., 'src/features/user'
  type: string; // Folder name where module is found (e.g., 'features', 'modules', 'domains', etc.)
  folderName: string; // e.g., 'user'
}

NestAppModuleUpdater

Updates app.module.ts with auto-generated imports.

Constructor:

new NestAppModuleUpdater();

Methods:

update(modules: Array<{ name: string; path: string }>): Promise<void>

Example:

import { NestAppModuleUpdater } from '@tgraph/backend-generator';

const updater = new NestAppModuleUpdater();

await updater.update([
  { name: 'UserModule', path: './features/user/user.module' },
  { name: 'PostModule', path: './features/post/post.module' },
]);

Behavior:

  • Inserts imports between // AUTO-GENERATED IMPORTS START/END comments
  • Preserves manual imports
  • Creates sentinel comments if missing

NestModuleUpdater

Updates individual feature module files with providers/controllers.

Constructor:

new NestModuleUpdater();

Methods:

update(modulePath: string, updates: ModuleUpdates): Promise<void>

Example:

import { NestModuleUpdater } from '@tgraph/backend-generator';

const updater = new NestModuleUpdater();

await updater.update('src/features/user/user.module.ts', {
  providers: ['UserTgService'],
  controllers: ['UserTgController'],
});

DataProviderEndpointGenerator

Updates React Admin data provider with endpoint mappings.

Constructor:

new DataProviderEndpointGenerator();

Methods:

update(resources: Array<{ name: string; endpoint: string }>): Promise<void>

Example:

import { DataProviderEndpointGenerator } from '@tgraph/backend-generator';

const generator = new DataProviderEndpointGenerator();

await generator.update([
  { name: 'users', endpoint: 'tg-api/users' },
  { name: 'posts', endpoint: 'tg-api/posts' },
]);

Behavior:

  • Updates endpointMap in data provider file
  • Preserves custom endpoint mappings
  • Inserts between auto-generated comments

Configuration

config

Default configuration object.

Type:

interface Config {
  schemaPath: string;
  dashboardPath: string;
  dtosPath: string;
  suffix: string;
  isAdmin?: boolean;
  updateDataProvider?: boolean;
  nonInteractive?: boolean;
}

Default Values:

{
  schemaPath: 'prisma/schema.prisma',
  dashboardPath: 'src/dashboard/src',
  dtosPath: 'src/dtos/generated',
  suffix: 'Tg',
  isAdmin: true,
  updateDataProvider: true,
  nonInteractive: false,
}

Example:

import type { Config } from '@tgraph/backend-generator';

// Define base configuration
const baseConfig: Config = {
  schemaPath: 'prisma/schema.prisma',
  dashboardPath: 'src/dashboard/src',
  dtosPath: 'src/dtos/generated',
  suffix: 'Tg',
  isAdmin: true,
  updateDataProvider: true,
  nonInteractive: false,
};

// Create variations
const adminConfig: Config = {
  ...baseConfig,
  suffix: 'Admin',
  isAdmin: true,
};

const publicConfig: Config = {
  ...baseConfig,
  suffix: 'Public',
  isAdmin: false,
};

Advanced Patterns

Custom Build Script

Create a custom generation script with pre/post hooks:

// scripts/generate.ts
import { ApiGenerator, DashboardGenerator, DtoGenerator } from '@tgraph/backend-generator';
import type { Config } from '@tgraph/backend-generator';
import { exec } from 'child_process';
import { promisify } from 'util';

const execAsync = promisify(exec);

// Load your configuration
const config: Config = {
  schemaPath: 'prisma/schema.prisma',
  dashboardPath: 'src/dashboard/src',
  dtosPath: 'src/dtos/generated',
  suffix: 'Tg',
  isAdmin: true,
  updateDataProvider: true,
  nonInteractive: false,
};

async function generate() {
  console.log('šŸš€ Starting generation...');

  // Pre-generation: Run Prisma migrations
  console.log('šŸ“¦ Running Prisma migrations...');
  await execAsync('npx prisma migrate dev');

  // Generate backend
  console.log('āš™ļø  Generating backend...');
  const api = new ApiGenerator(config);
  await api.generate();

  // Generate dashboard
  console.log('šŸŽØ Generating dashboard...');
  const dashboard = new DashboardGenerator(config);
  await dashboard.generate();

  // Generate DTOs
  console.log('šŸ“ Generating DTOs...');
  const dtos = new DtoGenerator(config);
  dtos.generate();

  // Post-generation: Format code
  console.log('āœØ Formatting code...');
  await execAsync('npx prettier --write "src/**/*.{ts,tsx}"');

  // Post-generation: Run linter
  console.log('šŸ” Running linter...');
  await execAsync('npx eslint --fix "src/**/*.{ts,tsx}"');

  console.log('āœ… Generation complete!');
}

generate().catch((error) => {
  console.error('āŒ Generation failed:', error);
  process.exit(1);
});

Run:

npx ts-node scripts/generate.ts

Multiple Configurations

Generate for different environments:

// scripts/generate-all.ts
import { ApiGenerator, DashboardGenerator } from '@tgraph/backend-generator';

const baseConfig = {
  schemaPath: 'prisma/schema.prisma',
  dashboardPath: 'src/dashboard/src',
  dtosPath: 'src/dtos/generated',
  updateDataProvider: true,
  nonInteractive: false,
};

async function generateAll() {
  // Admin API
  console.log('Generating admin API...');
  const adminApi = new ApiGenerator({
    ...baseConfig,
    suffix: 'Admin',
    isAdmin: true,
  });
  await adminApi.generate();

  // Public API
  console.log('Generating public API...');
  const publicApi = new ApiGenerator({
    ...baseConfig,
    suffix: 'Public',
    isAdmin: false,
    dtosPath: 'src/dtos/public',
  });
  await publicApi.generate();

  // Admin Dashboard
  console.log('Generating admin dashboard...');
  const adminDashboard = new DashboardGenerator({
    ...baseConfig,
    suffix: 'Admin',
  });
  await adminDashboard.generate();
}

generateAll();

Conditional Generation

Generate based on environment or conditions:

import { ApiGenerator, DashboardGenerator } from '@tgraph/backend-generator';

async function smartGenerate() {
  const env = process.env.NODE_ENV || 'development';
  const generateDashboard = process.env.GENERATE_DASHBOARD === 'true';

  const config = {
    schemaPath: 'prisma/schema.prisma',
    dashboardPath: 'src/dashboard/src',
    dtosPath: `src/dtos/${env}`,
    suffix: env === 'production' ? 'Prod' : 'Dev',
    isAdmin: true,
    updateDataProvider: generateDashboard,
  };

  // Always generate API
  const api = new ApiGenerator(config);
  await api.generate();

  // Conditionally generate dashboard
  if (generateDashboard) {
    const dashboard = new DashboardGenerator(config);
    await dashboard.generate();
  }
}

smartGenerate();

Error Handling

Robust error handling:

import { ApiGenerator } from '@tgraph/backend-generator';

async function safeGenerate() {
  try {
    const generator = new ApiGenerator(config);
    await generator.generate();
    console.log('āœ… Generation successful');
  } catch (error) {
    if (error instanceof Error) {
      console.error('āŒ Generation failed:', error.message);
      console.error('Stack trace:', error.stack);
    }

    // Send error to monitoring service
    await sendToSentry(error);

    // Exit with error code
    process.exit(1);
  }
}

safeGenerate();

Watch Mode

Auto-regenerate on schema changes:

import { watch } from 'fs';
import { ApiGenerator, DashboardGenerator } from '@tgraph/backend-generator';

const config = {
  schemaPath: 'prisma/schema.prisma',
  dashboardPath: 'src/dashboard/src',
  dtosPath: 'src/dtos/generated',
  suffix: 'Tg',
  isAdmin: true,
  updateDataProvider: true,
  nonInteractive: false,
};

async function regenerate() {
  console.log('šŸ”„ Regenerating...');

  const api = new ApiGenerator(config);
  await api.generate();

  const dashboard = new DashboardGenerator(config);
  await dashboard.generate();

  console.log('āœ… Done');
}

// Watch schema file
watch(config.schemaPath, async (eventType) => {
  if (eventType === 'change') {
    console.log('šŸ“ Schema changed, regenerating...');
    await regenerate();
  }
});

console.log(`šŸ‘€ Watching ${config.schemaPath} for changes...`);

Monorepo Support

Generate for multiple apps in a monorepo:

import { ApiGenerator, DashboardGenerator } from '@tgraph/backend-generator';

const apps = [
  {
    name: 'main-app',
    schemaPath: 'apps/main/prisma/schema.prisma',
    dashboardPath: 'apps/main/src/dashboard/src',
    dtosPath: 'apps/main/src/dtos',
  },
  {
    name: 'admin-app',
    schemaPath: 'apps/admin/prisma/schema.prisma',
    dashboardPath: 'apps/admin/src/dashboard/src',
    dtosPath: 'apps/admin/src/dtos',
  },
];

async function generateMonorepo() {
  for (const app of apps) {
    console.log(`\nšŸ“¦ Generating for ${app.name}...`);

    const config = {
      ...app,
      suffix: 'Tg',
      isAdmin: true,
      updateDataProvider: true,
      nonInteractive: false,
    };

    const api = new ApiGenerator(config);
    await api.generate();

    const dashboard = new DashboardGenerator(config);
    await dashboard.generate();
  }
}

generateMonorepo();

TypeScript Types

Config 

interface Config {
  schemaPath: string;
  dashboardPath: string;
  dtosPath: string;
  suffix: string;
  isAdmin?: boolean;
  updateDataProvider?: boolean;
  nonInteractive?: boolean;
}

ModulePathInfo 

interface ModulePathInfo {
  path: string;
  type: string; // Folder name where module is found
  folderName: string;
}

ModuleUpdates 

interface ModuleUpdates {
  providers?: string[];
  controllers?: string[];
  imports?: string[];
  exports?: string[];
}

Next Steps