nestjs-ddd-cli 2.2.1 → 3.2.2

package/dist/commands/filter-dsl.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"filter-dsl.js","sourceRoot":"","sources":["../../src/commands/filter-dsl.ts"],"names":[],"mappings":"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"}

package/dist/commands/generate-all.js

@@ -41,64 +41,218 @@ const path = __importStar(require("path"));
 const chalk_1 = __importDefault(require("chalk"));
 const generate_module_1 = require("./generate-module");
 const generate_entity_1 = require("./generate-entity");
-const generate_usecase_1 = require("./generate-usecase");
 const file_utils_1 = require("../utils/file.utils");
 const naming_utils_1 = require("../utils/naming.utils");
 const dependency_utils_1 = require("../utils/dependency.utils");
 async function generateAll(entityName, options) {
-    console.log(chalk_1.default.blue(`🚀 Generating complete scaffolding for: ${entityName}`));
+    console.log(chalk_1.default.blue(`\n🚀 Generating complete scaffolding for: ${entityName}`));
+    const orm = options.orm || 'typeorm';
+    const dryRun = !!options.dryRun;
+    if (dryRun) {
+        (0, file_utils_1.resetDryRunFiles)();
+        console.log(chalk_1.default.yellow('  Dry run: no files, directories, or dependencies will be written.'));
+    }
     // Check if we need to install dependencies
-    const requiredDeps = ['@nestjs/cqrs', 'class-validator', 'class-transformer'];
-    if (options.installDeps) {
+    const requiredDeps = ['@nestjs/cqrs', 'class-validator', 'class-transformer', '@nestjs/swagger'];
+    if (orm === 'prisma') {
+        requiredDeps.push('@prisma/client', 'prisma');
+    }
+    else {
+        requiredDeps.push('typeorm', '@nestjs/typeorm');
+    }
+    if (options.installDeps && !dryRun) {
         await (0, dependency_utils_1.installDependencies)(options.path || process.cwd(), requiredDeps);
     }
+    else if (options.installDeps && dryRun) {
+        console.log(chalk_1.default.yellow(`  Dry run: would install dependencies: ${requiredDeps.join(', ')}`));
+    }
     const moduleName = options.module || entityName;
     const basePath = options.path || process.cwd();
     const modulePath = (0, file_utils_1.getModulePath)(basePath, moduleName);
+    const fieldsString = options.fields || '';
     // Check if module exists, create if not
     const moduleFilePath = path.join(modulePath, `${(0, naming_utils_1.toKebabCase)(moduleName)}.module.ts`);
     if (!(await (0, file_utils_1.fileExists)(moduleFilePath))) {
-        console.log(chalk_1.default.yellow(`Module ${moduleName} doesn't exist. Creating...`));
-        await (0, generate_module_1.generateModule)(moduleName, options);
+        console.log(chalk_1.default.yellow(`  Module ${moduleName} doesn't exist. Creating...`));
+        await (0, generate_module_1.generateModule)(moduleName, { ...options, dryRun });
     }
+    // Prepare template data with fields
+    const templateData = (0, file_utils_1.prepareTemplateData)(entityName, moduleName, fieldsString);
     // Generate entity with all related files
-    await (0, generate_entity_1.generateEntity)(entityName, { ...options, module: moduleName });
-    // Generate CRUD use cases
-    const useCases = ['Create', 'Update', 'Delete'];
-    for (const action of useCases) {
-        const useCaseName = `${action}${entityName}`;
-        await (0, generate_usecase_1.generateUseCase)(useCaseName, { ...options, module: moduleName });
+    await (0, generate_entity_1.generateEntity)(entityName, {
+        ...options,
+        module: moduleName,
+        fields: fieldsString,
+        orm,
+        dryRun,
+        _fromGenerateAll: true,
+    });
+    // Generate PrismaService if using Prisma
+    if (orm === 'prisma') {
+        await generatePrismaService(basePath, dryRun);
     }
+    // Generate CRUD commands
+    console.log(chalk_1.default.cyan('  Generating commands...'));
+    await generateCommand('create', entityName, modulePath, templateData, dryRun);
+    await generateCommand('update', entityName, modulePath, templateData, dryRun);
+    await generateCommand('delete', entityName, modulePath, templateData, dryRun);
+    // Generate use cases
+    console.log(chalk_1.default.cyan('  Generating use cases...'));
+    await generateUseCase('create', entityName, modulePath, templateData, dryRun);
+    await generateUseCase('update', entityName, modulePath, templateData, dryRun);
+    await generateUseCase('delete', entityName, modulePath, templateData, dryRun);
+    // Generate queries
+    console.log(chalk_1.default.cyan('  Generating queries...'));
+    await generateQueryHandler('get-by-id', entityName, modulePath, templateData, dryRun);
+    await generateQueryHandler('get-all', entityName, modulePath, templateData, dryRun);
+    // Generate DTOs
+    console.log(chalk_1.default.cyan('  Generating DTOs...'));
+    await generateDto('create', entityName, modulePath, templateData, dryRun);
+    await generateDto('update', entityName, modulePath, templateData, dryRun);
+    await generateDto('response', entityName, modulePath, templateData, dryRun);
+    await generatePaginationDtos(modulePath, dryRun);
     // Generate controller
-    const templateData = (0, file_utils_1.prepareTemplateData)(entityName, moduleName);
+    console.log(chalk_1.default.cyan('  Generating controller...'));
     const controllerTemplatePath = path.join(__dirname, '../templates/controller/controller.hbs');
     const controllerOutputPath = path.join(modulePath, 'application/controllers', `${(0, naming_utils_1.toKebabCase)(entityName)}.controller.ts`);
-    await (0, file_utils_1.generateFromTemplate)(controllerTemplatePath, controllerOutputPath, templateData);
-    // Generate migration file
-    await generateMigration(entityName, basePath);
+    await (0, file_utils_1.generateFromTemplate)(controllerTemplatePath, controllerOutputPath, templateData, dryRun);
+    // Generate migration file or Prisma schema snippet
+    if (orm === 'prisma') {
+        console.log(chalk_1.default.cyan('  Generating Prisma schema snippet...'));
+        await generatePrismaSchemaSnippet(entityName, basePath, templateData, dryRun);
+    }
+    else {
+        console.log(chalk_1.default.cyan('  Generating migration...'));
+        await generateMigration(entityName, basePath, templateData, dryRun);
+    }
+    // Generate barrel exports
+    console.log(chalk_1.default.cyan('  Generating barrel exports...'));
+    await generateBarrelExports(entityName, modulePath, orm, dryRun);
+    // Generate tests if requested
+    if (options.withTests) {
+        console.log(chalk_1.default.cyan('  Generating tests...'));
+        await generateTests(entityName, modulePath, templateData, dryRun);
+    }
+    // Generate GraphQL files if requested
+    if (options.withGraphql) {
+        console.log(chalk_1.default.cyan('  Generating GraphQL resolvers and types...'));
+        await generateGraphQL(entityName, modulePath, templateData, dryRun);
+    }
+    if (dryRun) {
+        printDryRunSummary(basePath);
+        return;
+    }
     console.log(chalk_1.default.green(`\n✅ Complete scaffolding generated successfully!`));
-    console.log(chalk_1.default.cyan(`\n📁 Generated files:`));
-    console.log(`   Module: ${modulePath}`);
-    console.log(`   Entity: ${entityName}`);
-    console.log(`   Use Cases: Create, Update, Delete`);
-    console.log(`   Controller: ${entityName}Controller`);
-    console.log(`   Repository: ${entityName}Repository`);
-    console.log(`   Mapper: ${entityName}Mapper`);
-    console.log(chalk_1.default.yellow(`\n⚠️  Next steps:`));
-    console.log(`   1. Update the index.ts files in each directory`);
-    console.log(`   2. Add properties to your entity and DTOs`);
-    console.log(`   3. Update the mapper with proper field mappings`);
-    console.log(`   4. Run the migration to create the database table`);
-    console.log(`   5. Import ${moduleName}Module in your app.module.ts`);
-}
-async function generateMigration(entityName, basePath) {
+    console.log(chalk_1.default.cyan(`\n📁 Generated structure:`));
+    console.log(`   ${chalk_1.default.white('Module:')} ${modulePath}`);
+    console.log(`   ${chalk_1.default.white('Entity:')} ${entityName}`);
+    console.log(`   ${chalk_1.default.white('ORM:')} ${orm === 'prisma' ? 'Prisma' : 'TypeORM'}`);
+    console.log(`   ${chalk_1.default.white('Commands:')} Create, Update, Delete`);
+    console.log(`   ${chalk_1.default.white('Queries:')} GetById, GetAll (paginated)`);
+    console.log(`   ${chalk_1.default.white('Use Cases:')} Create, Update, Delete`);
+    console.log(`   ${chalk_1.default.white('DTOs:')} Create, Update, Response, Pagination`);
+    console.log(`   ${chalk_1.default.white('Controller:')} Full CRUD REST endpoints`);
+    console.log(`   ${chalk_1.default.white('Repository:')} With pagination support`);
+    console.log(`   ${chalk_1.default.white('Mapper:')} Domain ↔ ${orm === 'prisma' ? 'Prisma' : 'ORM'} ↔ Response`);
+    if (options.withGraphql) {
+        console.log(`   ${chalk_1.default.white('GraphQL:')} Resolver, Types, Inputs`);
+    }
+    if (templateData.hasFields) {
+        console.log(chalk_1.default.green(`\n✨ Fields generated: ${templateData.fields?.map((f) => f.name).join(', ')}`));
+    }
+    console.log(chalk_1.default.yellow(`\n📋 Next steps:`));
+    console.log(`   1. ${templateData.hasFields ? 'Review' : 'Add properties to'} your entity and DTOs`);
+    if (orm === 'prisma') {
+        console.log(`   2. Add the generated model to your ${chalk_1.default.cyan('prisma/schema.prisma')}`);
+        console.log(`   3. Run: ${chalk_1.default.cyan('npx prisma migrate dev --name add_' + (0, naming_utils_1.toKebabCase)(entityName))}`);
+        console.log(`   4. Run: ${chalk_1.default.cyan('npx prisma generate')}`);
+    }
+    else {
+        console.log(`   2. Run the migration: ${chalk_1.default.cyan('npm run migration:run')}`);
+    }
+    console.log(`   ${orm === 'prisma' ? '5' : '3'}. Import ${(0, naming_utils_1.toPascalCase)(moduleName)}Module in your app.module.ts`);
+    console.log(`   ${orm === 'prisma' ? '6' : '4'}. Start your server and test the API at ${chalk_1.default.cyan(`/${templateData.entityNamePluralKebab}`)}`);
+}
+function printDryRunSummary(basePath) {
+    const changes = (0, file_utils_1.getDryRunFiles)();
+    console.log(chalk_1.default.cyan(`\n🧪 Dry run complete. Planned file changes (${changes.length}):`));
+    if (!changes.length) {
+        console.log(chalk_1.default.gray('   No file changes planned.'));
+        return;
+    }
+    for (const change of changes) {
+        const relativePath = path.relative(basePath, change.filePath);
+        console.log(`   ${change.action.padEnd(6)} ${relativePath}`);
+    }
+}
+async function generateCommand(action, entityName, modulePath, templateData, dryRun = false) {
+    const templatePath = path.join(__dirname, `../templates/command/${action}-command.hbs`);
+    const outputPath = path.join(modulePath, 'application/commands', `${action}-${(0, naming_utils_1.toKebabCase)(entityName)}.command.ts`);
+    await (0, file_utils_1.generateFromTemplate)(templatePath, outputPath, templateData, dryRun);
+}
+async function generateUseCase(action, entityName, modulePath, templateData, dryRun = false) {
+    const templatePath = path.join(__dirname, `../templates/usecase/${action}-usecase.hbs`);
+    const outputPath = path.join(modulePath, 'application/domain/usecases', `${action}-${(0, naming_utils_1.toKebabCase)(entityName)}.use-case.ts`);
+    await (0, file_utils_1.generateFromTemplate)(templatePath, outputPath, templateData, dryRun);
+}
+async function generateQueryHandler(type, entityName, modulePath, templateData, dryRun = false) {
+    const fileName = type === 'get-all'
+        ? `get-all-${templateData.entityNamePluralKebab}.query.ts`
+        : `get-${(0, naming_utils_1.toKebabCase)(entityName)}-by-id.query.ts`;
+    const templatePath = path.join(__dirname, `../templates/query/${type}.query.hbs`);
+    const outputPath = path.join(modulePath, 'application/queries', fileName);
+    await (0, file_utils_1.generateFromTemplate)(templatePath, outputPath, templateData, dryRun);
+}
+async function generateDto(type, entityName, modulePath, templateData, dryRun = false) {
+    const templateMap = {
+        create: 'create-dto.hbs',
+        update: 'update-dto.hbs',
+        response: 'response-dto.hbs',
+    };
+    const outputDirMap = {
+        create: 'requests',
+        update: 'requests',
+        response: 'responses',
+    };
+    const fileNameMap = {
+        create: `create-${(0, naming_utils_1.toKebabCase)(entityName)}.dto.ts`,
+        update: `update-${(0, naming_utils_1.toKebabCase)(entityName)}.dto.ts`,
+        response: `${(0, naming_utils_1.toKebabCase)(entityName)}.response.dto.ts`,
+    };
+    const templatePath = path.join(__dirname, `../templates/dto/${templateMap[type]}`);
+    const outputPath = path.join(modulePath, `application/dto/${outputDirMap[type]}`, fileNameMap[type]);
+    await (0, file_utils_1.generateFromTemplate)(templatePath, outputPath, templateData, dryRun);
+}
+async function generatePaginationDtos(modulePath, dryRun = false) {
+    // Generate pagination query DTO
+    const paginationQueryTemplatePath = path.join(__dirname, '../templates/dto/pagination-query.dto.hbs');
+    const paginationQueryOutputPath = path.join(modulePath, 'application/dto/requests', 'pagination.query.dto.ts');
+    if (!(await (0, file_utils_1.fileExists)(paginationQueryOutputPath))) {
+        await (0, file_utils_1.generateFromTemplate)(paginationQueryTemplatePath, paginationQueryOutputPath, (0, file_utils_1.prepareTemplateData)('Pagination', 'shared'), dryRun);
+    }
+    // Generate paginated response DTO
+    const paginatedResponseTemplatePath = path.join(__dirname, '../templates/dto/paginated-response.dto.hbs');
+    const paginatedResponseOutputPath = path.join(modulePath, 'application/dto/responses', 'paginated.response.dto.ts');
+    if (!(await (0, file_utils_1.fileExists)(paginatedResponseOutputPath))) {
+        await (0, file_utils_1.generateFromTemplate)(paginatedResponseTemplatePath, paginatedResponseOutputPath, (0, file_utils_1.prepareTemplateData)('Paginated', 'shared'), dryRun);
+    }
+}
+async function generateMigration(entityName, basePath, templateData, dryRun = false) {
     const timestamp = Date.now();
-    const tableName = (0, naming_utils_1.toKebabCase)(entityName).replace(/-/g, '_') + 's';
+    const tableName = templateData.tableName;
     const migrationName = `create_${tableName}_table`;
     const fileName = `${timestamp}-${migrationName}.ts`;
+    const fieldsColumns = templateData.migrationColumns ||
+        `          // Add your custom columns here
+          // Example:
+          // {
+          //   name: "name",
+          //   type: "varchar",
+          //   isNullable: false,
+          // },`;
     const content = `import { MigrationInterface, QueryRunner, Table } from "typeorm";
 
-export class Create${entityName}Table${timestamp} implements MigrationInterface {
+export class Create${(0, naming_utils_1.toPascalCase)(entityName)}Table${timestamp} implements MigrationInterface {
   public async up(queryRunner: QueryRunner): Promise<void> {
     await queryRunner.createTable(
       new Table({
@@ -111,6 +265,7 @@ export class Create${entityName}Table${timestamp} implements MigrationInterface
             generationStrategy: "uuid",
             default: "uuid_generate_v4()",
           },
+${fieldsColumns}
           {
             name: "is_active",
             type: "boolean",
@@ -131,7 +286,6 @@ export class Create${entityName}Table${timestamp} implements MigrationInterface
             type: "timestamp",
             isNullable: true,
           },
-          // Add your custom columns here
         ],
       }),
       true,
@@ -144,7 +298,342 @@ export class Create${entityName}Table${timestamp} implements MigrationInterface
 }
 `;
     const migrationPath = path.join(basePath, 'src/migrations', fileName);
-    await require('../utils/file.utils').writeFile(migrationPath, content);
-    console.log(chalk_1.default.green(`   Migration: ${fileName}`));
+    await (0, file_utils_1.writeGeneratedFile)(migrationPath, content, dryRun);
+    console.log(chalk_1.default.green(`   ✓ Migration: ${fileName}`));
+}
+async function generateBarrelExports(entityName, modulePath, orm = 'typeorm', dryRun = false) {
+    const entityNameKebab = (0, naming_utils_1.toKebabCase)(entityName);
+    const entityNamePascal = (0, naming_utils_1.toPascalCase)(entityName);
+    const entityNamePluralKebab = (0, naming_utils_1.toKebabCase)((0, naming_utils_1.toPlural)(entityName));
+    const entityNamePluralPascal = (0, naming_utils_1.toPlural)((0, naming_utils_1.toPascalCase)(entityName));
+    const isPrisma = orm === 'prisma';
+    // Commands index
+    const commandsIndexPath = path.join(modulePath, 'application/commands/index.ts');
+    await (0, file_utils_1.updateBarrelFile)(commandsIndexPath, {
+        exports: [
+            `export * from './create-${entityNameKebab}.command';`,
+            `export * from './update-${entityNameKebab}.command';`,
+            `export * from './delete-${entityNameKebab}.command';`,
+        ],
+        imports: [
+            `import { Create${entityNamePascal}Handler } from './create-${entityNameKebab}.command';`,
+            `import { Update${entityNamePascal}Handler } from './update-${entityNameKebab}.command';`,
+            `import { Delete${entityNamePascal}Handler } from './delete-${entityNameKebab}.command';`,
+        ],
+        arrayName: 'CommandHandlers',
+        arrayItems: [
+            `Create${entityNamePascal}Handler`,
+            `Update${entityNamePascal}Handler`,
+            `Delete${entityNamePascal}Handler`,
+        ],
+        dryRun,
+    });
+    // Queries index
+    const queriesIndexPath = path.join(modulePath, 'application/queries/index.ts');
+    await (0, file_utils_1.updateBarrelFile)(queriesIndexPath, {
+        exports: [
+            `export * from './get-${entityNameKebab}-by-id.query';`,
+            `export * from './get-all-${entityNamePluralKebab}.query';`,
+        ],
+        imports: [
+            `import { Get${entityNamePascal}ByIdHandler } from './get-${entityNameKebab}-by-id.query';`,
+            `import { GetAll${entityNamePluralPascal}Handler } from './get-all-${entityNamePluralKebab}.query';`,
+        ],
+        arrayName: 'Queries',
+        arrayItems: [`Get${entityNamePascal}ByIdHandler`, `GetAll${entityNamePluralPascal}Handler`],
+        dryRun,
+    });
+    // Use cases index
+    const useCasesIndexPath = path.join(modulePath, 'application/domain/usecases/index.ts');
+    await (0, file_utils_1.updateBarrelFile)(useCasesIndexPath, {
+        exports: [
+            `export * from './create-${entityNameKebab}.use-case';`,
+            `export * from './update-${entityNameKebab}.use-case';`,
+            `export * from './delete-${entityNameKebab}.use-case';`,
+        ],
+        imports: [
+            `import { Create${entityNamePascal}UseCase } from './create-${entityNameKebab}.use-case';`,
+            `import { Update${entityNamePascal}UseCase } from './update-${entityNameKebab}.use-case';`,
+            `import { Delete${entityNamePascal}UseCase } from './delete-${entityNameKebab}.use-case';`,
+        ],
+        arrayName: 'UseCases',
+        arrayItems: [
+            `Create${entityNamePascal}UseCase`,
+            `Update${entityNamePascal}UseCase`,
+            `Delete${entityNamePascal}UseCase`,
+        ],
+        dryRun,
+    });
+    // DTOs index
+    const dtosIndexPath = path.join(modulePath, 'application/dto/index.ts');
+    await (0, file_utils_1.updateBarrelFile)(dtosIndexPath, {
+        exports: [`export * from './requests';`, `export * from './responses';`],
+        dryRun,
+    });
+    // Requests index
+    const requestsIndexPath = path.join(modulePath, 'application/dto/requests/index.ts');
+    await (0, file_utils_1.updateBarrelFile)(requestsIndexPath, {
+        exports: [
+            `export * from './create-${entityNameKebab}.dto';`,
+            `export * from './update-${entityNameKebab}.dto';`,
+            `export * from './pagination.query.dto';`,
+        ],
+        dryRun,
+    });
+    // Responses index
+    const responsesIndexPath = path.join(modulePath, 'application/dto/responses/index.ts');
+    await (0, file_utils_1.updateBarrelFile)(responsesIndexPath, {
+        exports: [
+            `export * from './${entityNameKebab}.response.dto';`,
+            `export * from './paginated.response.dto';`,
+        ],
+        dryRun,
+    });
+    // Controllers index
+    const controllersIndexPath = path.join(modulePath, 'application/controllers/index.ts');
+    await (0, file_utils_1.updateBarrelFile)(controllersIndexPath, {
+        exports: [`export * from './${entityNameKebab}.controller';`],
+        imports: [`import { ${entityNamePascal}Controller } from './${entityNameKebab}.controller';`],
+        arrayName: 'Controllers',
+        arrayItems: [`${entityNamePascal}Controller`],
+        dryRun,
+    });
+    // Entities index
+    const entitiesIndexPath = path.join(modulePath, 'application/domain/entities/index.ts');
+    await (0, file_utils_1.updateBarrelFile)(entitiesIndexPath, {
+        exports: [`export * from './${entityNameKebab}.entity';`],
+        dryRun,
+    });
+    // Repositories index
+    const repositoriesIndexPath = path.join(modulePath, 'infrastructure/repositories/index.ts');
+    await (0, file_utils_1.updateBarrelFile)(repositoriesIndexPath, {
+        exports: [`export * from './${entityNameKebab}.repository';`],
+        imports: [`import { ${entityNamePascal}Repository } from './${entityNameKebab}.repository';`],
+        arrayName: 'Repositories',
+        arrayItems: [`${entityNamePascal}Repository`],
+        dryRun,
+    });
+    // Mappers index
+    const mappersIndexPath = path.join(modulePath, 'infrastructure/mappers/index.ts');
+    await (0, file_utils_1.updateBarrelFile)(mappersIndexPath, {
+        exports: [`export * from './${entityNameKebab}.mapper';`],
+        imports: [`import { ${entityNamePascal}Mapper } from './${entityNameKebab}.mapper';`],
+        arrayName: 'Mappers',
+        arrayItems: [`${entityNamePascal}Mapper`],
+        dryRun,
+    });
+    // ORM entities index (TypeORM only)
+    if (!isPrisma) {
+        const ormEntitiesIndexPath = path.join(modulePath, 'infrastructure/orm-entities/index.ts');
+        await (0, file_utils_1.updateBarrelFile)(ormEntitiesIndexPath, {
+            exports: [`export * from './${entityNameKebab}.orm-entity';`],
+            imports: [`import { ${entityNamePascal}OrmEntity } from './${entityNameKebab}.orm-entity';`],
+            arrayName: 'OrmEntities',
+            arrayItems: [`${entityNamePascal}OrmEntity`],
+            dryRun,
+        });
+    }
+}
+async function generateTests(entityName, modulePath, templateData, dryRun = false) {
+    const entityNameKebab = (0, naming_utils_1.toKebabCase)(entityName);
+    // Repository test
+    const repoTestTemplatePath = path.join(__dirname, '../templates/test/repository.spec.hbs');
+    const repoTestOutputPath = path.join(modulePath, 'infrastructure/repositories', `${entityNameKebab}.repository.spec.ts`);
+    await (0, file_utils_1.generateFromTemplate)(repoTestTemplatePath, repoTestOutputPath, templateData, dryRun);
+    console.log(chalk_1.default.green(`   ✓ Repository test`));
+    // Use case tests
+    const useCaseTestTemplatePath = path.join(__dirname, '../templates/test/usecase.spec.hbs');
+    const useCaseTestOutputPath = path.join(modulePath, 'application/domain/usecases', `${entityNameKebab}.use-case.spec.ts`);
+    await (0, file_utils_1.generateFromTemplate)(useCaseTestTemplatePath, useCaseTestOutputPath, templateData, dryRun);
+    console.log(chalk_1.default.green(`   ✓ Use case tests`));
+    // Controller test
+    const controllerTestTemplatePath = path.join(__dirname, '../templates/test/controller.spec.hbs');
+    const controllerTestOutputPath = path.join(modulePath, 'application/controllers', `${entityNameKebab}.controller.spec.ts`);
+    await (0, file_utils_1.generateFromTemplate)(controllerTestTemplatePath, controllerTestOutputPath, templateData, dryRun);
+    console.log(chalk_1.default.green(`   ✓ Controller test`));
+}
+async function generateGraphQL(entityName, modulePath, templateData, dryRun = false) {
+    const entityNameKebab = (0, naming_utils_1.toKebabCase)(entityName);
+    const entityNamePascal = (0, naming_utils_1.toPascalCase)(entityName);
+    // Create GraphQL directories
+    const graphqlPath = path.join(modulePath, 'application/graphql');
+    const typesPath = path.join(graphqlPath, 'types');
+    const inputsPath = path.join(graphqlPath, 'inputs');
+    const argsPath = path.join(graphqlPath, 'args');
+    // Generate resolver
+    const resolverTemplatePath = path.join(__dirname, '../templates/resolver/resolver.hbs');
+    const resolverOutputPath = path.join(graphqlPath, `${entityNameKebab}.resolver.ts`);
+    await (0, file_utils_1.generateFromTemplate)(resolverTemplatePath, resolverOutputPath, templateData, dryRun);
+    console.log(chalk_1.default.green(`   ✓ Resolver`));
+    // Generate GraphQL type
+    const typeTemplatePath = path.join(__dirname, '../templates/resolver/graphql-type.hbs');
+    const typeOutputPath = path.join(typesPath, `${entityNameKebab}.type.ts`);
+    await (0, file_utils_1.generateFromTemplate)(typeTemplatePath, typeOutputPath, templateData, dryRun);
+    console.log(chalk_1.default.green(`   ✓ GraphQL Type`));
+    // Generate GraphQL inputs
+    const inputTemplatePath = path.join(__dirname, '../templates/resolver/graphql-input.hbs');
+    const inputOutputPath = path.join(inputsPath, `${entityNameKebab}.input.ts`);
+    await (0, file_utils_1.generateFromTemplate)(inputTemplatePath, inputOutputPath, templateData, dryRun);
+    console.log(chalk_1.default.green(`   ✓ GraphQL Inputs`));
+    // Generate pagination args (if not exists)
+    const paginationArgsPath = path.join(argsPath, 'pagination.args.ts');
+    if (!(await (0, file_utils_1.fileExists)(paginationArgsPath))) {
+        const paginationArgsTemplatePath = path.join(__dirname, '../templates/resolver/pagination-args.hbs');
+        await (0, file_utils_1.generateFromTemplate)(paginationArgsTemplatePath, paginationArgsPath, templateData, dryRun);
+        console.log(chalk_1.default.green(`   ✓ Pagination Args`));
+    }
+    // Generate barrel exports
+    const typesIndexContent = `export * from "./${entityNameKebab}.type";
+`;
+    await (0, file_utils_1.writeGeneratedFile)(path.join(typesPath, 'index.ts'), typesIndexContent, dryRun);
+    const inputsIndexContent = `export * from "./${entityNameKebab}.input";
+`;
+    await (0, file_utils_1.writeGeneratedFile)(path.join(inputsPath, 'index.ts'), inputsIndexContent, dryRun);
+    const argsIndexContent = `export * from "./pagination.args";
+`;
+    await (0, file_utils_1.writeGeneratedFile)(path.join(argsPath, 'index.ts'), argsIndexContent, dryRun);
+    const graphqlIndexContent = `export * from "./${entityNameKebab}.resolver";
+export * from "./types";
+export * from "./inputs";
+export * from "./args";
+
+import { ${entityNamePascal}Resolver } from "./${entityNameKebab}.resolver";
+
+export const Resolvers = [${entityNamePascal}Resolver];
+`;
+    await (0, file_utils_1.writeGeneratedFile)(path.join(graphqlPath, 'index.ts'), graphqlIndexContent, dryRun);
+}
+async function generatePrismaService(basePath, dryRun = false) {
+    const prismaServicePath = path.join(basePath, 'src/prisma/prisma.service.ts');
+    if (await (0, file_utils_1.fileExists)(prismaServicePath)) {
+        console.log(chalk_1.default.yellow(`   PrismaService already exists. Skipping...`));
+        return;
+    }
+    const content = `import { Injectable, OnModuleInit, OnModuleDestroy } from "@nestjs/common";
+import { PrismaClient } from "@prisma/client";
+
+@Injectable()
+export class PrismaService extends PrismaClient implements OnModuleInit, OnModuleDestroy {
+  constructor() {
+    super({
+      log: process.env.NODE_ENV === "development"
+        ? ["query", "info", "warn", "error"]
+        : ["error"],
+    });
+  }
+
+  async onModuleInit() {
+    await this.$connect();
+  }
+
+  async onModuleDestroy() {
+    await this.$disconnect();
+  }
+
+  /**
+   * Execute operations in a transaction
+   */
+  async executeInTransaction<T>(
+    fn: (prisma: Omit<PrismaClient, "$connect" | "$disconnect" | "$on" | "$transaction" | "$use">) => Promise<T>,
+  ): Promise<T> {
+    return this.$transaction(fn);
+  }
+
+  /**
+   * Clean database (useful for testing)
+   */
+  async cleanDatabase() {
+    if (process.env.NODE_ENV !== "test") {
+      throw new Error("cleanDatabase can only be called in test environment");
+    }
+
+    const models = Reflect.ownKeys(this).filter(
+      (key) => typeof key === "string" && !key.startsWith("_") && !key.startsWith("$"),
+    );
+
+    for (const model of models) {
+      try {
+        await (this as any)[model].deleteMany();
+      } catch (error) {
+        // Ignore if model doesn't support deleteMany
+      }
+    }
+  }
+}
+`;
+    await (0, file_utils_1.writeGeneratedFile)(prismaServicePath, content, dryRun);
+    console.log(chalk_1.default.green(`   ✓ PrismaService`));
+    // Also generate prisma.module.ts
+    const prismaModulePath = path.join(basePath, 'src/prisma/prisma.module.ts');
+    if (!(await (0, file_utils_1.fileExists)(prismaModulePath))) {
+        const moduleContent = `import { Global, Module } from "@nestjs/common";
+import { PrismaService } from "./prisma.service";
+
+@Global()
+@Module({
+  providers: [PrismaService],
+  exports: [PrismaService],
+})
+export class PrismaModule {}
+`;
+        await (0, file_utils_1.writeGeneratedFile)(prismaModulePath, moduleContent, dryRun);
+        console.log(chalk_1.default.green(`   ✓ PrismaModule`));
+    }
+    // Generate index.ts
+    const indexPath = path.join(basePath, 'src/prisma/index.ts');
+    if (!(await (0, file_utils_1.fileExists)(indexPath))) {
+        const indexContent = `export * from "./prisma.service";
+export * from "./prisma.module";
+`;
+        await (0, file_utils_1.writeGeneratedFile)(indexPath, indexContent, dryRun);
+    }
+}
+async function generatePrismaSchemaSnippet(entityName, basePath, templateData, dryRun = false) {
+    const tableName = templateData.tableName;
+    const entityNamePascal = (0, naming_utils_1.toPascalCase)(entityName);
+    // Generate fields for Prisma schema
+    let fieldsContent = '';
+    if (templateData.fields && templateData.fields.length > 0) {
+        fieldsContent = templateData.fields
+            .map((f) => {
+            let line = `  ${f.snakeCase.padEnd(20)} ${f.prismaType}`;
+            if (f.isOptional)
+                line += '?';
+            if (f.isUnique)
+                line += ' @unique';
+            return line;
+        })
+            .join('\n');
+    }
+    else {
+        fieldsContent = `  // Add your fields here
+  // name                 String
+  // email                String    @unique`;
+    }
+    const content = `// =============================================================
+// Prisma Schema Snippet for ${entityNamePascal}
+// Add this to your prisma/schema.prisma file
+// =============================================================
+
+model ${entityNamePascal} {
+  id                   String    @id @default(uuid())
+${fieldsContent}
+  is_active            Boolean   @default(true)
+  created_at           DateTime  @default(now())
+  updated_at           DateTime  @updatedAt
+  deleted_at           DateTime?
+
+  @@map("${tableName}")
+}
+
+// =============================================================
+// After adding, run:
+//   npx prisma migrate dev --name add_${(0, naming_utils_1.toKebabCase)(entityName)}
+//   npx prisma generate
+// =============================================================
+`;
+    const snippetPath = path.join(basePath, `prisma/snippets/${(0, naming_utils_1.toKebabCase)(entityName)}.prisma`);
+    await (0, file_utils_1.writeGeneratedFile)(snippetPath, content, dryRun);
+    console.log(chalk_1.default.green(`   ✓ Prisma schema snippet: prisma/snippets/${(0, naming_utils_1.toKebabCase)(entityName)}.prisma`));
 }
 //# sourceMappingURL=generate-all.js.map