nestjs-ddd-cli 3.2.1 → 3.3.0

package/dist/commands/generate-all.js

@@ -44,9 +44,18 @@ const generate_entity_1 = require("./generate-entity");
 const file_utils_1 = require("../utils/file.utils");
 const naming_utils_1 = require("../utils/naming.utils");
 const dependency_utils_1 = require("../utils/dependency.utils");
+const config_utils_1 = require("../utils/config.utils");
+const migration_1 = require("./migration");
 async function generateAll(entityName, options) {
     console.log(chalk_1.default.blue(`\n🚀 Generating complete scaffolding for: ${entityName}`));
-    const orm = options.orm || 'typeorm';
+    const basePath = options.path || process.cwd();
+    const config = await (0, config_utils_1.loadConfig)(basePath);
+    const orm = options.orm || config.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', '@nestjs/swagger'];
     if (orm === 'prisma') {
@@ -55,91 +64,116 @@ async function generateAll(entityName, options) {
     else {
         requiredDeps.push('typeorm', '@nestjs/typeorm');
     }
-    if (options.installDeps) {
+    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);
+        await (0, generate_module_1.generateModule)(moduleName, { ...options, dryRun });
     }
     // Prepare template data with fields
-    const templateData = (0, file_utils_1.prepareTemplateData)(entityName, moduleName, fieldsString);
+    const templateData = await (0, file_utils_1.prepareConfiguredTemplateData)(entityName, moduleName, {
+        basePath,
+        fieldsString,
+        orm,
+        features: {
+            ...config.features,
+            delete: options.delete === false ? false : config.features.delete,
+        },
+    });
     // Generate entity with all related files
-    await (0, generate_entity_1.generateEntity)(entityName, { ...options, module: moduleName, fields: fieldsString, orm, _fromGenerateAll: true });
+    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);
+        await generatePrismaService(basePath, dryRun);
     }
     // Generate CRUD commands
     console.log(chalk_1.default.cyan('  Generating commands...'));
-    await generateCommand('create', entityName, modulePath, templateData);
-    await generateCommand('update', entityName, modulePath, templateData);
-    await generateCommand('delete', entityName, modulePath, templateData);
+    await generateCommand('create', entityName, modulePath, templateData, dryRun);
+    await generateCommand('update', entityName, modulePath, templateData, dryRun);
+    if (templateData.deleteEnabled) {
+        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);
-    await generateUseCase('update', entityName, modulePath, templateData);
-    await generateUseCase('delete', entityName, modulePath, templateData);
+    await generateUseCase('create', entityName, modulePath, templateData, dryRun);
+    await generateUseCase('update', entityName, modulePath, templateData, dryRun);
+    if (templateData.deleteEnabled) {
+        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);
-    await generateQueryHandler('get-all', entityName, modulePath, templateData);
+    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);
-    await generateDto('update', entityName, modulePath, templateData);
-    await generateDto('response', entityName, modulePath, templateData);
-    await generatePaginationDtos(modulePath);
+    await generateDto('create', entityName, modulePath, templateData, dryRun);
+    await generateDto('update', entityName, modulePath, templateData, dryRun);
+    await generateDto('response', entityName, modulePath, templateData, dryRun);
+    await generatePaginationDtos(modulePath, templateData, dryRun);
     // Generate controller
     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);
+    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);
+        await generatePrismaSchemaSnippet(entityName, basePath, templateData, dryRun);
     }
     else {
         console.log(chalk_1.default.cyan('  Generating migration...'));
-        await generateMigration(entityName, basePath, templateData);
+        await generateMigration(entityName, basePath, templateData, dryRun);
     }
     // Generate barrel exports
     console.log(chalk_1.default.cyan('  Generating barrel exports...'));
