@diagramers/cli 4.0.19 → 4.0.21

package/dist/services/project-extender.js

@@ -125,39 +125,108 @@ class ProjectExtender {
         const projectPath = process.cwd();
         // Check if module already exists
         const modulePath = path.join(projectPath, 'src', 'modules', moduleName);
-        if (await fs.pathExists(modulePath)) {
-            throw new Error(`Module '${moduleName}' already exists in this project.`);
+        if (await fs.pathExists(modulePath) && !options.force) {
+            throw new Error(`Module '${moduleName}' already exists. Use --force to override.`);
         }
-        console.log(chalk_1.default.blue(`📁 Creating module structure for: ${moduleName}`));
-        // Create module directory structure
-        await this.createModuleStructure(projectPath, moduleName, options);
+        // Parse options
+        const fields = options.fields || ['name', 'description', 'status'];
+        const generateRoutes = options.generateRoutes !== false;
+        const generateDatabase = options.generateDatabase !== false;
+        const crud = options.crud || false;
+        console.log(chalk_1.default.blue(`📦 Generating module '${moduleName}'...`));
+        // Create module structure
+        await this.createModuleStructure(projectPath, moduleName, { fields, crud, generateRoutes, generateDatabase });
         // Generate CRUD operations if requested
-        if (options.crud) {
-            await this.generateCRUDOperations(projectPath, moduleName, options);
+        if (crud) {
+            console.log(chalk_1.default.blue('🔧 Generating CRUD operations...'));
+            await this.generateCRUDOperations(projectPath, moduleName, { fields });
         }
-        // Update main application to include the module
+        // Register module
         await this.registerModule(projectPath, moduleName);
-        // Update database seeder
-        await this.updateSeeder(projectPath, moduleName);
+        // Update configuration
+        await this.updateDiagramersConfig(projectPath, moduleName);
         console.log(chalk_1.default.green(`✅ Module '${moduleName}' generated successfully!`));
+        console.log(chalk_1.default.blue(`📁 Location: src/modules/${moduleName}/`));
+        if (generateRoutes) {
+            console.log(chalk_1.default.blue(`🔗 Routes: /api/${moduleName}s`));
+        }
+        if (generateDatabase) {
+            console.log(chalk_1.default.blue(`🗄️ Database: ${moduleName} collection`));
+        }
+        if (crud) {
+            console.log(chalk_1.default.blue(`🔧 CRUD: Full CRUD operations included`));
+        }
     }
     async generateTable(tableName, options = {}) {
         const projectPath = process.cwd();
-        console.log(chalk_1.default.blue(`🗄️  Generating table schema for: ${tableName}`));
-        // Create table schema based on database type
-        await this.createTableSchema(projectPath, tableName, options);
+        // Parse options
+        const fields = options.fields || ['name', 'description', 'status'];
+        const databaseType = options.type || 'mongodb';
+        const generateSeeder = options.seeder !== false;
+        const force = options.force || false;
+        console.log(chalk_1.default.blue(`🗄️ Generating table '${tableName}'...`));
+        // Create table schema
+        await this.createTableSchema(projectPath, tableName, { fields, type: databaseType, force });
+        // Add to seeder if requested
+        if (generateSeeder) {
+            console.log(chalk_1.default.blue('🌱 Adding to database seeder...'));
+            await this.updateSeeder(projectPath, tableName);
+        }
         console.log(chalk_1.default.green(`✅ Table '${tableName}' generated successfully!`));
+        console.log(chalk_1.default.blue(`📁 Schema: src/modules/${tableName}/schemas/${tableName}.schema.ts`));
+        console.log(chalk_1.default.blue(`🗄️ Database Type: ${databaseType}`));
+        if (generateSeeder) {
+            console.log(chalk_1.default.blue(`🌱 Seeder: Added to src/core/database/seeder.ts`));
+        }
     }
     async generateRelations(relationName, options = {}) {
-        const projectPath = process.cwd();
-        console.log(chalk_1.default.blue(`🔗 Generating relations for: ${relationName}`));
-        // Create relation definitions
-        await this.createRelations(projectPath, relationName, options);
-        console.log(chalk_1.default.green(`✅ Relations '${relationName}' generated successfully!`));
+        console.log(chalk_1.default.blue(`🔗 Generating relations for '${relationName}'...`));
+        // Parse options
+        const relationType = options.type || 'one-to-many';
+        const moduleName = options.module;
+        const force = options.force || false;
+        // For now, we'll use a simple approach - the user needs to specify both tables
+        if (!options.table1 || !options.table2) {
+            throw new Error('Both table1 and table2 must be specified for relation generation. Use: --table1 <name> --table2 <name>');
+        }
+        // Import and use the relation-generator service
+        const { generateRelation } = await Promise.resolve().then(() => __importStar(require('./relation-generator')));
+        await generateRelation(moduleName, options.table1, options.table2, relationType, { force });
+        console.log(chalk_1.default.green(`✅ Relations generated successfully for '${relationName}'!`));
+        console.log(chalk_1.default.blue(`🔗 Type: ${relationType}`));
+        console.log(chalk_1.default.blue(`📦 Module: ${moduleName}`));
+        console.log(chalk_1.default.blue(`🗄️ Tables: ${options.table1} ↔ ${options.table2}`));
     }
     async generateEndpoint(moduleName, endpointName, options = {}) {
-        // Delegate to the working implementation in api-generator
-        await (0, api_generator_1.generateEndpoint)(moduleName, endpointName, options);
+        console.log(chalk_1.default.blue(`🔧 Adding endpoint '${endpointName}' to module '${moduleName}'...`));
+        // Parse options
+        const method = options.method || 'GET';
+        const customPath = options.path || endpointName;
+        const description = options.description || `${endpointName} endpoint for ${moduleName}`;
+        const generateService = options.generateService !== false;
+        const generateController = options.generateController !== false;
+        const generateRoute = options.generateRoute !== false;
+        const force = options.force || false;
+        // Pass options to the api-generator service
+        await (0, api_generator_1.generateEndpoint)(moduleName, endpointName, {
+            method,
+            path: customPath,
+            description,
+            generateService,
+            generateController,
+            generateRoute,
+            force
+        });
+        console.log(chalk_1.default.green(`✅ Endpoint '${endpointName}' added to module '${moduleName}' successfully!`));
+        if (generateService) {
+            console.log(chalk_1.default.blue(`📝 Service method generated`));
+        }
+        if (generateController) {
+            console.log(chalk_1.default.blue(`🎮 Controller method generated`));
+        }
+        if (generateRoute) {
+            console.log(chalk_1.default.blue(`🛣️ Route generated`));
+        }
     }
     async addServiceMethod(modulePath, moduleName, endpointName, method, description) {
         const singularName = moduleName; // Use exact name provided by developer
@@ -1129,6 +1198,9 @@ export class ${capitalizedName}Feature {
     }
     async createModuleStructure(projectPath, moduleName, options) {
         const modulePath = path.join(projectPath, 'src', 'modules', moduleName);
+        // Convert module name to valid TypeScript identifiers
+        const moduleNameCamelCase = moduleName.replace(/[-_]([a-z0-9])/g, (_, char) => char.toUpperCase());
+        const moduleNameCapitalized = moduleNameCamelCase.charAt(0).toUpperCase() + moduleNameCamelCase.slice(1);
         // Create module directory structure
         const structure = {
             'entities': 'Data models and interfaces',
@@ -1140,26 +1212,26 @@ export class ${capitalizedName}Feature {
         for (const [dir, description] of Object.entries(structure)) {
             const dirPath = path.join(modulePath, dir);
             await fs.ensureDir(dirPath);
-            // Create index file with correct file extensions
+            // Create index file with correct file extensions - use camelCase for file names
             let fileName = '';
             switch (dir) {
                 case 'entities':
-                    fileName = `${moduleName}.entity`;
+                    fileName = `${moduleNameCamelCase}.entity`;
                     break;
                 case 'schemas':
-                    fileName = `${moduleName}.schema`;
+                    fileName = `${moduleNameCamelCase}.schema`;
                     break;
                 case 'services':
-                    fileName = `${moduleName}.service`;
+                    fileName = `${moduleNameCamelCase}.service`;
                     break;
                 case 'controllers':
-                    fileName = `${moduleName}.controller`;
+                    fileName = `${moduleNameCamelCase}.controller`;
                     break;
                 case 'routes':
-                    fileName = `${moduleName}.routes`;
+                    fileName = `${moduleNameCamelCase}.routes`;
                     break;
                 default:
-                    fileName = `${moduleName}.${dir.slice(0, -1)}`;
+                    fileName = `${moduleNameCamelCase}.${dir.slice(0, -1)}`;
             }
             const indexContent = `// ${description} for ${moduleName} module
 export * from './${fileName}';
@@ -1167,22 +1239,23 @@ export * from './${fileName}';
             await fs.writeFile(path.join(dirPath, 'index.ts'), indexContent);
         }
         // Create main entity
-        await this.createEntity(modulePath, moduleName, options);
+        await this.createEntity(modulePath, moduleNameCamelCase, options);
         // Create schema
-        await this.createSchema(modulePath, moduleName, options);
+        await this.createSchema(modulePath, moduleNameCamelCase, options);
         // Create service
-        await this.createService(modulePath, moduleName, options);
+        await this.createService(modulePath, moduleNameCamelCase, options);
         // Create controller
-        await this.createController(modulePath, moduleName, options);
+        await this.createController(modulePath, moduleNameCamelCase, options);
         // Create routes
-        await this.createRoutes(modulePath, moduleName, options);
+        await this.createRoutes(modulePath, moduleNameCamelCase, options);
     }
-    async createEntity(modulePath, moduleName, options) {
-        const entityName = this.capitalizeFirst(moduleName);
+    async createEntity(modulePath, moduleNameCamelCase, options) {
+        // Convert module name to valid TypeScript identifiers
+        const moduleNameCapitalized = moduleNameCamelCase.charAt(0).toUpperCase() + moduleNameCamelCase.slice(1);
         const entityContent = `import * as mongoose from 'mongoose';
 import { ObjectId } from "bson";
 
-export interface I${entityName} extends mongoose.Document {
+export interface I${moduleNameCapitalized} extends mongoose.Document {
     _id: ObjectId,
     name: string,
     description?: string,
@@ -1190,14 +1263,15 @@ export interface I${entityName} extends mongoose.Document {
     createdAt: Date,
     updatedAt: Date
 }`;
-        await fs.writeFile(path.join(modulePath, 'entities', `${moduleName}.entity.ts`), entityContent);
+        await fs.writeFile(path.join(modulePath, 'entities', `${moduleNameCamelCase}.entity.ts`), entityContent);
     }
-    async createSchema(modulePath, moduleName, options) {
-        const entityName = this.capitalizeFirst(moduleName);
+    async createSchema(modulePath, moduleNameCamelCase, options) {
+        // Convert module name to valid TypeScript identifiers
+        const moduleNameCapitalized = moduleNameCamelCase.charAt(0).toUpperCase() + moduleNameCamelCase.slice(1);
         const schemaContent = `import * as mongoose from 'mongoose';
-import { I${entityName} } from '../entities/${moduleName}.entity';
+import { I${moduleNameCapitalized} } from '../entities/${moduleNameCamelCase}.entity';
 
-export const ${moduleName}Schema = new mongoose.Schema(
+export const ${moduleNameCamelCase}Schema = new mongoose.Schema(
     {
         name: {
             type: mongoose.SchemaTypes.String,
@@ -1215,57 +1289,117 @@ export const ${moduleName}Schema = new mongoose.Schema(
     { timestamps: true, suppressReservedKeysWarning: true },
 );
 
-export const ${entityName}Model = mongoose.model<I${entityName}>('${moduleName}', ${moduleName}Schema);`;
-        await fs.writeFile(path.join(modulePath, 'schemas', `${moduleName}.schema.ts`), schemaContent);
+export const ${moduleNameCapitalized}Model = mongoose.model<I${moduleNameCapitalized}>('${moduleNameCapitalized}', ${moduleNameCamelCase}Schema);`;
+        await fs.writeFile(path.join(modulePath, 'schemas', `${moduleNameCamelCase}.schema.ts`), schemaContent);
     }
-    async createService(modulePath, moduleName, options) {
-        const entityName = this.capitalizeFirst(moduleName);
+    async createService(modulePath, moduleNameCamelCase, options) {
+        // Convert module name to valid TypeScript identifiers
+        const moduleNameCapitalized = moduleNameCamelCase.charAt(0).toUpperCase() + moduleNameCamelCase.slice(1);
         const serviceContent = `import { ObjectId } from "bson";
-import { ${entityName}Model } from '../schemas/${moduleName}.schema';
+import { ${moduleNameCapitalized}Model } from '../schemas/${moduleNameCamelCase}.schema';
 
-export class ${entityName}Service {
+export class ${moduleNameCapitalized}Service {
     async getAll() {
-        return await ${entityName}Model.find({ status: 1 });
+        try {
+            const data = await ${moduleNameCapitalized}Model.find({ status: 1 });
+            return {
+                Data: data,
+                StatusCode: 1000,
+                Message: '${moduleNameCapitalized}s retrieved successfully'
+            };
+        } catch (error) {
+            throw new Error(\`Failed to retrieve ${moduleNameCamelCase}s: \${error.message}\`);
+        }
     }
+    
     async getById(id: string) {
-        return await ${entityName}Model.findById(id);
+        try {
+            const data = await ${moduleNameCapitalized}Model.findById(id);
+            if (!data) {
+                throw new Error('${moduleNameCapitalized} not found');
+            }
+            return {
+                Data: data,
+                StatusCode: 1000,
+                Message: '${moduleNameCapitalized} retrieved successfully'
+            };
+        } catch (error) {
+            throw new Error(\`Failed to retrieve ${moduleNameCamelCase}: \${error.message}\`);
+        }
     }
+    
     async create(data: any) {
-        const entity = new ${entityName}Model({ _id: new ObjectId(), ...data, status: 1 });
-        return await ${entityName}Model.create(entity);
+        try {
+            const entity = new ${moduleNameCapitalized}Model({ _id: new ObjectId(), ...data, status: 1 });
+            const result = await ${moduleNameCapitalized}Model.create(entity);
+            return {
+                Data: result,
+                StatusCode: 1000,
+                Message: '${moduleNameCapitalized} created successfully'
+            };
+        } catch (error) {
+            throw new Error(\`Failed to create ${moduleNameCamelCase}: \${error.message}\`);
+        }
     }
+    
     async update(id: string, data: any) {
-        return await ${entityName}Model.findByIdAndUpdate(id, { ...data }, { new: true });
+        try {
+            const result = await ${moduleNameCapitalized}Model.findByIdAndUpdate(id, { ...data }, { new: true });
+            if (!result) {
+                throw new Error('${moduleNameCapitalized} not found');
+            }
+            return {
+                Data: result,
+                StatusCode: 1000,
+                Message: '${moduleNameCapitalized} updated successfully'
+            };
+        } catch (error) {
+            throw new Error(\`Failed to update ${moduleNameCamelCase}: \${error.message}\`);
+        }
     }
+    
     async delete(id: string) {
-        return await ${entityName}Model.findByIdAndUpdate(id, { status: 0 }, { new: true });
+        try {
+            const result = await ${moduleNameCapitalized}Model.findByIdAndUpdate(id, { status: 0 }, { new: true });
+            if (!result) {
+                throw new Error('${moduleNameCapitalized} not found');
+            }
+            return {
+                Data: true,
+                StatusCode: 1000,
+                Message: '${moduleNameCapitalized} deleted successfully'
+            };
+        } catch (error) {
+            throw new Error(\`Failed to delete ${moduleNameCamelCase}: \${error.message}\`);
+        }
     }
 }`;
-        await fs.writeFile(path.join(modulePath, 'services', `${moduleName}.service.ts`), serviceContent);
+        await fs.writeFile(path.join(modulePath, 'services', `${moduleNameCamelCase}.service.ts`), serviceContent);
     }
-    async createController(modulePath, moduleName, options) {
-        const entityName = this.capitalizeFirst(moduleName);
-        const controllerContent = `import { ${entityName}Service } from '../services/${moduleName}.service';
+    async createController(modulePath, moduleNameCamelCase, options) {
+        // Convert module name to valid TypeScript identifiers
+        const moduleNameCapitalized = moduleNameCamelCase.charAt(0).toUpperCase() + moduleNameCamelCase.slice(1);
+        const controllerContent = `import { ${moduleNameCapitalized}Service } from '../services/${moduleNameCamelCase}.service';
 
 /**
  * @openapi
  * components:
  *   schemas:
- *     ${entityName}:
+ *     ${moduleNameCapitalized}:
  *       type: object
  *       properties:
  *         _id:
  *           type: string
- *           description: ${entityName} ID
+ *           description: ${moduleNameCapitalized} ID
  *         name:
  *           type: string
- *           description: Name of the ${moduleName}
+ *           description: Name of the ${moduleNameCapitalized}
  *         description:
  *           type: string
- *           description: Description of the ${moduleName}
+ *           description: Description of the ${moduleNameCapitalized}
  *         status:
  *           type: integer
- *           description: Status of the ${moduleName} (1 - active, 0 - deleted)
+ *           description: Status of the ${moduleNameCapitalized} (1 - active, 0 - deleted)
  *         createdAt:
  *           type: string
  *           format: date-time
@@ -1282,19 +1416,19 @@ export class ${entityName}Service {
  *         - updatedAt
  */
 
-export class ${entityName}Controller {
-    private service = new ${entityName}Service();
+export class ${moduleNameCapitalized}Controller {
+    private service = new ${moduleNameCapitalized}Service();
 
     /**
      * @openapi
-     * /api/${moduleName}:
+     * /api/${moduleNameCamelCase}:
      *   get:
-     *     summary: Get all ${moduleName}s
-     *     description: Retrieve a list of all active ${moduleName}s
-     *     tags: [${entityName}s]
+     *     summary: Get all ${moduleNameCapitalized}s
+     *     description: Retrieve a list of all active ${moduleNameCapitalized}s
+     *     tags: [${moduleNameCapitalized}s]
      *     responses:
      *       200:
-     *         description: List of ${moduleName}s retrieved successfully
+     *         description: List of ${moduleNameCapitalized}s retrieved successfully
      *         content:
      *           application/json:
      *             schema:
@@ -1303,7 +1437,7 @@ export class ${entityName}Controller {
      *                 Data:
      *                   type: array
      *                   items:
-     *                     $ref: '#/components/schemas/${entityName}'
+     *                     $ref: '#/components/schemas/${moduleNameCapitalized}'
      *                 StatusCode:
      *                   type: integer
      *                   example: 1000
@@ -1311,52 +1445,68 @@ export class ${entityName}Controller {
      *         description: Bad request
      */
     async getAll(req, res) {
-        const data = await this.service.getAll();
-        res.json(data);
+        try {
+            const data = await this.service.getAll();
+            res.json(data);
+        } catch (error) {
+            res.status(400).json({
+                Data: null,
+                StatusCode: 4000,
+                Message: error.message
+            });
+        }
     }
 
     /**
      * @openapi
-     * /api/${moduleName}/{id}:
+     * /api/${moduleNameCamelCase}/{id}:
      *   get:
-     *     summary: Get ${moduleName} by ID
-     *     description: Retrieve a specific ${moduleName} by its ID
-     *     tags: [${entityName}s]
+     *     summary: Get ${moduleNameCapitalized} by ID
+     *     description: Retrieve a specific ${moduleNameCapitalized} by its ID
+     *     tags: [${moduleNameCapitalized}s]
      *     parameters:
      *       - in: path
      *         name: id
      *         required: true
      *         schema:
      *           type: string
-     *         description: ${entityName} ID
+     *         description: ${moduleNameCapitalized} ID
      *     responses:
      *       200:
-     *         description: ${entityName} retrieved successfully
+     *         description: ${moduleNameCapitalized} retrieved successfully
      *         content:
      *           application/json:
      *             schema:
      *               type: object
      *               properties:
      *                 Data:
-     *                   $ref: '#/components/schemas/${entityName}'
+     *                   $ref: '#/components/schemas/${moduleNameCapitalized}'
      *                 StatusCode:
      *                   type: integer
      *                   example: 1000
      *       404:
-     *         description: ${entityName} not found
+     *         description: ${moduleNameCapitalized} not found
      */
     async getById(req, res) {
-        const data = await this.service.getById(req.params.id);
-        res.json(data);
+        try {
+            const data = await this.service.getById(req.params.id);
+            res.json(data);
+        } catch (error) {
+            res.status(404).json({
+                Data: null,
+                StatusCode: 4004,
+                Message: error.message
+            });
+        }
     }
 
     /**
      * @openapi
-     * /api/${moduleName}:
+     * /api/${moduleNameCamelCase}:
      *   post:
-     *     summary: Create new ${moduleName}
-     *     description: Create a new ${moduleName} record
-     *     tags: [${entityName}s]
+     *     summary: Create new ${moduleNameCapitalized}
+     *     description: Create a new ${moduleNameCapitalized} record
+     *     tags: [${moduleNameCapitalized}s]
      *     requestBody:
      *       required: true
      *       content:
@@ -1368,24 +1518,24 @@ export class ${entityName}Controller {
      *             properties:
      *               name:
      *                 type: string
-     *                 description: Name of the ${moduleName}
+     *                 description: Name of the ${moduleNameCapitalized}
      *               description:
      *                 type: string
-     *                 description: Description of the ${moduleName}
+     *                 description: Description of the ${moduleNameCapitalized}
      *               status:
      *                 type: integer
      *                 default: 1
-     *                 description: Status of the ${moduleName}
+     *                 description: Status of the ${moduleNameCapitalized}
      *     responses:
      *       201:
-     *         description: ${entityName} created successfully
+     *         description: ${moduleNameCapitalized} created successfully
      *         content:
      *           application/json:
      *             schema:
      *               type: object
      *               properties:
      *                 Data:
-     *                   $ref: '#/components/schemas/${entityName}'
+     *                   $ref: '#/components/schemas/${moduleNameCapitalized}'
      *                 StatusCode:
      *                   type: integer
      *                   example: 1000
@@ -1393,24 +1543,32 @@ export class ${entityName}Controller {
      *         description: Bad request or missing required fields
      */
     async create(req, res) {
-        const data = await this.service.create(req.body);
-        res.json(data);
+        try {
+            const data = await this.service.create(req.body);
+            res.status(201).json(data);
+        } catch (error) {
+            res.status(400).json({
+                Data: null,
+                StatusCode: 4000,
+                Message: error.message
+            });
+        }
     }
 
     /**
      * @openapi
-     * /api/${moduleName}/{id}:
+     * /api/${moduleNameCamelCase}/{id}:
      *   put:
-     *     summary: Update ${moduleName}
-     *     description: Update an existing ${moduleName} record
-     *     tags: [${entityName}s]
+     *     summary: Update ${moduleNameCapitalized}
+     *     description: Update an existing ${moduleNameCapitalized} record
+     *     tags: [${moduleNameCapitalized}s]
      *     parameters:
      *       - in: path
      *         name: id
      *         required: true
      *         schema:
      *           type: string
-     *         description: ${entityName} ID
+     *         description: ${moduleNameCapitalized} ID
      *     requestBody:
      *       required: true
      *       content:
@@ -1420,51 +1578,59 @@ export class ${entityName}Controller {
      *             properties:
      *               name:
      *                 type: string
-     *                 description: Name of the ${moduleName}
+     *                 description: Name of the ${moduleNameCapitalized}
      *               description:
      *                 type: string
-     *                 description: Description of the ${moduleName}
+     *                 description: Description of the ${moduleNameCapitalized}
      *               status:
      *                 type: integer
-     *                 description: Status of the ${moduleName}
+     *                 description: Status of the ${moduleNameCapitalized}
      *     responses:
      *       200:
-     *         description: ${entityName} updated successfully
+     *         description: ${moduleNameCapitalized} updated successfully
      *         content:
      *           application/json:
      *             schema:
      *               type: object
      *               properties:
      *                 Data:
-     *                   $ref: '#/components/schemas/${entityName}'
+     *                   $ref: '#/components/schemas/${moduleNameCapitalized}'
      *                 StatusCode:
      *                   type: integer
      *                   example: 1000
      *       404:
-     *         description: ${entityName} not found
+     *         description: ${moduleNameCapitalized} not found
      */
     async update(req, res) {
-        const data = await this.service.update(req.params.id, req.body);
-        res.json(data);
+        try {
+            const data = await this.service.update(req.params.id, req.body);
+            res.json(data);
+        } catch (error) {
+            res.status(404).json({
+                Data: null,
+                StatusCode: 4004,
+                Message: error.message
+            });
+        }
     }
 
     /**
      * @openapi
-     * /api/${moduleName}/{id}:
+     * /api/${moduleNameCamelCase}/{id}:
      *   delete:
-     *     summary: Delete ${moduleName}
-     *     description: Soft delete a ${moduleName} (sets status to 0)
-     *     tags: [${entityName}s]
+     *     summary: Delete ${moduleNameCapitalized}
+     *     description: Soft delete a ${moduleNameCapitalized} (sets status to 0)
+     *     tags: [${moduleNameCapitalized}s]
      *     parameters:
      *       - in: path
      *         name: id
      *         required: true
      *         schema:
      *           type: string
-     *         description: ${entityName} ID
+     *         description: ${moduleNameCapitalized} ID
      *     responses:
      *       200:
-     *         description: ${entityName} deleted successfully
+     *         description: ${moduleNameCapitalized} deleted successfully
      *         content:
      *           application/json:
      *             schema:
@@ -1477,46 +1643,55 @@ export class ${entityName}Controller {
      *                   type: integer
      *                   example: 1000
      *       404:
-     *         description: ${entityName} not found
+     *         description: ${moduleNameCapitalized} not found
      */
     async delete(req, res) {
-        const data = await this.service.delete(req.params.id);
-        res.json(data);
+        try {
+            const data = await this.service.delete(req.params.id);
+            res.json(data);
+        } catch (error) {
+            res.status(404).json({
+                Data: null,
+                StatusCode: 4004,
+                Message: error.message
+            });
+        }
     }
 }`;
-        await fs.writeFile(path.join(modulePath, 'controllers', `${moduleName}.controller.ts`), controllerContent);
+        await fs.writeFile(path.join(modulePath, 'controllers', `${moduleNameCamelCase}.controller.ts`), controllerContent);
     }
-    async createRoutes(modulePath, moduleName, options) {
-        const entityName = this.capitalizeFirst(moduleName);
+    async createRoutes(modulePath, moduleNameCamelCase, options) {
+        // Convert module name to valid TypeScript identifiers
+        const moduleNameCapitalized = moduleNameCamelCase.charAt(0).toUpperCase() + moduleNameCamelCase.slice(1);
         const routesContent = `import { Router } from 'express';
-import { ${entityName}Controller } from '../controllers/${moduleName}.controller';
+import { ${moduleNameCapitalized}Controller } from '../controllers/${moduleNameCamelCase}.controller';
 
 const router = Router();
-const controller = new ${entityName}Controller();
+const controller = new ${moduleNameCapitalized}Controller();
 
 /**
  * @openapi
- * /api/${moduleName}:
+ * /api/${moduleNameCamelCase}/health:
  *   get:
- *     summary: Health check for ${moduleName} API
- *     description: Check if the ${moduleName} API is running
- *     tags: [${entityName}s]
+ *     summary: Health check for ${moduleNameCapitalized} API
+ *     description: Check if the ${moduleNameCapitalized} API is running
+ *     tags: [${moduleNameCapitalized}s]
  *     responses:
  *       200:
- *         description: ${entityName} API is running
+ *         description: ${moduleNameCapitalized} API is running
  */
-router.get('/', (req, res) => res.send('${entityName} API is up.'));
+router.get('/health', (req, res) => res.send('${moduleNameCapitalized} API is up.'));
 
 /**
  * @openapi
- * /api/${moduleName}/all:
+ * /api/${moduleNameCamelCase}/all:
  *   get:
- *     summary: Get all ${moduleName}s
- *     description: Retrieve a list of all active ${moduleName}s
- *     tags: [${entityName}s]
+ *     summary: Get all ${moduleNameCapitalized}s
+ *     description: Retrieve a list of all active ${moduleNameCapitalized}s
+ *     tags: [${moduleNameCapitalized}s]
  *     responses:
  *       200:
- *         description: List of ${moduleName}s retrieved successfully
+ *         description: List of ${moduleNameCapitalized}s retrieved successfully
  *         content:
  *           application/json:
  *             schema:
@@ -1525,7 +1700,7 @@ router.get('/', (req, res) => res.send('${entityName} API is up.'));
  *                 Data:
  *                   type: array
  *                   items:
- *                     $ref: '#/components/schemas/${entityName}'
+ *                     $ref: '#/components/schemas/${moduleNameCapitalized}'
  *                 StatusCode:
  *                   type: integer
  *                   example: 1000
@@ -1536,43 +1711,43 @@ router.get('/all', (req, res) => controller.getAll(req, res));
 
 /**
  * @openapi
- * /api/${moduleName}/{id}:
+ * /api/${moduleNameCamelCase}/{id}:
  *   get:
- *     summary: Get ${moduleName} by ID
- *     description: Retrieve a specific ${moduleName} by its ID
- *     tags: [${entityName}s]
+ *     summary: Get ${moduleNameCapitalized} by ID
+ *     description: Retrieve a specific ${moduleNameCapitalized} by its ID
+ *     tags: [${moduleNameCapitalized}s]
  *     parameters:
  *       - in: path
  *         name: id
  *         required: true
  *         schema:
  *           type: string
- *         description: ${entityName} ID
+ *         description: ${moduleNameCapitalized} ID
  *     responses:
  *       200:
- *         description: ${entityName} retrieved successfully
+ *         description: ${moduleNameCapitalized} retrieved successfully
  *         content:
  *           application/json:
  *             schema:
  *               type: object
  *               properties:
  *                 Data:
- *                   $ref: '#/components/schemas/${entityName}'
+ *                   $ref: '#/components/schemas/${moduleNameCapitalized}'
  *                 StatusCode:
  *                   type: integer
  *                   example: 1000
  *       404:
- *         description: ${entityName} not found
+ *         description: ${moduleNameCapitalized} not found
  */
 router.get('/:id', (req, res) => controller.getById(req, res));
 
 /**
  * @openapi
- * /api/${moduleName}:
+ * /api/${moduleNameCamelCase}:
  *   post:
- *     summary: Create new ${moduleName}
- *     description: Create a new ${moduleName} record
- *     tags: [${entityName}s]
+ *     summary: Create new ${moduleNameCapitalized}
+ *     description: Create a new ${moduleNameCapitalized} record
+ *     tags: [${moduleNameCapitalized}s]
  *     requestBody:
  *       required: true
  *       content:
@@ -1583,116 +1758,116 @@ router.get('/:id', (req, res) => controller.getById(req, res));
  *               - name
  *             properties:
  *               name:
- *                 type: string
- *                 description: Name of the ${moduleName}
- *               description:
- *                 type: string
- *                 description: Description of the ${moduleName}
- *               status:
- *                 type: integer
- *                 default: 1
- *                 description: Status of the ${moduleName}
- *     responses:
- *       201:
- *         description: ${entityName} created successfully
- *         content:
- *           application/json:
- *             schema:
- *               type: object
- *               properties:
- *                 Data:
- *                   $ref: '#/components/schemas/${entityName}'
- *                 StatusCode:
- *                   type: integer
- *                   example: 1000
- *       400:
- *         description: Bad request or missing required fields
- */
+     *                 type: string
+     *                 description: Name of the ${moduleNameCapitalized}
+     *               description:
+     *                 type: string
+     *                 description: Description of the ${moduleNameCapitalized}
+     *               status:
+     *                 type: integer
+     *                 default: 1
+     *                 description: Status of the ${moduleNameCapitalized}
+     *     responses:
+     *       201:
+     *         description: ${moduleNameCapitalized} created successfully
+     *         content:
+     *           application/json:
+     *             schema:
+     *               type: object
+     *               properties:
+     *                 Data:
+     *                   $ref: '#/components/schemas/${moduleNameCapitalized}'
+     *                 StatusCode:
+     *                   type: integer
+     *                   example: 1000
+     *       400:
+     *         description: Bad request or missing required fields
+     */
 router.post('/', (req, res) => controller.create(req, res));
 
 /**
  * @openapi
- * /api/${moduleName}/{id}:
+ * /api/${moduleNameCamelCase}/{id}:
  *   put:
- *     summary: Update ${moduleName}
- *     description: Update an existing ${moduleName} record
- *     tags: [${entityName}s]
+ *     summary: Update ${moduleNameCapitalized}
+ *     description: Update an existing ${moduleNameCapitalized} record
+ *     tags: [${moduleNameCapitalized}s]
  *     parameters:
- *       - in: path
- *         name: id
- *         required: true
- *         schema:
- *           type: string
- *         description: ${entityName} ID
- *     requestBody:
- *       required: true
- *       content:
- *         application/json:
- *           schema:
- *             type: object
- *             properties:
- *               name:
+     *       - in: path
+     *         name: id
+     *         required: true
+     *         schema:
+     *           type: string
+     *         description: ${moduleNameCapitalized} ID
+     *     requestBody:
+     *       required: true
+     *       content:
+     *         application/json:
+     *           schema:
+     *             type: object
+     *             properties:
+      *               name:
  *                 type: string
- *                 description: Name of the ${moduleName}
+ *                 description: Name of the ${moduleNameCapitalized}
  *               description:
  *                 type: string
- *                 description: Description of the ${moduleName}
+ *                 description: Description of the ${moduleNameCapitalized}
  *               status:
  *                 type: integer
- *                 description: Status of the ${moduleName}
- *     responses:
- *       200:
- *         description: ${entityName} updated successfully
- *         content:
- *           application/json:
- *             schema:
- *               type: object
- *               properties:
- *                 Data:
- *                   $ref: '#/components/schemas/${entityName}'
- *                 StatusCode:
- *                   type: integer
- *                   example: 1000
- *       404:
- *         description: ${entityName} not found
- */
+ *                 description: Status of the ${moduleNameCapitalized}
+     *     responses:
+     *       200:
+     *         description: ${moduleNameCapitalized} updated successfully
+     *         content:
+     *           application/json:
+     *             schema:
+     *               type: object
+     *               properties:
+     *                 Data:
+     *                   $ref: '#/components/schemas/${moduleNameCapitalized}'
+     *                 StatusCode:
+     *                   type: integer
+     *                   example: 1000
+     *       404:
+     *         description: ${moduleNameCapitalized} not found
+     */
 router.put('/:id', (req, res) => controller.update(req, res));
 
 /**
  * @openapi
- * /api/${moduleName}/{id}:
+ * /api/${moduleNameCamelCase}/{id}:
  *   delete:
- *     summary: Delete ${moduleName}
- *     description: Soft delete a ${moduleName} (sets status to 0)
- *     tags: [${entityName}s]
+ *     summary: Delete ${moduleNameCapitalized}
+ *     description: Soft delete a ${moduleNameCapitalized} (sets status to 0)
+ *     tags: [${moduleNameCapitalized}s]
  *     parameters:
- *       - in: path
- *         name: id
- *         required: true
- *         schema:
- *           type: string
- *         description: ${entityName} ID
- *     responses:
- *       200:
- *         description: ${entityName} deleted successfully
- *         content:
- *           application/json:
- *             schema:
- *               type: object
- *               properties:
- *                 Data:
- *                   type: boolean
- *                   example: true
- *                 StatusCode:
- *                   type: integer
- *                   example: 1000
- *       404:
- *         description: ${entityName} not found
- */
+     *       - in: path
+     *         name: id
+     *         required: true
+     *         schema:
+     *           type: string
+     *         description: ${moduleNameCapitalized} ID
+     *     responses:
+     *       200:
+     *         description: ${moduleNameCapitalized} deleted successfully
+     *         content:
+     *           application/json:
+     *             schema:
+     *               type: object
+     *               properties:
+     *                 Data:
+     *                   type: boolean
+     *                   example: true
+     *                 StatusCode:
+     *                   type: integer
+     *                   example: 1000
+     *       404:
+     *         description: ${moduleNameCapitalized} not found
+     */
 router.delete('/:id', (req, res) => controller.delete(req, res));
 
 export default router;`;
-        await fs.writeFile(path.join(modulePath, 'routes', `${moduleName}.routes.ts`), routesContent);
+        await fs.writeFile(path.join(modulePath, 'routes', `${moduleNameCamelCase}.routes.ts`), routesContent);
     }
     async generateCRUDOperations(projectPath, moduleName, options) {
         console.log(chalk_1.default.blue(`🔄 Generating CRUD operations for ${moduleName}...`));
@@ -1750,12 +1925,12 @@ export default router;`;
         }
     }
     async updateSeeder(projectPath, moduleName) {
-        const entityName = this.capitalizeFirst(moduleName);
+        const moduleNameCapitalized = this.capitalizeFirst(moduleName);
         const seederPath = path.join(projectPath, 'src', 'core', 'database', 'seeder.ts');
         if (await fs.pathExists(seederPath)) {
             let seederContent = await fs.readFile(seederPath, 'utf8');
             // Add import for the model
-            const importStatement = `import { ${entityName}Model } from '../../modules/${moduleName}/schemas/${moduleName}.schema';`;
+            const importStatement = `import { ${moduleNameCapitalized}Model } from '../../modules/${moduleName}/schemas/${moduleName}.schema';`;
             if (!seederContent.includes(importStatement)) {
                 // Add import after the last import statement
                 const lastImportIndex = seederContent.lastIndexOf('import');
@@ -1763,34 +1938,34 @@ export default router;`;
                 seederContent = seederContent.slice(0, lastImportEndIndex) + importStatement + '\n' + seederContent.slice(lastImportEndIndex);
             }
             // Add seeder function - use exact module name provided by developer
-            const seederFunction = `  private async seed${entityName}(data: any[]): Promise<void> {
+            const seederFunction = `  private async seed${moduleNameCapitalized}(data: any[]): Promise<void> {
     if (data.length === 0) return;
     
     logger.info(\`[DatabaseSeeder] Seeding \${data.length} ${moduleName} records...\`);
     
     for (const ${moduleName}Data of data) {
       try {
-        const existing = await ${entityName}Model.findOne({ name: ${moduleName}Data.name });
+        const existing = await ${moduleNameCapitalized}Model.findOne({ name: ${moduleName}Data.name });
         if (!existing) {
-          const ${moduleName} = new ${entityName}Model({
+          const ${moduleName} = new ${moduleNameCapitalized}Model({
             ...${moduleName}Data,
             status: 1
           });
           await ${moduleName}.save();
           logger.info(\`[DatabaseSeeder] Created ${moduleName}: \${${moduleName}Data.name}\`);
         } else {
-          logger.info(\`[DatabaseSeeder] ${entityName} \${${moduleName}Data.name} already exists, skipping\`);
+          logger.info(\`[DatabaseSeeder] ${moduleNameCapitalized} \${${moduleName}Data.name} already exists, skipping\`);
         }
       } catch (error) {
         logger.error(\`[DatabaseSeeder] Failed to create ${moduleName} \${${moduleName}Data.name}:\`, error);
       }
     }
   }`;
-            if (!seederContent.includes(`seed${entityName}(`)) {
+            if (!seederContent.includes(`seed${moduleNameCapitalized}(`)) {
                 seederContent = seederContent.replace(/\/\/ TEMPLATE: Add new seeder functions here \(the CLI will add new functions automatically\)/, `// TEMPLATE: Add new seeder functions here (the CLI will add new functions automatically)\n${seederFunction}`);
             }
             // Add default seed data - use exact module name
-            const seedDataLine = `      ${moduleName}: [ { name: '${entityName} Example', description: 'Example ${moduleName}', status: 1 } ],`;
+            const seedDataLine = `      ${moduleName}: [ { name: '${moduleNameCapitalized} Example', description: 'Example ${moduleName}', status: 1 } ],`;
             if (!seederContent.includes(seedDataLine)) {
                 seederContent = seederContent.replace(/const defaultData: SeedData = \{/, `const defaultData: SeedData = {\n${seedDataLine}`);
             }
@@ -1798,7 +1973,7 @@ export default router;`;
         }
     }
     async createTableSchema(projectPath, tableName, options) {
-        const entityName = this.capitalizeFirst(tableName);
+        const tableNameCapitalized = this.capitalizeFirst(tableName);
         const fields = options.fields || ['name', 'description'];
         const dbType = options.type || 'mongodb';
         if (dbType === 'mongodb') {
@@ -1811,10 +1986,10 @@ export default router;`;
     async createMongoDBSchema(projectPath, tableName, fields) {
         const schemaPath = path.join(projectPath, 'src', 'schemas', `${tableName}.schema.ts`);
         await fs.ensureDir(path.dirname(schemaPath));
-        const entityName = this.capitalizeFirst(tableName);
+        const tableNameCapitalized = this.capitalizeFirst(tableName);
         const schemaContent = `import mongoose, { Schema, Document } from 'mongoose';
 
-export interface I${entityName}Document extends Document {
+export interface I${tableNameCapitalized}Document extends Document {
 ${fields.map(field => `  ${field}: string;`).join('\n')}
   createdAt: Date;
   updatedAt: Date;
@@ -1833,15 +2008,15 @@ ${fields.map(field => `  ${field}: {
 // Indexes
 ${fields.map(field => `${tableName}Schema.index({ ${field}: 1 });`).join('\n')}
 
-export const ${entityName}Model = mongoose.model<I${entityName}Document>('${entityName}', ${tableName}Schema);
+export const ${tableNameCapitalized}Model = mongoose.model<I${tableNameCapitalized}Document>('${tableNameCapitalized}', ${tableName}Schema);
 `;
         await fs.writeFile(schemaPath, schemaContent);
     }
     async createSQLSchema(projectPath, tableName, fields, dbType) {
         const schemaPath = path.join(projectPath, 'src', 'schemas', `${tableName}.sql`);
         await fs.ensureDir(path.dirname(schemaPath));
-        const entityName = this.capitalizeFirst(tableName);
-        const schemaContent = `-- ${entityName} table schema for ${dbType.toUpperCase()}
+        const tableNameCapitalized = this.capitalizeFirst(tableName);
+        const schemaContent = `-- ${tableNameCapitalized} table schema for ${dbType.toUpperCase()}
 CREATE TABLE ${tableName}s (
   id ${dbType === 'postgres' ? 'SERIAL' : 'INT AUTO_INCREMENT'} PRIMARY KEY,
 ${fields.map(field => `  ${field} VARCHAR(255) NOT NULL,`).join('\n')}