@diagramers/cli 4.0.19 → 4.0.21

package/dist/services/api-generator.js

@@ -37,12 +37,17 @@ exports.generateModule = generateModule;
 exports.generateEndpoint = generateEndpoint;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
-async function generateModule(moduleName) {
+async function generateModule(moduleName, options = {}) {
     // Validate module name
     if (!moduleName || !/^[a-zA-Z][a-zA-Z0-9_-]*$/.test(moduleName)) {
         throw new Error('Invalid module name. Use only letters, numbers, hyphens, and underscores. Must start with a letter.');
     }
-    const moduleNameCapitalized = moduleName.charAt(0).toUpperCase() + moduleName.slice(1);
+    // 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);
+    console.log(`🔍 Debug: moduleName = "${moduleName}"`);
+    console.log(`🔍 Debug: moduleNameCamelCase = "${moduleNameCamelCase}"`);
+    console.log(`🔍 Debug: moduleNameCapitalized = "${moduleNameCapitalized}"`);
     const currentDir = process.cwd();
     // Check for required API project structure
     const requiredDirs = ['src/modules'];
@@ -60,34 +65,49 @@ async function generateModule(moduleName) {
         fs.mkdirSync(path.join(modulePath, 'controllers'), { recursive: true });
         fs.mkdirSync(path.join(modulePath, 'routes'), { recursive: true });
     }
+    // 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('📝 Creating entity...');
-    const entityContent = generateEntityContent(moduleName, moduleNameCapitalized);
-    fs.writeFileSync(path.join(modulePath, 'entities', `${moduleName}.entity.ts`), entityContent);
+    const entityContent = generateEntityContent(moduleNameCamelCase, moduleNameCapitalized, fields);
+    fs.writeFileSync(path.join(modulePath, 'entities', `${moduleNameCamelCase}.entity.ts`), entityContent);
     console.log('📋 Creating schema...');
-    const schemaContent = generateSchemaContent(moduleName, moduleNameCapitalized);
-    fs.writeFileSync(path.join(modulePath, 'schemas', `${moduleName}.schema.ts`), schemaContent);
+    const schemaContent = generateSchemaContent(moduleNameCamelCase, moduleNameCapitalized, fields);
+    fs.writeFileSync(path.join(modulePath, 'schemas', `${moduleNameCamelCase}.schema.ts`), schemaContent);
     console.log('🔧 Creating service...');
-    const serviceContent = generateServiceContent(moduleName, moduleNameCapitalized);
-    fs.writeFileSync(path.join(modulePath, 'services', `${moduleName}.service.ts`), serviceContent);
+    const serviceContent = generateServiceContent(moduleNameCamelCase, moduleNameCapitalized, fields, crud);
+    fs.writeFileSync(path.join(modulePath, 'services', `${moduleNameCamelCase}.service.ts`), serviceContent);
     console.log('🎮 Creating controller...');
-    const controllerContent = generateControllerContent(moduleName, moduleNameCapitalized);
-    fs.writeFileSync(path.join(modulePath, 'controllers', `${moduleName}.controller.ts`), controllerContent);
-    console.log('🛣️ Creating routes...');
-    const routesContent = generateRoutesContent(moduleName, moduleNameCapitalized);
-    fs.writeFileSync(path.join(modulePath, 'routes', `${moduleName}.routes.ts`), routesContent);
-    // Register routes in server manager
-    console.log('🔗 Registering routes...');
-    await registerModuleRoutes(currentDir, moduleName, moduleNameCapitalized);
-    // Create database table/collection
-    console.log('🗄️ Creating database table...');
-    await createDatabaseTable(currentDir, moduleName, moduleNameCapitalized);
+    const controllerContent = generateControllerContent(moduleNameCamelCase, moduleNameCapitalized, fields, crud);
+    fs.writeFileSync(path.join(modulePath, 'controllers', `${moduleNameCamelCase}.controller.ts`), controllerContent);
+    if (generateRoutes) {
+        console.log('🛣️ Creating routes...');
+        const routesContent = generateRoutesContent(moduleNameCamelCase, moduleNameCapitalized, crud, fields);
+        fs.writeFileSync(path.join(modulePath, 'routes', `${moduleNameCamelCase}.routes.ts`), routesContent);
+        // Register routes in server manager
+        console.log('🔗 Registering routes...');
+        await registerModuleRoutes(currentDir, moduleName, moduleNameCapitalized);
+    }
+    if (generateDatabase) {
+        // Create database table/collection
+        console.log('🗄️ Creating database table...');
+        await createDatabaseTable(currentDir, moduleName, moduleNameCapitalized);
+    }
     console.log('✅ Module generation completed!');
     console.log(`📁 Module: src/modules/${moduleName}/`);
-    console.log(`🔗 Routes: /api/${moduleName}s`);
-    console.log(`🗄️ Database: ${moduleName} collection`);
+    if (generateRoutes) {
+        console.log(`🔗 Routes: /api/${moduleName}s`);
+    }
+    if (generateDatabase) {
+        console.log(`🗄️ Database: ${moduleName} collection`);
+    }
 }
-function generateEntityContent(moduleName, moduleNameCapitalized) {
-    return `import * as mongoose from 'mongoose';
+function generateEntityContent(moduleName, moduleNameCapitalized, fields) {
+    // Convert moduleName to camelCase for internal identifiers
+    const moduleNameCamelCase = moduleName.replace(/[-_]([a-z0-9])/g, (_, char) => char.toUpperCase());
+    let entityContent = `import * as mongoose from 'mongoose';
 import { ObjectId } from "bson";
 
 export interface I${moduleNameCapitalized} extends mongoose.Document {
@@ -98,12 +118,33 @@ export interface I${moduleNameCapitalized} extends mongoose.Document {
     createdAt: Date,
     updatedAt: Date
 }`;
+    if (fields.length > 0) {
+        entityContent += `
+export interface I${moduleNameCapitalized} extends mongoose.Document {
+    _id: ObjectId,
+    name: string,
+    description?: string,
+    status: number,
+    createdAt: Date,
+    updatedAt: Date
+`;
+        fields.forEach(field => {
+            entityContent += `
+    ${field}: string;
+`;
+        });
+        entityContent += `
+}`;
+    }
+    return entityContent;
 }
-function generateSchemaContent(moduleName, moduleNameCapitalized) {
-    return `import * as mongoose from 'mongoose';
-import { I${moduleNameCapitalized} } from '../entities/${moduleName}';
+function generateSchemaContent(moduleName, moduleNameCapitalized, fields) {
+    // Convert moduleName to camelCase for file paths
+    const moduleNameCamelCase = moduleName.replace(/[-_]([a-z0-9])/g, (_, char) => char.toUpperCase());
+    let schemaContent = `import * as mongoose from 'mongoose';
+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,
@@ -121,12 +162,90 @@ export const ${moduleName}Schema = new mongoose.Schema(
     { timestamps: true, suppressReservedKeysWarning: true },
 );
 
-export const ${moduleNameCapitalized}Model = mongoose.model<I${moduleNameCapitalized}>('${moduleName}', ${moduleName}Schema);`;
+export const ${moduleNameCapitalized}Model = mongoose.model<I${moduleNameCapitalized}>('${moduleNameCamelCase}', ${moduleNameCamelCase}Schema);`;
+    if (fields.length > 0) {
+        schemaContent += `
+export const ${moduleNameCamelCase}Schema = new mongoose.Schema(
+    {
+        name: {
+            type: mongoose.SchemaTypes.String,
+            required: true,
+        },
+        description: {
+            type: mongoose.SchemaTypes.String,
+            required: false,
+        },
+        status: {
+            type: mongoose.SchemaTypes.Number,
+            default: 1,
+        }
+`;
+        fields.forEach(field => {
+            schemaContent += `
+        ${field}: {
+            type: mongoose.SchemaTypes.String,
+            required: true,
+        },
+`;
+        });
+        schemaContent += `
+    },
+    { timestamps: true, suppressReservedKeysWarning: true },
+);
+`;
+    }
+    return schemaContent;
 }
-function generateServiceContent(moduleName, moduleNameCapitalized) {
-    return `import { ObjectId } from "bson";
-import { ${moduleNameCapitalized}Model } from '../schemas/${moduleName}.schema';
+function generateServiceContent(moduleName, moduleNameCapitalized, fields, crud) {
+    // Convert moduleName to camelCase for file paths
+    const moduleNameCamelCase = moduleName.replace(/[-_]([a-z0-9])/g, (_, char) => char.toUpperCase());
+    let serviceContent = `import { ObjectId } from "bson";
+import { ${moduleNameCapitalized}Model } from '../schemas/${moduleNameCamelCase}.schema';
 
+export class ${moduleNameCapitalized}Service {
+    async getAll() {
+        try {
+            return await ${moduleNameCapitalized}Model.find({ status: 1 });
+        } catch (error) {
+            throw new Error(\`Failed to fetch ${moduleNameCamelCase}s: \${error.message}\`);
+        }
+    }
+    
+    async getById(id: string) {
+        try {
+            return await ${moduleNameCapitalized}Model.findById(id);
+        } catch (error) {
+            throw new Error(\`Failed to fetch ${moduleNameCamelCase}: \${error.message}\`);
+        }
+    }
+    
+    async create(data: any) {
+        try {
+            const entity = new ${moduleNameCapitalized}Model({ _id: new ObjectId(), ...data, status: 1 });
+            return await ${moduleNameCapitalized}Model.create(entity);
+        } catch (error) {
+            throw new Error(\`Failed to create ${moduleNameCamelCase}: \${error.message}\`);
+        }
+    }
+    
+    async update(id: string, data: any) {
+        try {
+            return await ${moduleNameCapitalized}Model.findByIdAndUpdate(id, { ...data }, { new: true });
+        } catch (error) {
+            throw new Error(\`Failed to update ${moduleNameCamelCase}: \${error.message}\`);
+        }
+    }
+    
+    async delete(id: string) {
+        try {
+            return await ${moduleNameCapitalized}Model.findByIdAndUpdate(id, { status: 0 }, { new: true });
+        } catch (error) {
+            throw new Error(\`Failed to delete ${moduleNameCamelCase}: \${error.message}\`);
+        }
+    }
+}`;
+    if (crud) {
+        serviceContent += `
 export class ${moduleNameCapitalized}Service {
     async getAll() {
         return await ${moduleNameCapitalized}Model.find({ status: 1 });
@@ -144,10 +263,21 @@ export class ${moduleNameCapitalized}Service {
     async delete(id: string) {
         return await ${moduleNameCapitalized}Model.findByIdAndUpdate(id, { status: 0 }, { new: true });
     }
-}`;
+`;
+        fields.forEach(field => {
+            serviceContent += `
+    async ${field}(id: string, data: any) {
+        return await ${moduleNameCapitalized}Model.findByIdAndUpdate(id, { ${field}: data }, { new: true });
+    }
+`;
+        });
+    }
+    return serviceContent;
 }
-function generateControllerContent(moduleName, moduleNameCapitalized) {
-    return `import { ${moduleNameCapitalized}Service } from '../services/${moduleName}.service';
+function generateControllerContent(moduleName, moduleNameCapitalized, fields, crud) {
+    // Convert moduleName to camelCase for file paths
+    const moduleNameCamelCase = moduleName.replace(/[-_]([a-z0-9])/g, (_, char) => char.toUpperCase());
+    let controllerContent = `import { ${moduleNameCapitalized}Service } from '../services/${moduleNameCamelCase}.service';
 
 /**
  * @openapi
@@ -189,14 +319,14 @@ export class ${moduleNameCapitalized}Controller {
 
     /**
      * @openapi
-     * /api/${moduleName}:
+     * /api/${moduleNameCamelCase}:
      *   get:
-     *     summary: Get all ${moduleName}s
-     *     description: Retrieve a list of all active ${moduleName}s
+     *     summary: Get all ${moduleNameCamelCase}s
+     *     description: Retrieve a list of all active ${moduleNameCamelCase}s
      *     tags: [${moduleNameCapitalized}s]
      *     responses:
      *       200:
-     *         description: List of ${moduleName}s retrieved successfully
+     *         description: List of ${moduleNameCamelCase}s retrieved successfully
      *         content:
      *           application/json:
      *             schema:
@@ -213,16 +343,28 @@ export class ${moduleNameCapitalized}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: data,
+                StatusCode: 1000,
+                Message: '${moduleNameCapitalized}s retrieved successfully'
+            });
+        } catch (error: any) {
+            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
+     *     summary: Get ${moduleNameCamelCase} by ID
+     *     description: Retrieve a specific ${moduleNameCamelCase} by its ID
      *     tags: [${moduleNameCapitalized}s]
      *     parameters:
      *       - in: path
@@ -248,8 +390,27 @@ export class ${moduleNameCapitalized}Controller {
      *         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);
+            if (!data) {
+                return res.status(404).json({
+                    Data: null,
+                    StatusCode: 4004,
+                    Message: '${moduleNameCapitalized} not found'
+                });
+            }
+            res.json({
+                Data: data,
+                StatusCode: 1000,
+                Message: '${moduleNameCapitalized} retrieved successfully'
+            });
+        } catch (error: any) {
+            res.status(400).json({
+                Data: null,
+                StatusCode: 4000,
+                Message: error.message
+            });
+        }
     }
 
     /**
@@ -295,8 +456,20 @@ export class ${moduleNameCapitalized}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: data,
+                StatusCode: 1000,
+                Message: '${moduleNameCapitalized} created successfully'
+            });
+        } catch (error: any) {
+            res.status(400).json({
+                Data: null,
+                StatusCode: 4000,
+                Message: error.message
+            });
+        }
     }
 
     /**
@@ -382,19 +555,115 @@ export class ${moduleNameCapitalized}Controller {
      *         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);
+            if (!data) {
+                return res.status(404).json({
+                    Data: null,
+                    StatusCode: 4004,
+                    Message: '${moduleNameCapitalized} not found'
+                });
+            }
+            res.json({
+                Data: data,
+                StatusCode: 1000,
+                Message: '${moduleNameCapitalized} deleted successfully'
+            });
+        } catch (error: any) {
+            res.status(400).json({
+                Data: null,
+                StatusCode: 4000,
+                Message: error.message
+            });
+        }
     }
-}`;
+`;
+    if (crud) {
+        controllerContent += `
+`;
+        fields.forEach(field => {
+            controllerContent += `
+    /**
+     * @openapi
+     * /api/${moduleName}/{id}:
+     *   put:
+     *     summary: Update ${moduleName}
+     *     description: Update an existing ${moduleName} record
+     *     tags: [${moduleNameCapitalized}s]
+     *     parameters:
+     *       - in: path
+     *         name: id
+     *         required: true
+     *         schema:
+     *           type: string
+     *         description: ${moduleNameCapitalized} ID
+     *     requestBody:
+     *       required: true
+     *       content:
+     *         application/json:
+     *           schema:
+     *             type: object
+     *             properties:
+     *               ${field}:
+     *                 type: string
+     *                 description: ${field} 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
+     */
+    async update(req, res) {
+        try {
+            const data = await this.service.update(req.params.id, req.body);
+            if (!data) {
+                return res.status(404).json({
+                    Data: null,
+                    StatusCode: 4004,
+                    Message: '${moduleNameCapitalized} not found'
+                });
+            }
+            res.json({
+                Data: data,
+                StatusCode: 1000,
+                Message: '${moduleNameCapitalized} updated successfully'
+            });
+        } catch (error: any) {
+            res.status(400).json({
+                Data: null,
+                StatusCode: 4000,
+                Message: error.message
+            });
+        }
+    }
+`;
+        });
+    }
+    return controllerContent;
 }
-function generateRoutesContent(moduleName, moduleNameCapitalized) {
-    return `import { Router } from 'express';
-import { ${moduleNameCapitalized}Controller } from '../controllers/${moduleName}.controller';
+function generateRoutesContent(moduleName, moduleNameCapitalized, crud, fields = []) {
+    // Convert moduleName to camelCase for file paths
+    const moduleNameCamelCase = moduleName.replace(/[-_]([a-z0-9])/g, (_, char) => char.toUpperCase());
+    let routesContent = `import { Router } from 'express';
+import { ${moduleNameCapitalized}Controller } from '../controllers/${moduleNameCamelCase}.controller';
 
 const router = Router();
 const controller = new ${moduleNameCapitalized}Controller();
 
-router.get('/', (req, res) => res.send('${moduleNameCapitalized} API is up.'));
+// Health check endpoint
+router.get('/health', (req, res) => res.send('${moduleNameCapitalized} API is up.'));
+
+// CRUD endpoints
 router.get('/all', (req, res) => controller.getAll(req, res));
 router.get('/:id', (req, res) => controller.getById(req, res));
 router.post('/', (req, res) => controller.create(req, res));
@@ -402,6 +671,16 @@ router.put('/:id', (req, res) => controller.update(req, res));
 router.delete('/:id', (req, res) => controller.delete(req, res));
 
 export default router;`;
+    if (crud && fields.length > 0) {
+        routesContent += `
+`;
+        fields.forEach((field) => {
+            routesContent += `
+  router.put('/${field}/:id', (req, res) => controller.update(req, res));
+`;
+        });
+    }
+    return routesContent;
 }
 function updateRoutesIndex(currentDir, moduleName) {
     const routesIndexPath = path.join(currentDir, 'src/routes/index.ts');
@@ -409,15 +688,17 @@ function updateRoutesIndex(currentDir, moduleName) {
         console.log('⚠️ routes/index.ts not found, skipping routes index update');
         return;
     }
+    // Convert moduleName to camelCase for file paths
+    const moduleNameCamelCase = moduleName.replace(/[-_]([a-z0-9])/g, (_, char) => char.toUpperCase());
     let routesContent = fs.readFileSync(routesIndexPath, 'utf8');
-    // Add import
-    const importStatement = `import ${moduleName}Routes from '../modules/${moduleName}/routes/${moduleName}.routes';`;
+    // Add import - use camelCase for file path
+    const importStatement = `import ${moduleNameCamelCase}Routes from '../modules/${moduleName}/routes/${moduleNameCamelCase}.routes';`;
     if (!routesContent.includes(importStatement)) {
         // Add import after the userRoutes import
-        routesContent = routesContent.replace(/import userRoutes from '\.\.\/modules\/users\/routes\/user\.routes';/, `import userRoutes from '../modules/users/routes/user.routes';\n${importStatement}`);
+        routesContent = routesContent.replace(/import userRoutes from '\.\.\/modules\/user\/routes\/user\.routes';/, `import userRoutes from '../modules/user/routes/user.routes';\n${importStatement}`);
     }
-    // Add route registration
-    const routeRegistration = `router.use('/${moduleName}', ${moduleName}Routes);`;
+    // Add route registration - use original moduleName for route path
+    const routeRegistration = `router.use('/${moduleName}', ${moduleNameCamelCase}Routes);`;
     if (!routesContent.includes(routeRegistration)) {
         // Add route after the users route
         routesContent = routesContent.replace(/router\.use\('\/users', userRoutes\);/, `router.use('/users', userRoutes);\n${routeRegistration}`);
@@ -435,9 +716,10 @@ async function createDatabaseTable(currentDir, moduleName, moduleNameCapitalized
     if (fs.existsSync(mainSeederPath)) {
         let seederContent = fs.readFileSync(mainSeederPath, 'utf8');
         // Add import for the model
-        const importStatement = `import { ${moduleNameCapitalized}Model } from '../../modules/${moduleName}/schemas/${moduleName}.schema';`;
+        const moduleNameCamelCase = moduleName.replace(/[-_]([a-z0-9])/g, (_, char) => char.toUpperCase());
+        const importStatement = `import { ${moduleNameCapitalized}Model } from '../../modules/${moduleName}/schemas/${moduleNameCamelCase}.schema';`;
         if (!seederContent.includes(importStatement)) {
-            seederContent = seederContent.replace(/import { UserModel } from '\.\.\/\.\.\/modules\/users\/schemas\/user\.schema';/, `import { UserModel } from '../../modules/users/schemas/user.schema';\n${importStatement}`);
+            seederContent = seederContent.replace(/import { UserModel } from '\.\.\/\.\.\/modules\/user\/schemas\/user\.schema';/, `import { UserModel } from '../../modules/user/schemas/user.schema';\n${importStatement}`);
         }
         // Add seeder function - use exact module name provided by developer
         const seederFunction = `  private async seed${moduleNameCapitalized}(data: any[]): Promise<void> {
@@ -491,27 +773,46 @@ async function generateEndpoint(moduleName, endpointName, options = {}) {
     if (!fs.existsSync(modulePath)) {
         throw new Error(`Module '${moduleName}' does not exist. Please create the module first using 'generate:module ${moduleName}'`);
     }
-    // Set default options
+    // Parse options
     const method = (options.method || 'GET').toUpperCase();
     const customPath = options.path || endpointName;
     const description = options.description || `${endpointNameCapitalized} endpoint for ${moduleName}`;
+    const generateService = options.generateService !== false;
+    const generateController = options.generateController !== false;
+    const generateRoute = options.generateRoute !== false;
+    const force = options.force || false;
     console.log(`🔧 Adding endpoint '${endpointName}' to module '${moduleName}'...`);
     // Convert endpoint name to camelCase for method names
     const camelCaseEndpoint = endpointName.replace(/-/g, '_').replace(/_([a-z])/g, (g) => g[1].toUpperCase());
     const camelCaseEndpointCapitalized = camelCaseEndpoint.charAt(0).toUpperCase() + camelCaseEndpoint.slice(1);
-    // Add service method
-    console.log('📝 Adding service method...');
-    await addServiceMethod(modulePath, moduleName, moduleNameCapitalized, camelCaseEndpoint, camelCaseEndpointCapitalized, method, description);
-    // Add controller method
-    console.log('🎮 Adding controller method...');
-    await addControllerMethod(modulePath, moduleName, moduleNameCapitalized, camelCaseEndpoint, camelCaseEndpointCapitalized, method, customPath, description);
-    // Add route
-    console.log('🛣️ Adding route...');
-    await addRoute(modulePath, moduleName, moduleNameCapitalized, camelCaseEndpoint, camelCaseEndpointCapitalized, method, customPath);
+    // Add service method if requested
+    if (generateService) {
+        console.log('📝 Adding service method...');
+        await addServiceMethod(modulePath, moduleName, moduleNameCapitalized, camelCaseEndpoint, camelCaseEndpointCapitalized, method, description, force);
+    }
+    // Add controller method if requested
+    if (generateController) {
+        console.log('🎮 Adding controller method...');
+        await addControllerMethod(modulePath, moduleName, moduleNameCapitalized, camelCaseEndpoint, camelCaseEndpointCapitalized, method, customPath, description, force);
+    }
+    // Add route if requested
+    if (generateRoute) {
+        console.log('🛣️ Adding route...');
+        await addRoute(modulePath, moduleName, moduleNameCapitalized, camelCaseEndpoint, camelCaseEndpointCapitalized, method, customPath);
+    }
     console.log(`✅ Endpoint '${endpointName}' added to module '${moduleName}' successfully!`);
     console.log(`🔗 New endpoint available at: ${method} /api/${moduleName}/${customPath}`);
+    if (generateService) {
+        console.log(`📝 Service: Method '${camelCaseEndpoint}' added to service`);
+    }
+    if (generateController) {
+        console.log(`🎮 Controller: Method '${camelCaseEndpoint}' added to controller`);
+    }
+    if (generateRoute) {
+        console.log(`🛣️ Route: ${method} /${customPath} added to routes`);
+    }
 }
-async function addServiceMethod(modulePath, moduleName, moduleNameCapitalized, endpointName, endpointNameCapitalized, method, description) {
+async function addServiceMethod(modulePath, moduleName, moduleNameCapitalized, endpointName, endpointNameCapitalized, method, description, force) {
     // Use singular form for file names (convert plural to singular if needed)
     const singularName = moduleName.endsWith('s') && moduleName.length > 1 ? moduleName.slice(0, -1) : moduleName;
     const servicePath = path.join(modulePath, 'services', `${singularName}.service.ts`);
@@ -519,6 +820,10 @@ async function addServiceMethod(modulePath, moduleName, moduleNameCapitalized, e
         throw new Error(`Service file not found: ${servicePath}`);
     }
     let serviceContent = fs.readFileSync(servicePath, 'utf8');
+    // Check if method already exists
+    if (serviceContent.includes(`async ${endpointName}(`) && !force) {
+        throw new Error(`Service method '${endpointName}' already exists. Use --force to override.`);
+    }
     // Generate service method based on HTTP method
     let serviceMethod = '';
     switch (method) {
@@ -556,12 +861,19 @@ async function addServiceMethod(modulePath, moduleName, moduleNameCapitalized, e
         return { message: '${endpointNameCapitalized} endpoint - implement your logic here', params };
     }`;
     }
-    // Add method before the closing brace
-    const lastBraceIndex = serviceContent.lastIndexOf('}');
-    serviceContent = serviceContent.slice(0, lastBraceIndex) + serviceMethod + '\n' + serviceContent.slice(lastBraceIndex);
+    // If method exists and force is enabled, replace it
+    if (serviceContent.includes(`async ${endpointName}(`) && force) {
+        const methodRegex = new RegExp(`\\s*async ${endpointName}\\([^)]*\\)\\s*\\{[^}]*\\}`, 's');
+        serviceContent = serviceContent.replace(methodRegex, serviceMethod);
+    }
+    else {
+        // Add method before the closing brace
+        const lastBraceIndex = serviceContent.lastIndexOf('}');
+        serviceContent = serviceContent.slice(0, lastBraceIndex) + serviceMethod + '\n' + serviceContent.slice(lastBraceIndex);
+    }
     fs.writeFileSync(servicePath, serviceContent);
 }
-async function addControllerMethod(modulePath, moduleName, moduleNameCapitalized, endpointName, endpointNameCapitalized, method, customPath, description) {
+async function addControllerMethod(modulePath, moduleName, moduleNameCapitalized, endpointName, endpointNameCapitalized, method, customPath, description, force) {
     // Use singular form for file names (convert plural to singular if needed)
     const singularName = moduleName.endsWith('s') && moduleName.length > 1 ? moduleName.slice(0, -1) : moduleName;
     const controllerPath = path.join(modulePath, 'controllers', `${singularName}.controller.ts`);
@@ -569,132 +881,117 @@ async function addControllerMethod(modulePath, moduleName, moduleNameCapitalized
         throw new Error(`Controller file not found: ${controllerPath}`);
     }
     let controllerContent = fs.readFileSync(controllerPath, 'utf8');
-    // Add necessary imports if they don't exist
-    if (!controllerContent.includes('import { Request, Response }')) {
-        controllerContent = `import { Request, Response } from 'express';\n` + controllerContent;
-    }
-    if (!controllerContent.includes('import { handleResponse }')) {
-        controllerContent = `import { handleResponse } from '../../../shared/utils/handle-response';\n` + controllerContent;
+    // Check if method already exists
+    if (controllerContent.includes(`async ${endpointName}(`) && !force) {
+        throw new Error(`Controller method '${endpointName}' already exists. Use --force to override.`);
     }
-    if (!controllerContent.includes('import { Result }')) {
-        controllerContent = `import { Result } from '../../../shared/types/result';\n` + controllerContent;
-    }
-    if (!controllerContent.includes('import { v4 as uuidv4 }')) {
-        controllerContent = `import { v4 as uuidv4 } from 'uuid';\n` + controllerContent;
-    }
-    if (!controllerContent.includes('import { ResponseCode }')) {
-        controllerContent = `import { ResponseCode } from '../../../shared/constants/enums';\n` + controllerContent;
-    }
-    // Generate Swagger documentation and controller method
-    let swaggerDoc = '';
+    // Generate controller method based on HTTP method
     let controllerMethod = '';
     switch (method) {
         case 'GET':
-            swaggerDoc = `    /**
-     * @swagger
+            controllerMethod = `    /**
+     * @openapi
      * /api/${moduleName}/${customPath}:
      *   get:
-     *     summary: ${endpointNameCapitalized} ${moduleName}
+     *     summary: ${endpointNameCapitalized}
      *     description: ${description}
-     *     tags: [${moduleNameCapitalized}]
+     *     tags: [${moduleNameCapitalized}s]
      *     parameters:
      *       - in: query
-     *         name: filter
+     *         name: params
      *         schema:
-     *           type: string
-     *         description: Filter parameters
+     *           type: object
+     *         description: Query parameters
      *     responses:
      *       200:
-     *         description: ${endpointNameCapitalized} retrieved successfully
+     *         description: ${endpointNameCapitalized} executed successfully
      *         content:
      *           application/json:
      *             schema:
      *               type: object
      *               properties:
-     *                 data:
+     *                 Data:
      *                   type: object
-     *                 statusCode:
+     *                 StatusCode:
      *                   type: integer
      *                   example: 1000
-     *                 errors:
-     *                   type: array
-     *                   items:
-     *                     type: object
-     *                 requestIdentifier:
-     *                   type: string
      *       400:
      *         description: Bad request
-     */`;
-            controllerMethod = `    async ${endpointName}(req: Request, res: Response): Promise<void> {
-        const requestIdentifier = req.headers['x-request-id'] || uuidv4();
+     */
+    async ${endpointName}(req, res) {
         try {
-          const data = await this.service.${endpointName}(req.query);
-          const result = new Result(data, ResponseCode.Ok, [], null, requestIdentifier as string);
-          return handleResponse(res, result);
-        } catch (error: any) {
-          const result = new Result(null, ResponseCode.Error, [{ message: error.message }], null, requestIdentifier as string);
-          return handleResponse(res, result);
+            const params = req.query;
+            const result = await this.service.${endpointName}(params);
+            res.json({
+                Data: result,
+                StatusCode: 1000,
+                Message: '${endpointNameCapitalized} executed successfully'
+            });
+        } catch (error) {
+            res.status(400).json({
+                Data: null,
+                StatusCode: 4000,
+                Message: error.message
+            });
         }
-      }`;
+    }`;
             break;
         case 'POST':
-            swaggerDoc = `    /**
-     * @swagger
+            controllerMethod = `    /**
+     * @openapi
      * /api/${moduleName}/${customPath}:
      *   post:
-     *     summary: ${endpointNameCapitalized} ${moduleName}
+     *     summary: ${endpointNameCapitalized}
      *     description: ${description}
-     *     tags: [${moduleNameCapitalized}]
+     *     tags: [${moduleNameCapitalized}s]
      *     requestBody:
      *       required: true
      *       content:
      *         application/json:
      *           schema:
      *             type: object
-     *             properties:
-     *               # Add your request body properties here
      *     responses:
      *       200:
-     *         description: ${endpointNameCapitalized} completed successfully
+     *         description: ${endpointNameCapitalized} executed successfully
      *         content:
      *           application/json:
      *             schema:
      *               type: object
      *               properties:
-     *                 data:
+     *                 Data:
      *                   type: object
-     *                 statusCode:
+     *                 StatusCode:
      *                   type: integer
      *                   example: 1000
-     *                 errors:
-     *                   type: array
-     *                   items:
-     *                     type: object
-     *                 requestIdentifier:
-     *                   type: string
      *       400:
      *         description: Bad request
-     */`;
-            controllerMethod = `    async ${endpointName}(req: Request, res: Response): Promise<void> {
-        const requestIdentifier = req.headers['x-request-id'] || uuidv4();
+     */
+    async ${endpointName}(req, res) {
         try {
-          const data = await this.service.${endpointName}(req.body);
-          const result = new Result(data, ResponseCode.Ok, [], null, requestIdentifier as string);
-          return handleResponse(res, result);
-        } catch (error: any) {
-          const result = new Result(null, ResponseCode.Error, [{ message: error.message }], null, requestIdentifier as string);
-          return handleResponse(res, result);
+            const data = req.body;
+            const result = await this.service.${endpointName}(data);
+            res.json({
+                Data: result,
+                StatusCode: 1000,
+                Message: '${endpointNameCapitalized} executed successfully'
+            });
+        } catch (error) {
+            res.status(400).json({
+                Data: null,
+                StatusCode: 4000,
+                Message: error.message
+            });
         }
-      }`;
+    }`;
             break;
         case 'PUT':
-            swaggerDoc = `    /**
-     * @swagger
+            controllerMethod = `    /**
+     * @openapi
      * /api/${moduleName}/${customPath}/{id}:
      *   put:
-     *     summary: ${endpointNameCapitalized} ${moduleName}
+     *     summary: ${endpointNameCapitalized}
      *     description: ${description}
-     *     tags: [${moduleNameCapitalized}]
+     *     tags: [${moduleNameCapitalized}s]
      *     parameters:
      *       - in: path
      *         name: id
@@ -708,50 +1005,49 @@ async function addControllerMethod(modulePath, moduleName, moduleNameCapitalized
      *         application/json:
      *           schema:
      *             type: object
-     *             properties:
-     *               # Add your request body properties here
      *     responses:
      *       200:
-     *         description: ${endpointNameCapitalized} updated successfully
+     *         description: ${endpointNameCapitalized} executed successfully
      *         content:
      *           application/json:
      *             schema:
      *               type: object
      *               properties:
-     *                 data:
+     *                 Data:
      *                   type: object
-     *                 statusCode:
+     *                 StatusCode:
      *                   type: integer
      *                   example: 1000
-     *                 errors:
-     *                   type: array
-     *                   items:
-     *                     type: object
-     *                 requestIdentifier:
-     *                   type: string
-     *       404:
-     *         description: ${moduleNameCapitalized} not found
-     */`;
-            controllerMethod = `    async ${endpointName}(req: Request, res: Response): Promise<void> {
-        const requestIdentifier = req.headers['x-request-id'] || uuidv4();
+     *       400:
+     *         description: Bad request
+     */
+    async ${endpointName}(req, res) {
         try {
-          const data = await this.service.${endpointName}(req.params.id, req.body);
-          const result = new Result(data, ResponseCode.Ok, [], null, requestIdentifier as string);
-          return handleResponse(res, result);
-        } catch (error: any) {
-          const result = new Result(null, ResponseCode.Error, [{ message: error.message }], null, requestIdentifier as string);
-          return handleResponse(res, result);
+            const { id } = req.params;
+            const data = req.body;
+            const result = await this.service.${endpointName}(id, data);
+            res.json({
+                Data: result,
+                StatusCode: 1000,
+                Message: '${endpointNameCapitalized} executed successfully'
+            });
+        } catch (error) {
+            res.status(400).json({
+                Data: null,
+                StatusCode: 4000,
+                Message: error.message
+            });
         }
-      }`;
+    }`;
             break;
         case 'DELETE':
-            swaggerDoc = `    /**
-     * @swagger
+            controllerMethod = `    /**
+     * @openapi
      * /api/${moduleName}/${customPath}/{id}:
      *   delete:
-     *     summary: ${endpointNameCapitalized} ${moduleName}
+     *     summary: ${endpointNameCapitalized}
      *     description: ${description}
-     *     tags: [${moduleNameCapitalized}]
+     *     tags: [${moduleNameCapitalized}s]
      *     parameters:
      *       - in: path
      *         name: id
@@ -761,84 +1057,90 @@ async function addControllerMethod(modulePath, moduleName, moduleNameCapitalized
      *         description: ${moduleNameCapitalized} ID
      *     responses:
      *       200:
-     *         description: ${endpointNameCapitalized} completed successfully
+     *         description: ${endpointNameCapitalized} executed successfully
      *         content:
      *           application/json:
      *             schema:
      *               type: object
      *               properties:
-     *                 data:
+     *                 Data:
      *                   type: object
-     *                 statusCode:
+     *                 StatusCode:
      *                   type: integer
      *                   example: 1000
-     *                 errors:
-     *                   type: array
-     *                   items:
-     *                     type: object
-     *                 requestIdentifier:
-     *                   type: string
-     *       404:
-     *         description: ${moduleNameCapitalized} not found
-     */`;
-            controllerMethod = `    async ${endpointName}(req: Request, res: Response): Promise<void> {
-        const requestIdentifier = req.headers['x-request-id'] || uuidv4();
+     *       400:
+     *         description: Bad request
+     */
+    async ${endpointName}(req, res) {
         try {
-          const data = await this.service.${endpointName}(req.params.id);
-          const result = new Result(data, ResponseCode.Ok, [], null, requestIdentifier as string);
-          return handleResponse(res, result);
-        } catch (error: any) {
-          const result = new Result(null, ResponseCode.Error, [{ message: error.message }], null, requestIdentifier as string);
-          return handleResponse(res, result);
+            const { id } = req.params;
+            const result = await this.service.${endpointName}(id);
+            res.json({
+                Data: result,
+                StatusCode: 1000,
+                Message: '${endpointNameCapitalized} executed successfully'
+            });
+        } catch (error) {
+            res.status(400).json({
+                Data: null,
+                StatusCode: 4000,
+                Message: error.message
+            });
         }
-      }`;
+    }`;
             break;
         default:
-            swaggerDoc = `    /**
-     * @swagger
+            controllerMethod = `    /**
+     * @openapi
      * /api/${moduleName}/${customPath}:
      *   ${method.toLowerCase()}:
-     *     summary: ${endpointNameCapitalized} ${moduleName}
+     *     summary: ${endpointNameCapitalized}
      *     description: ${description}
-     *     tags: [${moduleNameCapitalized}]
+     *     tags: [${moduleNameCapitalized}s]
      *     responses:
      *       200:
-     *         description: ${endpointNameCapitalized} completed successfully
+     *         description: ${endpointNameCapitalized} executed successfully
      *         content:
      *           application/json:
      *             schema:
      *               type: object
      *               properties:
-     *                 data:
+     *                 Data:
      *                   type: object
-     *                 statusCode:
+     *                 StatusCode:
      *                   type: integer
      *                   example: 1000
-     *                 errors:
-     *                   type: array
-     *                   items:
-     *                     type: object
-     *                 requestIdentifier:
-     *                   type: string
      *       400:
      *         description: Bad request
-     */`;
-            controllerMethod = `    async ${endpointName}(req: Request, res: Response): Promise<void> {
-        const requestIdentifier = req.headers['x-request-id'] || uuidv4();
+     */
+    async ${endpointName}(req, res) {
         try {
-          const data = await this.service.${endpointName}(req.query);
-          const result = new Result(data, ResponseCode.Ok, [], null, requestIdentifier as string);
-          return handleResponse(res, result);
-        } catch (error: any) {
-          const result = new Result(null, ResponseCode.Error, [{ message: error.message }], null, requestIdentifier as string);
-          return handleResponse(res, result);
+            const params = req.query || req.body || req.params;
+            const result = await this.service.${endpointName}(params);
+            res.json({
+                Data: result,
+                StatusCode: 1000,
+                Message: '${endpointNameCapitalized} executed successfully'
+            });
+        } catch (error) {
+            res.status(400).json({
+                Data: null,
+                StatusCode: 4000,
+                Message: error.message
+            });
         }
-      }`;
+    }`;
+    }
+    // If method exists and force is enabled, replace it
+    if (controllerContent.includes(`async ${endpointName}(`) && force) {
+        const methodRegex = new RegExp(`\\s*async ${endpointName}\\([^)]*\\)\\s*\\{[^}]*\\}`, 's');
+        controllerContent = controllerContent.replace(methodRegex, controllerMethod);
+    }
+    else {
+        // Add method before the closing brace
+        const lastBraceIndex = controllerContent.lastIndexOf('}');
+        controllerContent = controllerContent.slice(0, lastBraceIndex) + controllerMethod + '\n' + controllerContent.slice(lastBraceIndex);
     }
-    // Add method before the closing brace
-    const lastBraceIndex = controllerContent.lastIndexOf('}');
-    const methodWithDoc = swaggerDoc + '\n' + controllerMethod;
-    controllerContent = controllerContent.slice(0, lastBraceIndex) + methodWithDoc + '\n' + controllerContent.slice(lastBraceIndex);
     fs.writeFileSync(controllerPath, controllerContent);
 }
 async function addRoute(modulePath, moduleName, moduleNameCapitalized, endpointName, endpointNameCapitalized, method, customPath) {