-    await generateBarrelExports(entityName, modulePath, orm);
+    await generateBarrelExports(entityName, modulePath, orm, dryRun, templateData.deleteEnabled);
     // Generate tests if requested
     if (options.withTests) {
         console.log(chalk_1.default.cyan('  Generating tests...'));
-        await generateTests(entityName, modulePath, templateData);
+        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);
+        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 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('Commands:')} Create, Update${templateData.deleteEnabled ? ', 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('Use Cases:')} Create, Update${templateData.deleteEnabled ? ', 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('Controller:')} ${templateData.deleteEnabled ? 'Full CRUD' : 'Create, read, and update'} 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.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`);
@@ -152,24 +186,39 @@ async function generateAll(entityName, options) {
         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(`/${(0, naming_utils_1.toKebabCase)(entityName)}s`)}`);
+    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) {
+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);
+    await (0, file_utils_1.generateFromTemplate)(templatePath, outputPath, templateData, dryRun);
 }
-async function generateUseCase(action, entityName, modulePath, templateData) {
+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);
+    await (0, file_utils_1.generateFromTemplate)(templatePath, outputPath, templateData, dryRun);
 }
-async function generateQueryHandler(type, entityName, modulePath, templateData) {
+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', `${type}-${(0, naming_utils_1.toKebabCase)(entityName)}${type === 'get-all' ? 's' : ''}.query.ts`);
-    await (0, file_utils_1.generateFromTemplate)(templatePath, outputPath, templateData);
+    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) {
+async function generateDto(type, entityName, modulePath, templateData, dryRun = false) {
     const templateMap = {
         create: 'create-dto.hbs',
         update: 'update-dto.hbs',
@@ -187,34 +236,42 @@ async function generateDto(type, entityName, modulePath, templateData) {
     };
     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);
+    await (0, file_utils_1.generateFromTemplate)(templatePath, outputPath, templateData, dryRun);
 }
-async function generatePaginationDtos(modulePath) {
+async function generatePaginationDtos(modulePath, templateData, 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'));
+        await (0, file_utils_1.generateFromTemplate)(paginationQueryTemplatePath, paginationQueryOutputPath, templateData, 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'));
+        await (0, file_utils_1.generateFromTemplate)(paginatedResponseTemplatePath, paginatedResponseOutputPath, templateData, dryRun);
     }
 }
-async function generateMigration(entityName, basePath, templateData) {
+async function generateMigration(entityName, basePath, templateData, dryRun = false) {
     const timestamp = Date.now();
     const tableName = templateData.tableName;
     const migrationName = `create_${tableName}_table`;
     const fileName = `${timestamp}-${migrationName}.ts`;
-    const fieldsColumns = templateData.migrationColumns || `          // Add your custom columns here
+    const fieldsColumns = templateData.migrationColumns ||
+        `          // Add your custom columns here
           // Example:
           // {
           //   name: "name",
           //   type: "varchar",
           //   isNullable: false,
           // },`;
+    const softDeleteColumn = templateData.softDelete
+        ? `          {
+            name: "deleted_at",
+            type: "timestamp",
+            isNullable: true,
+          },`
+        : '';
     const content = `import { MigrationInterface, QueryRunner, Table } from "typeorm";
 
 export class Create${(0, naming_utils_1.toPascalCase)(entityName)}Table${timestamp} implements MigrationInterface {
@@ -246,11 +303,7 @@ ${fieldsColumns}
             type: "timestamp",
             default: "CURRENT_TIMESTAMP",
           },
-          {
-            name: "deleted_at",
-            type: "timestamp",
-            isNullable: true,
-          },
+${softDeleteColumn}
         ],
       }),
       true,
@@ -262,163 +315,172 @@ ${fieldsColumns}
   }
 }
 `;
-    const migrationPath = path.join(basePath, 'src/migrations', fileName);
-    await (0, file_utils_1.writeFile)(migrationPath, content);
+    const config = await (0, config_utils_1.loadConfig)(basePath);
+    const migrationsDir = (0, migration_1.resolveMigrationOutputPath)(basePath, config.paths.migrations, 'src/migrations');
+    const migrationPath = path.join(migrationsDir, 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') {
+async function generateBarrelExports(entityName, modulePath, orm = 'typeorm', dryRun = false, deleteEnabled = true) {
     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');
-    const commandsIndexContent = `export * from './create-${entityNameKebab}.command';
-export * from './update-${entityNameKebab}.command';
-export * from './delete-${entityNameKebab}.command';
-
-import { Create${entityNamePascal}Handler } from './create-${entityNameKebab}.command';
-import { Update${entityNamePascal}Handler } from './update-${entityNameKebab}.command';
-import { Delete${entityNamePascal}Handler } from './delete-${entityNameKebab}.command';
-
-export const CommandHandlers = [
-  Create${entityNamePascal}Handler,
-  Update${entityNamePascal}Handler,
-  Delete${entityNamePascal}Handler,
-];
-`;
-    await (0, file_utils_1.writeFile)(commandsIndexPath, commandsIndexContent);
+    await (0, file_utils_1.updateBarrelFile)(commandsIndexPath, {
+        exports: [
+            `export * from './create-${entityNameKebab}.command';`,
+            `export * from './update-${entityNameKebab}.command';`,
+            ...(deleteEnabled ? [`export * from './delete-${entityNameKebab}.command';`] : []),
+        ],
+        imports: [
+            `import { Create${entityNamePascal}Handler } from './create-${entityNameKebab}.command';`,
+            `import { Update${entityNamePascal}Handler } from './update-${entityNameKebab}.command';`,
+            ...(deleteEnabled
+                ? [`import { Delete${entityNamePascal}Handler } from './delete-${entityNameKebab}.command';`]
+                : []),
+        ],
+        arrayName: 'CommandHandlers',
+        arrayItems: [
+            `Create${entityNamePascal}Handler`,
+            `Update${entityNamePascal}Handler`,
+            ...(deleteEnabled ? [`Delete${entityNamePascal}Handler`] : []),
+        ],
+        dryRun,
+    });
     // Queries index
     const queriesIndexPath = path.join(modulePath, 'application/queries/index.ts');
-    const entityNamePluralPascal = (0, naming_utils_1.toPascalCase)(entityName) + 's';
-    const queriesIndexContent = `export * from './get-${entityNameKebab}-by-id.query';
-export * from './get-all-${entityNameKebab}s.query';
-
-import { Get${entityNamePascal}ByIdHandler } from './get-${entityNameKebab}-by-id.query';
-import { GetAll${entityNamePluralPascal}Handler } from './get-all-${entityNameKebab}s.query';
-
-export const Queries = [
-  Get${entityNamePascal}ByIdHandler,
-  GetAll${entityNamePluralPascal}Handler,
-];
-`;
-    await (0, file_utils_1.writeFile)(queriesIndexPath, queriesIndexContent);
+    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');
-    const useCasesIndexContent = `export * from './create-${entityNameKebab}.use-case';
-export * from './update-${entityNameKebab}.use-case';
-export * from './delete-${entityNameKebab}.use-case';
-
-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';
-
-export const UseCases = [
-  Create${entityNamePascal}UseCase,
-  Update${entityNamePascal}UseCase,
-  Delete${entityNamePascal}UseCase,
-];
-`;
-    await (0, file_utils_1.writeFile)(useCasesIndexPath, useCasesIndexContent);
+    await (0, file_utils_1.updateBarrelFile)(useCasesIndexPath, {
+        exports: [
+            `export * from './create-${entityNameKebab}.use-case';`,
+            `export * from './update-${entityNameKebab}.use-case';`,
+            ...(deleteEnabled ? [`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';`,
+            ...(deleteEnabled
+                ? [`import { Delete${entityNamePascal}UseCase } from './delete-${entityNameKebab}.use-case';`]
+                : []),
+        ],
+        arrayName: 'UseCases',
+        arrayItems: [
+            `Create${entityNamePascal}UseCase`,
+            `Update${entityNamePascal}UseCase`,
+            ...(deleteEnabled ? [`Delete${entityNamePascal}UseCase`] : []),
+        ],
+        dryRun,
+    });
     // DTOs index
     const dtosIndexPath = path.join(modulePath, 'application/dto/index.ts');
-    const dtosIndexContent = `export * from './requests';
-export * from './responses';
-`;
-    await (0, file_utils_1.writeFile)(dtosIndexPath, dtosIndexContent);
+    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');
-    const requestsIndexContent = `export * from './create-${entityNameKebab}.dto';
-export * from './update-${entityNameKebab}.dto';
-export * from './pagination.query.dto';
-`;
-    await (0, file_utils_1.writeFile)(requestsIndexPath, requestsIndexContent);
+    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');
-    const responsesIndexContent = `export * from './${entityNameKebab}.response.dto';
-export * from './paginated.response.dto';
-`;
-    await (0, file_utils_1.writeFile)(responsesIndexPath, responsesIndexContent);
+    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');
-    const controllersIndexContent = `export * from './${entityNameKebab}.controller';
-
-import { ${entityNamePascal}Controller } from './${entityNameKebab}.controller';
-
-export const Controllers = [${entityNamePascal}Controller];
-`;
-    await (0, file_utils_1.writeFile)(controllersIndexPath, controllersIndexContent);
+    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');
-    const entitiesIndexContent = `export * from './${entityNameKebab}.entity';
-`;
-    await (0, file_utils_1.writeFile)(entitiesIndexPath, entitiesIndexContent);
+    await (0, file_utils_1.updateBarrelFile)(entitiesIndexPath, {
+        exports: [`export * from './${entityNameKebab}.entity';`],
+        dryRun,
+    });
     // Repositories index
     const repositoriesIndexPath = path.join(modulePath, 'infrastructure/repositories/index.ts');
-    const repositoriesIndexContent = `export * from './${entityNameKebab}.repository';
-
-import { ${entityNamePascal}Repository } from './${entityNameKebab}.repository';
-
-export const Repositories = [${entityNamePascal}Repository];
-`;
-    await (0, file_utils_1.writeFile)(repositoriesIndexPath, repositoriesIndexContent);
+    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');
-    const mappersIndexContent = `export * from './${entityNameKebab}.mapper';
-
-import { ${entityNamePascal}Mapper } from './${entityNameKebab}.mapper';
-
-export const Mappers = [${entityNamePascal}Mapper];
-`;
-    await (0, file_utils_1.writeFile)(mappersIndexPath, mappersIndexContent);
+    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');
-        const ormEntitiesIndexContent = `export * from './${entityNameKebab}.orm-entity';
-
-import { ${entityNamePascal}OrmEntity } from './${entityNameKebab}.orm-entity';
-
-export const OrmEntities = [${entityNamePascal}OrmEntity];
-`;
-        await (0, file_utils_1.writeFile)(ormEntitiesIndexPath, ormEntitiesIndexContent);
+        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,
+        });
     }
-    // Services index (empty for now)
-    const servicesIndexPath = path.join(modulePath, 'application/domain/services/index.ts');
-    const servicesIndexContent = `// Export your domain services here
-// import { YourService } from './your.service';
-// export const Services = [YourService];
-
-export const Services: any[] = [];
-`;
-    await (0, file_utils_1.writeFile)(servicesIndexPath, servicesIndexContent);
-    // Events index (empty for now)
-    const eventsIndexPath = path.join(modulePath, 'application/domain/events/index.ts');
-    const eventsIndexContent = `// Export your domain events here
-// export * from './your-event.event';
-`;
-    await (0, file_utils_1.writeFile)(eventsIndexPath, eventsIndexContent);
 }
-async function generateTests(entityName, modulePath, templateData) {
+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 repoTestTemplatePath = templateData.isPrisma
+        ? path.join(__dirname, '../templates/test/prisma-repository.spec.hbs')
+        : 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);
+    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);
+    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);
+    await (0, file_utils_1.generateFromTemplate)(controllerTestTemplatePath, controllerTestOutputPath, templateData, dryRun);
     console.log(chalk_1.default.green(`   ✓ Controller test`));
 }
-async function generateGraphQL(entityName, modulePath, templateData) {
+async function generateGraphQL(entityName, modulePath, templateData, 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)(templateData.entityNamePlural);
     // Create GraphQL directories
     const graphqlPath = path.join(modulePath, 'application/graphql');
     const typesPath = path.join(graphqlPath, 'types');
@@ -427,35 +489,35 @@ async function generateGraphQL(entityName, modulePath, templateData) {
     // 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);
+    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);
+    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);
+    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);
+        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.writeFile)(path.join(typesPath, 'index.ts'), typesIndexContent);
+    await (0, file_utils_1.writeGeneratedFile)(path.join(typesPath, 'index.ts'), typesIndexContent, dryRun);
     const inputsIndexContent = `export * from "./${entityNameKebab}.input";
 `;
