nestjs-ddd-cli/dist/commands/generate-all.js

CLI for generating NestJS DDD boilerplate code

"use strict";
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
    if (k2 === undefined) k2 = k;
    var desc = Object.getOwnPropertyDescriptor(m, k);
    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
      desc = { enumerable: true, get: function() { return m[k]; } };
    }
    Object.defineProperty(o, k2, desc);
}) : (function(o, m, k, k2) {
    if (k2 === undefined) k2 = k;
    o[k2] = m[k];
}));
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
    Object.defineProperty(o, "default", { enumerable: true, value: v });
}) : function(o, v) {
    o["default"] = v;
});
var __importStar = (this && this.__importStar) || (function () {
    var ownKeys = function(o) {
        ownKeys = Object.getOwnPropertyNames || function (o) {
            var ar = [];
            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
            return ar;
        };
        return ownKeys(o);
    };
    return function (mod) {
        if (mod && mod.__esModule) return mod;
        var result = {};
        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
        __setModuleDefault(result, mod);
        return result;
    };
})();
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.generateAll = generateAll;
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");
async function generateAll(entityName, options) {
    console.log(chalk_1.default.blue(`🚀 Generating complete scaffolding for: ${entityName}`));
    const moduleName = options.module || entityName;
    const basePath = options.path || process.cwd();
    const modulePath = (0, file_utils_1.getModulePath)(basePath, moduleName);
    // 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);
    }
    // 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 });
    }
    // Generate controller
    const templateData = (0, file_utils_1.prepareTemplateData)(entityName, moduleName);
    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);
    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) {
    const timestamp = Date.now();
    const tableName = (0, naming_utils_1.toKebabCase)(entityName).replace(/-/g, '_') + 's';
    const migrationName = `create_${tableName}_table`;
    const fileName = `${timestamp}-${migrationName}.ts`;
    const content = `import { MigrationInterface, QueryRunner, Table } from "typeorm";

export class Create${entityName}Table${timestamp} implements MigrationInterface {
  public async up(queryRunner: QueryRunner): Promise<void> {
    await queryRunner.createTable(
      new Table({
        name: "${tableName}",
        columns: [
          {
            name: "id",
            type: "uuid",
            isPrimary: true,
            generationStrategy: "uuid",
            default: "uuid_generate_v4()",
          },
          {
            name: "is_active",
            type: "boolean",
            default: true,
          },
          {
            name: "created_at",
            type: "timestamp",
            default: "CURRENT_TIMESTAMP",
          },
          {
            name: "updated_at",
            type: "timestamp",
            default: "CURRENT_TIMESTAMP",
          },
          {
            name: "deleted_at",
            type: "timestamp",
            isNullable: true,
          },
          // Add your custom columns here
        ],
      }),
      true,
    );
  }

  public async down(queryRunner: QueryRunner): Promise<void> {
    await queryRunner.dropTable("${tableName}");
  }
}
`;
    const migrationPath = path.join(basePath, 'src/migrations', fileName);
    await require('../utils/file.utils').writeFile(migrationPath, content);
    console.log(chalk_1.default.green(`   Migration: ${fileName}`));
}
//# sourceMappingURL=generate-all.js.map