-    await (0, file_utils_1.writeFile)(path.join(inputsPath, 'index.ts'), inputsIndexContent);
+    await (0, file_utils_1.writeGeneratedFile)(path.join(inputsPath, 'index.ts'), inputsIndexContent, dryRun);
     const argsIndexContent = `export * from "./pagination.args";
 `;
-    await (0, file_utils_1.writeFile)(path.join(argsPath, 'index.ts'), argsIndexContent);
+    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";
@@ -465,9 +527,9 @@ import { ${entityNamePascal}Resolver } from "./${entityNameKebab}.resolver";
 
 export const Resolvers = [${entityNamePascal}Resolver];
 `;
-    await (0, file_utils_1.writeFile)(path.join(graphqlPath, 'index.ts'), graphqlIndexContent);
+    await (0, file_utils_1.writeGeneratedFile)(path.join(graphqlPath, 'index.ts'), graphqlIndexContent, dryRun);
 }
-async function generatePrismaService(basePath) {
+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...`));
@@ -525,7 +587,7 @@ export class PrismaService extends PrismaClient implements OnModuleInit, OnModul
   }
 }
 `;
-    await (0, file_utils_1.writeFile)(prismaServicePath, content);
+    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');
@@ -540,7 +602,7 @@ import { PrismaService } from "./prisma.service";
 })
 export class PrismaModule {}
 `;
-        await (0, file_utils_1.writeFile)(prismaModulePath, moduleContent);
+        await (0, file_utils_1.writeGeneratedFile)(prismaModulePath, moduleContent, dryRun);
         console.log(chalk_1.default.green(`   ✓ PrismaModule`));
     }
     // Generate index.ts
@@ -549,10 +611,10 @@ export class PrismaModule {}
         const indexContent = `export * from "./prisma.service";
 export * from "./prisma.module";
 `;
-        await (0, file_utils_1.writeFile)(indexPath, indexContent);
+        await (0, file_utils_1.writeGeneratedFile)(indexPath, indexContent, dryRun);
     }
 }
-async function generatePrismaSchemaSnippet(entityName, basePath, templateData) {
+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
@@ -585,7 +647,7 @@ ${fieldsContent}
   is_active            Boolean   @default(true)
   created_at           DateTime  @default(now())
   updated_at           DateTime  @updatedAt
-  deleted_at           DateTime?
+${templateData.softDelete ? '  deleted_at           DateTime?' : ''}
 
   @@map("${tableName}")
 }
@@ -597,7 +659,7 @@ ${fieldsContent}
 // =============================================================
 `;
     const snippetPath = path.join(basePath, `prisma/snippets/${(0, naming_utils_1.toKebabCase)(entityName)}.prisma`);
-    await (0, file_utils_1.writeFile)(snippetPath, content);
+    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