speedrun-cli 2.7.10 → 2.8.0

package/src/moduleConfigurator.js

@@ -0,0 +1,336 @@
+/**
+ * Module Configurator for speedrun-cli
+ * Allows dynamic customization of Auth/Roles Guards and active CRUD endpoints on existing controllers.
+ * @module moduleConfigurator
+ */
+
+const inquirer = require('inquirer');
+const fs = require('fs-extra');
+const path = require('path');
+const chalk = require('chalk');
+const {
+  toKebabCase,
+  toPascalCase,
+  toSingularPascal,
+  detectModulePrimaryKey,
+} = require('./moduleGenerator');
+
+/**
+ * Detects whether JwtAuthGuard or AuthGuard is used in the project
+ */
+async function getGuardImportDetails(targetDir) {
+  const commonGuardsDir = path.join(targetDir, 'src', 'common', 'guards');
+  if (await fs.pathExists(path.join(commonGuardsDir, 'jwt-auth.guard.ts'))) {
+    return {
+      guardName: 'JwtAuthGuard',
+      guardImportPath: '../../common/guards/jwt-auth.guard',
+    };
+  }
+  if (await fs.pathExists(path.join(commonGuardsDir, 'auth.guard.ts'))) {
+    return {
+      guardName: 'AuthGuard',
+      guardImportPath: '../../common/guards/auth.guard',
+    };
+  }
+  return {
+    guardName: 'JwtAuthGuard',
+    guardImportPath: '../../common/guards/jwt-auth.guard',
+  };
+}
+
+/**
+ * Parses existing controller file to extract active CRUD operations and roles configuration
+ */
+function parseExistingController(controllerContent) {
+  const ops = {
+    create: /@Post\s*\(/m.test(controllerContent) && /override\s+async\s+create\s*\(/m.test(controllerContent),
+    findAll: /@Get\s*\(\s*\)/m.test(controllerContent) && /override\s+async\s+findAll\s*\(/m.test(controllerContent),
+    findOne: /@Get\s*\(\s*':/m.test(controllerContent) && /override\s+async\s+findOne\s*\(/m.test(controllerContent),
+    update: /@Put\s*\(/m.test(controllerContent) && /override\s+async\s+update\s*\(/m.test(controllerContent),
+    remove: /@Delete\s*\(/m.test(controllerContent) && /override\s+async\s+remove\s*\(/m.test(controllerContent),
+  };
+
+  const hasGuards = /@UseGuards\s*\(/m.test(controllerContent);
+
+  let roles = [];
+  const rolesMatch = controllerContent.match(/@Roles\s*\(\s*([^)]+)\s*\)/m) || controllerContent.match(/\/\/\s*Roles:\s*(.+)/m);
+  if (rolesMatch && rolesMatch[1]) {
+    roles = rolesMatch[1]
+      .split(',')
+      .map((r) => r.replace(/['"\s]/g, '').trim())
+      .filter(Boolean);
+  }
+
+  return { ops, hasGuards, roles };
+}
+
+/**
+ * Generates pristine controller TypeScript file content
+ */
+function renderControllerContent({
+  pascalName,
+  kebabName,
+  primaryKey = 'id',
+  createDtoName,
+  updateDtoName,
+  responseDtoName,
+  ops = { create: true, findAll: true, findOne: true, update: true, remove: true },
+  protectWriteOps = false,
+  roles = ['ADMIN'],
+  guardName = 'JwtAuthGuard',
+  guardImportPath = '../../common/guards/jwt-auth.guard',
+}) {
+  const formattedRoles = roles.map((r) => `'${r}'`).join(', ');
+  const guardDecorator = protectWriteOps && roles.length > 0
+    ? `\n  @UseGuards(${guardName}, RolesGuard)\n  @Roles(${formattedRoles})`
+    : protectWriteOps
+    ? `\n  @UseGuards(${guardName})`
+    : '';
+
+  const extraGuardsImports = protectWriteOps
+    ? `import { ${guardName} } from '${guardImportPath}';\nimport { RolesGuard } from '../../common/guards/roles.guard';\nimport { Roles } from '../../common/decorators/roles.decorator';\n`
+    : '';
+
+  const nestCommonImports = ['Controller'];
+  if (ops.findAll) nestCommonImports.push('Query');
+  if (ops.findOne || ops.update || ops.remove) nestCommonImports.push('Param', 'ParseUUIDPipe', 'HttpStatus');
+  if (ops.create) nestCommonImports.push('Post', 'Body');
+  if (ops.findAll || ops.findOne) nestCommonImports.push('Get');
+  if (ops.update) nestCommonImports.push('Put');
+  if (ops.remove) nestCommonImports.push('Delete');
+  nestCommonImports.push('Type');
+  if (protectWriteOps) nestCommonImports.push('UseGuards');
+
+  return `import { ${Array.from(new Set(nestCommonImports)).join(', ')} } from '@nestjs/common';
+import { ApiTags, ApiBearerAuth, ApiExtraModels, ApiOperation, ApiResponse, ApiParam } from '@nestjs/swagger';
+import { BaseController, ApiResponseDto, ApiResponseSchema, PaginatedResponseDto, PaginatedResponseSchema, PaginationQueryDto } from '../../common/base';
+${extraGuardsImports}import { ${pascalName}Service } from './${kebabName}.service';
+${ops.create || ops.update ? `import { ${createDtoName} } from './dto/create-${kebabName}.dto';\nimport { ${updateDtoName} } from './dto/update-${kebabName}.dto';` : `type ${createDtoName} = any;\ntype ${updateDtoName} = any;`}
+import { ${responseDtoName} } from './dto/${kebabName}.dto';
+
+type ${pascalName}Entity = any;
+
+@ApiTags('${pascalName}')
+@ApiBearerAuth('bearer')
+@ApiExtraModels(ApiResponseDto, PaginatedResponseDto, ${responseDtoName})
+@Controller('${kebabName}')
+export class ${pascalName}Controller extends BaseController<${pascalName}Entity, ${createDtoName}, ${updateDtoName}> {
+  constructor(protected readonly service: ${pascalName}Service) {
+    super(service);
+  }
+
+  protected getDtoClass(): Type<${pascalName}Entity> {
+    return ${responseDtoName} as unknown as Type<${pascalName}Entity>;
+  }
+${ops.create ? `
+  @Post()${guardDecorator}
+  @ApiOperation({ summary: 'Create a new ${kebabName}' })
+  @ApiResponse({ status: HttpStatus.CREATED, schema: ApiResponseSchema(${responseDtoName}) })
+  override async create(@Body() dto: ${createDtoName}): Promise<ApiResponseDto<${pascalName}Entity>> {
+    return super.create(dto);
+  }
+` : ''}${ops.findAll ? `
+  @Get()
+  @ApiOperation({ summary: 'Get all ${kebabName} (paginated)' })
+  @ApiResponse({ status: HttpStatus.OK, schema: PaginatedResponseSchema(${responseDtoName}) })
+  override async findAll(@Query() pagination: PaginationQueryDto): Promise<PaginatedResponseDto<${pascalName}Entity>> {
+    return super.findAll(pagination);
+  }
+` : ''}${ops.findOne ? `
+  @Get(':${primaryKey}')
+  @ApiOperation({ summary: 'Get ${kebabName} by ID' })
+  @ApiParam({ name: '${primaryKey}', format: 'uuid' })
+  @ApiResponse({ status: HttpStatus.OK, schema: ApiResponseSchema(${responseDtoName}) })
+  @ApiResponse({ status: HttpStatus.NOT_FOUND, description: '${pascalName} not found' })
+  override async findOne(@Param('${primaryKey}', new ParseUUIDPipe({ version: '4', errorHttpStatusCode: HttpStatus.BAD_REQUEST })) ${primaryKey}: string): Promise<ApiResponseDto<${pascalName}Entity>> {
+    return super.findOne(${primaryKey});
+  }
+` : ''}${ops.update ? `
+  @Put(':${primaryKey}')${guardDecorator}
+  @ApiOperation({ summary: 'Update ${kebabName} by ID' })
+  @ApiParam({ name: '${primaryKey}', format: 'uuid' })
+  @ApiResponse({ status: HttpStatus.OK, schema: ApiResponseSchema(${responseDtoName}) })
+  @ApiResponse({ status: HttpStatus.NOT_FOUND, description: '${pascalName} not found' })
+  override async update(
+    @Param('${primaryKey}', new ParseUUIDPipe({ version: '4', errorHttpStatusCode: HttpStatus.BAD_REQUEST })) ${primaryKey}: string,
+    @Body() dto: ${updateDtoName}
+  ): Promise<ApiResponseDto<${pascalName}Entity>> {
+    return super.update(${primaryKey}, dto);
+  }
+` : ''}${ops.remove ? `
+  @Delete(':${primaryKey}')${guardDecorator}
+  @ApiOperation({ summary: 'Delete ${kebabName} by ID' })
+  @ApiParam({ name: '${primaryKey}', format: 'uuid' })
+  @ApiResponse({ status: HttpStatus.OK, schema: ApiResponseSchema(${responseDtoName}) })
+  @ApiResponse({ status: HttpStatus.NOT_FOUND, description: '${pascalName} not found' })
+  override async remove(@Param('${primaryKey}', new ParseUUIDPipe({ version: '4', errorHttpStatusCode: HttpStatus.BAD_REQUEST })) ${primaryKey}: string): Promise<ApiResponseDto<${pascalName}Entity>> {
+    return super.remove(${primaryKey});
+  }
+` : ''}
+}
+`;
+}
+
+/**
+ * Main Interactive Module Configurator Entry Point
+ */
+async function configureModule(providedModuleName, targetDir = process.cwd()) {
+  try {
+    let moduleName = providedModuleName;
+
+    if (!moduleName) {
+      const nameAnswer = await inquirer.prompt([{
+        type: 'input',
+        name: 'moduleName',
+        message: 'Which module do you want to configure? (e.g., orders, products)',
+        validate: (input) => (input && input.trim() ? true : 'Module name is required'),
+      }]);
+      moduleName = nameAnswer.moduleName.trim();
+    }
+
+    const kebabName = toKebabCase(moduleName);
+    const pascalName = toPascalCase(moduleName);
+    const singularPascal = toSingularPascal(pascalName);
+
+    const srcDir = path.join(targetDir, 'src');
+    const moduleDir = (await fs.pathExists(srcDir))
+      ? path.join(srcDir, 'modules', kebabName)
+      : path.join(targetDir, 'modules', kebabName);
+    const controllerPath = path.join(moduleDir, `${kebabName}.controller.ts`);
+
+    if (!(await fs.pathExists(controllerPath))) {
+      console.error(chalk.red(`\n❌ Controller for module "${kebabName}" not found at ${controllerPath}`));
+      return false;
+    }
+
+    const controllerContent = await fs.readFile(controllerPath, 'utf8');
+    const { ops: currentOps, hasGuards, roles: currentRoles } = parseExistingController(controllerContent);
+    const primaryKey = await detectModulePrimaryKey(moduleDir, kebabName);
+    const { guardName, guardImportPath } = await getGuardImportDetails(targetDir);
+
+    const createDtoName = `Create${singularPascal}Dto`;
+    const updateDtoName = `Update${singularPascal}Dto`;
+    const responseDtoName = `${pascalName}Dto`;
+
+    console.log(chalk.cyan(`\n⚙️  Configuring module: ${chalk.bold(kebabName)}`));
+
+    const { configChoice } = await inquirer.prompt([{
+      type: 'list',
+      name: 'configChoice',
+      message: 'Select configuration action:',
+      choices: [
+        { name: '🔐 Manage Auth & Roles Guards (POST, PUT, DELETE protection)', value: 'guards' },
+        { name: '🛠️  Toggle Active CRUD Operations (Enable/Disable endpoints)', value: 'operations' },
+        { name: '❌ Cancel', value: 'cancel' },
+      ],
+    }]);
+
+    if (configChoice === 'cancel') {
+      console.log(chalk.gray('Cancelled configuration. No files modified.'));
+      return true;
+    }
+
+    let protectWriteOps = hasGuards;
+    let roles = currentRoles.length > 0 ? currentRoles : ['ADMIN'];
+    let updatedOps = { ...currentOps };
+
+    if (configChoice === 'guards') {
+      const guardAnswer = await inquirer.prompt([{
+        type: 'confirm',
+        name: 'protectWriteOps',
+        message: 'Protect write operations (POST, PUT, DELETE) with Auth/Roles Guard?',
+        default: hasGuards,
+      }]);
+
+      protectWriteOps = guardAnswer.protectWriteOps;
+
+      if (protectWriteOps) {
+        const roleAnswer = await inquirer.prompt([{
+          type: 'checkbox',
+          name: 'selectedRoles',
+          message: 'Select allowed roles for write operations:',
+          choices: [
+            { name: 'ADMIN', value: 'ADMIN', checked: roles.includes('ADMIN') || roles.length === 0 },
+            { name: 'USER', value: 'USER', checked: roles.includes('USER') },
+            { name: 'SUPERADMIN', value: 'SUPERADMIN', checked: roles.includes('SUPERADMIN') },
+            { name: 'MANAGER', value: 'MANAGER', checked: roles.includes('MANAGER') },
+            { name: 'Custom Role...', value: '__custom__' },
+          ],
+        }]);
+
+        let finalRoles = roleAnswer.selectedRoles.filter((r) => r !== '__custom__');
+
+        if (roleAnswer.selectedRoles.includes('__custom__')) {
+          const customRoleAnswer = await inquirer.prompt([{
+            type: 'input',
+            name: 'customRoles',
+            message: 'Enter custom role name(s) (comma-separated, e.g., AUDITOR, EDITOR):',
+            validate: (input) => (input && input.trim() ? true : 'Custom role is required'),
+          }]);
+
+          const parsedCustom = customRoleAnswer.customRoles
+            .split(',')
+            .map((r) => r.trim().toUpperCase())
+            .filter(Boolean);
+
+          finalRoles = Array.from(new Set([...finalRoles, ...parsedCustom]));
+        }
+
+        roles = finalRoles.length > 0 ? finalRoles : ['ADMIN'];
+      }
+    } else if (configChoice === 'operations') {
+      const opsAnswer = await inquirer.prompt([{
+        type: 'checkbox',
+        name: 'activeOps',
+        message: 'Select active CRUD operations:',
+        choices: [
+          { name: 'Create (POST)', value: 'create', checked: currentOps.create },
+          { name: 'Read All / findAll (GET)', value: 'findAll', checked: currentOps.findAll },
+          { name: 'Read One / findOne (GET /:id)', value: 'findOne', checked: currentOps.findOne },
+          { name: 'Update (PUT /:id)', value: 'update', checked: currentOps.update },
+          { name: 'Delete / remove (DELETE /:id)', value: 'remove', checked: currentOps.remove },
+        ],
+      }]);
+
+      updatedOps = {
+        create: opsAnswer.activeOps.includes('create'),
+        findAll: opsAnswer.activeOps.includes('findAll'),
+        findOne: opsAnswer.activeOps.includes('findOne'),
+        update: opsAnswer.activeOps.includes('update'),
+        remove: opsAnswer.activeOps.includes('remove'),
+      };
+    }
+
+    const updatedController = renderControllerContent({
+      pascalName,
+      kebabName,
+      primaryKey,
+      createDtoName,
+      updateDtoName,
+      responseDtoName,
+      ops: updatedOps,
+      protectWriteOps,
+      roles,
+      guardName,
+      guardImportPath,
+    });
+
+    await fs.writeFile(controllerPath, updatedController, 'utf8');
+    console.log(chalk.green(`\n✅ Successfully updated module configuration for "${kebabName}"!`));
+    console.log(chalk.gray(`   Controller: ${path.relative(process.cwd(), controllerPath)}`));
+    if (protectWriteOps) {
+      console.log(chalk.gray(`   Protected Write Ops: ${roles.join(', ')}`));
+    } else {
+      console.log(chalk.gray(`   Protected Write Ops: Disabled`));
+    }
+    const activeOpsList = Object.keys(updatedOps).filter((op) => updatedOps[op]);
+    console.log(chalk.gray(`   Active Operations: ${activeOpsList.join(', ')}`));
+
+    return true;
+  } catch (error) {
+    console.error(chalk.red('\n❌ Module configuration failed:'), error.message);
+    return false;
+  }
+}
+
+module.exports = { configureModule, renderControllerContent };

package/src/moduleGenerator.js

@@ -7,7 +7,7 @@ const inquirer = require('inquirer');
 const fs = require('fs-extra');
 const path = require('path');
 const chalk = require('chalk');
-require('./utils');
+const { detectPackageManager, getRunPrefix } = require('./utils');
 
 function toPascalCase(str) {
   return str
@@ -503,15 +503,19 @@ function getFieldExampleValue(field, pascalName) {
 
 /**
  * Dynamic ORM Schema Synchronization: Prisma
+ * @param {boolean} forceUpdate - When true, replace existing model block instead of skipping
  */
-async function syncPrismaSchema(targetDir, singularPascal, kebabName, primaryKey, fields, relations, includeStatus = true) {
+async function syncPrismaSchema(targetDir, singularPascal, kebabName, primaryKey, fields, relations, includeStatus = true, forceUpdate = false) {
   try {
     const schemaPath = path.join(targetDir, 'prisma', 'schema.prisma');
     if (!(await fs.pathExists(schemaPath))) return;
 
     let content = await fs.readFile(schemaPath, 'utf8');
 
-    if (new RegExp(`\\bmodel\\s+${singularPascal}\\b`).test(content)) {
+    const modelRegex = new RegExp(`(\\bmodel\\s+${singularPascal}\\s*\\{[^}]*\\})`, 's');
+    const modelExists = modelRegex.test(content);
+
+    if (modelExists && !forceUpdate) {
       return;
     }
 
@@ -547,9 +551,15 @@ ${relLines.length > 0 ? relLines.join('\n') + '\n' : ''}${statusLine}  createdAt
 }
 `;
 
-    content += modelDefinition;
+    if (modelExists && forceUpdate) {
+      content = content.replace(modelRegex, modelDefinition.trim());
+      console.log(chalk.green(`   ✓ Updated existing Prisma model ${singularPascal} in schema.prisma`));
+    } else {
+      content += modelDefinition;
+      console.log(chalk.green(`   ✓ Added Prisma model ${singularPascal} to schema.prisma`));
+    }
+
     await fs.writeFile(schemaPath, content, 'utf8');
-    console.log(chalk.green(`   ✓ Updated prisma/schema.prisma with model ${singularPascal}`));
   } catch (error) {
     console.warn(chalk.yellow(`   ⚠️ Could not sync prisma/schema.prisma: ${error.message}`));
   }
@@ -835,7 +845,7 @@ class TypeOrm${pascalName}Repository implements IBaseRepository<${pascalName}Ent
   }` : `async findOne(${primaryKey}: string): Promise<${pascalName}Entity | null> { throw new Error('Not implemented'); }`}
 
   ${ops.update ? `async update(${primaryKey}: string, dto: ${updateDtoName}): Promise<${pascalName}Entity> {
-    await this.repo.update(${primaryKey}, dto as any);
+    await this.repo.update({ ${primaryKey} } as any, dto as any);
     return this.repo.findOneOrFail({ where: { ${primaryKey} } as any });
   }` : `async update(${primaryKey}: string, dto: ${updateDtoName}): Promise<${pascalName}Entity> { throw new Error('Not implemented'); }`}
 
@@ -1206,17 +1216,27 @@ async function generateModule(providedModuleName, targetDir = process.cwd(), spe
       return `  ${swaggerDecorator}\n  ${valDecorators.join('\n  ')}\n  ${f.name}${f.isOptional ? '?' : ''}: ${details.tsType};`;
     }).join('\n\n');
 
+    // Build FK fields for Create DTO from relations (e.g., userId, categoryId)
+    const relationFkFields = (options.relations || []).map((r) => {
+      return `  @ApiPropertyOptional({ description: 'Foreign key linking to ${r.targetModule}', example: '123e4567-e89b-12d3-a456-426614174000', format: 'uuid' })\n  @IsOptional()\n  @IsUUID()\n  ${r.fkField}?: string;`;
+    }).join('\n\n');
+
     const hasDateFields = options.fields.some((f) => ['DateTime', 'timestamp', 'Date'].includes(f.type));
+    const hasRelations = (options.relations || []).length > 0;
 
-    // Validator import gathering
+    // Validator import gathering — only collect 'Is*' decorators (class-validator)
     const allValDecorators = new Set(['IsOptional', 'IsNotEmpty']);
     options.fields.forEach((f) => {
       const details = getFieldDetails(f.type);
       details.valDecorators.forEach((dec) => {
         const name = dec.replace('@', '').replace(/\(.*\)/, '');
-        if (name) allValDecorators.add(name);
+        // Only include class-validator decorators (Is* prefix), not Type from class-transformer
+        if (name && name.startsWith('Is')) allValDecorators.add(name);
       });
     });
+    if (hasRelations) allValDecorators.add('IsUUID');
+
+    const createDtoBody = [createFieldsText, relationFkFields].filter(Boolean).join('\n\n');
 
     if (ops.create || ops.update) {
       await fs.writeFile(
@@ -1225,7 +1245,7 @@ async function generateModule(providedModuleName, targetDir = process.cwd(), spe
 import { ${Array.from(allValDecorators).join(', ')} } from 'class-validator';
 ${hasDateFields ? `import { Type } from 'class-transformer';\n` : ''}
 export class ${createDtoName} {
-${createFieldsText}
+${createDtoBody}
 }
 `
       );
@@ -1252,6 +1272,11 @@ export class ${updateDtoName} extends PartialType(${createDtoName}) {}
       return `  ${swaggerDecorator}\n  ${f.name}${f.isOptional ? '?' : ''}: ${details.tsType};`;
     }).join('\n\n');
 
+    // FK relation fields in response DTO (always optional — may be null if not populated)
+    const responseFkFields = (options.relations || []).map((r) => {
+      return `  @ApiPropertyOptional({ example: '123e4567-e89b-12d3-a456-426614174000', format: 'uuid' })\n  ${r.fkField}?: string;`;
+    }).join('\n\n');
+
     const statusDtoField = options.includeStatus !== false
       ? `  @ApiProperty({ example: 'ACTIVE' })\n  status: string;\n\n`
       : '';
@@ -1264,7 +1289,9 @@ export class ${responseDtoName} {
   @ApiProperty({ example: '123e4567-e89b-12d3-a456-426614174000', format: 'uuid' })
   ${primaryKey}: string;
 
-${responseFieldsText}
+${responseFieldsText}${
+  responseFkFields ? `\n\n${responseFkFields}` : ''
+}
 
 ${statusDtoField}  @ApiProperty({ example: '2025-01-01T00:00:00.000Z' })
   createdAt: Date;
@@ -1293,79 +1320,18 @@ ${statusDtoField}  @ApiProperty({ example: '2025-01-01T00:00:00.000Z' })
     await fs.writeFile(path.join(moduleDir, `${kebabName}.service.ts`), serviceContent);
 
     // 4. Generate Controller
-    const guardImports = options.protectWriteOps ? `, UseGuards` : '';
-    const guardDecorator = options.protectWriteOps && options.roles?.length > 0
-      ? `\n  @UseGuards()\n  // Roles: ${options.roles.join(', ')}`
-      : '';
-
-    const controllerContent = `import { Controller${ops.findAll ? ', Query' : ''}${ops.findOne || ops.update || ops.remove ? ', Param, ParseUUIDPipe, HttpStatus' : ''}${ops.create ? ', Post, Body' : ''}${ops.findAll || ops.findOne ? ', Get' : ''}${ops.update ? ', Put' : ''}${ops.remove ? ', Delete' : ''}, Type${guardImports} } from '@nestjs/common';
-import { ApiTags, ApiBearerAuth, ApiExtraModels, ApiOperation, ApiResponse, ApiParam } from '@nestjs/swagger';
-import { BaseController, ApiResponseDto, ApiResponseSchema, PaginatedResponseDto, PaginatedResponseSchema, PaginationQueryDto } from '../../common/base';
-import { ${pascalName}Service } from './${kebabName}.service';
-${ops.create || ops.update ? `import { ${createDtoName} } from './dto/create-${kebabName}.dto';\nimport { ${updateDtoName} } from './dto/update-${kebabName}.dto';` : `type ${createDtoName} = any;\ntype ${updateDtoName} = any;`}
-import { ${responseDtoName} } from './dto/${kebabName}.dto';
-
-type ${pascalName}Entity = any;
-
-@ApiTags('${pascalName}')
-@ApiBearerAuth('bearer')
-@ApiExtraModels(ApiResponseDto, PaginatedResponseDto, ${responseDtoName})
-@Controller('${kebabName}')
-export class ${pascalName}Controller extends BaseController<${pascalName}Entity, ${createDtoName}, ${updateDtoName}> {
-  constructor(protected readonly service: ${pascalName}Service) {
-    super(service);
-  }
-
-  protected getDtoClass(): Type<${pascalName}Entity> {
-    return ${responseDtoName} as unknown as Type<${pascalName}Entity>;
-  }
-${ops.create ? `
-  @Post()${guardDecorator}
-  @ApiOperation({ summary: 'Create a new ${kebabName}' })
-  @ApiResponse({ status: HttpStatus.CREATED, schema: ApiResponseSchema(${responseDtoName}) })
-  override async create(@Body() dto: ${createDtoName}): Promise<ApiResponseDto<${pascalName}Entity>> {
-    return super.create(dto);
-  }
-` : ''}${ops.findAll ? `
-  @Get()
-  @ApiOperation({ summary: 'Get all ${kebabName} (paginated)' })
-  @ApiResponse({ status: HttpStatus.OK, schema: PaginatedResponseSchema(${responseDtoName}) })
-  override async findAll(@Query() pagination: PaginationQueryDto): Promise<PaginatedResponseDto<${pascalName}Entity>> {
-    return super.findAll(pagination);
-  }
-` : ''}${ops.findOne ? `
-  @Get(':${primaryKey}')
-  @ApiOperation({ summary: 'Get ${kebabName} by ID' })
-  @ApiParam({ name: '${primaryKey}', format: 'uuid' })
-  @ApiResponse({ status: HttpStatus.OK, schema: ApiResponseSchema(${responseDtoName}) })
-  @ApiResponse({ status: HttpStatus.NOT_FOUND, description: '${pascalName} not found' })
-  override async findOne(@Param('${primaryKey}', new ParseUUIDPipe({ version: '4', errorHttpStatusCode: HttpStatus.BAD_REQUEST })) ${primaryKey}: string): Promise<ApiResponseDto<${pascalName}Entity>> {
-    return super.findOne(${primaryKey});
-  }
-` : ''}${ops.update ? `
-  @Put(':${primaryKey}')${guardDecorator}
-  @ApiOperation({ summary: 'Update ${kebabName} by ID' })
-  @ApiParam({ name: '${primaryKey}', format: 'uuid' })
-  @ApiResponse({ status: HttpStatus.OK, schema: ApiResponseSchema(${responseDtoName}) })
-  @ApiResponse({ status: HttpStatus.NOT_FOUND, description: '${pascalName} not found' })
-  override async update(
-    @Param('${primaryKey}', new ParseUUIDPipe({ version: '4', errorHttpStatusCode: HttpStatus.BAD_REQUEST })) ${primaryKey}: string,
-    @Body() dto: ${updateDtoName}
-  ): Promise<ApiResponseDto<${pascalName}Entity>> {
-    return super.update(${primaryKey}, dto);
-  }
-` : ''}${ops.remove ? `
-  @Delete(':${primaryKey}')${guardDecorator}
-  @ApiOperation({ summary: 'Delete ${kebabName} by ID' })
-  @ApiParam({ name: '${primaryKey}', format: 'uuid' })
-  @ApiResponse({ status: HttpStatus.OK, schema: ApiResponseSchema(${responseDtoName}) })
-  @ApiResponse({ status: HttpStatus.NOT_FOUND, description: '${pascalName} not found' })
-  override async remove(@Param('${primaryKey}', new ParseUUIDPipe({ version: '4', errorHttpStatusCode: HttpStatus.BAD_REQUEST })) ${primaryKey}: string): Promise<ApiResponseDto<${pascalName}Entity>> {
-    return super.remove(${primaryKey});
-  }
-` : ''}
-}
-`;
+    const { renderControllerContent } = require('./moduleConfigurator');
+    const controllerContent = renderControllerContent({
+      pascalName,
+      kebabName,
+      primaryKey,
+      createDtoName,
+      updateDtoName,
+      responseDtoName,
+      ops,
+      protectWriteOps: options.protectWriteOps,
+      roles: options.roles || ['ADMIN'],
+    });
     await fs.writeFile(path.join(moduleDir, `${kebabName}.controller.ts`), controllerContent);
 
     // 5. Generate Module
@@ -1403,6 +1369,30 @@ export class AppModule {}
   }
 }
 
+/**
+ * Detect the primary key used by a module by scanning its response DTO file.
+ * Falls back to 'id' if the file is missing or no PK can be found.
+ */
+async function detectModulePrimaryKey(moduleDir, kebabName) {
+  try {
+    const dtoPath = path.join(moduleDir, 'dto', `${kebabName}.dto.ts`);
+    if (!(await fs.pathExists(dtoPath))) return 'id';
+
+    const content = await fs.readFile(dtoPath, 'utf8');
+    // The PK is the first property after 'export class Xxx {'
+    // It is decorated with @ApiProperty and has format: 'uuid'
+    const pkMatch = content.match(/@ApiProperty\([^)]*format:\s*['"](uuid)['"][^)]*\)[\s\S]*?\n\s*(\w+)\s*:/m);
+    if (pkMatch && pkMatch[2]) return pkMatch[2];
+
+    // Fallback: look for *_id or *Id as the first bare property
+    const firstPropMatch = content.match(/^\s*([a-zA-Z][a-zA-Z0-9_]*)\s*:/m);
+    if (firstPropMatch && firstPropMatch[1] !== 'status') return firstPropMatch[1];
+  } catch {
+    // swallow
+  }
+  return 'id';
+}
+
 /**
  * Regenerate module DTOs and ORM schemas when fields are updated via fieldManager
  */
@@ -1411,7 +1401,6 @@ async function regenerateModuleComponents(moduleName, fields, targetDir = proces
   const kebabName = toKebabCase(moduleName);
   const pascalName = toPascalCase(moduleName);
   const singularPascal = toSingularPascal(pascalName);
-  const primaryKey = 'id';
 
   const srcDir = path.join(targetDir, 'src');
   const moduleDir = (await fs.pathExists(srcDir))
@@ -1422,9 +1411,12 @@ async function regenerateModuleComponents(moduleName, fields, targetDir = proces
   await fs.ensureDir(moduleDir);
   await fs.ensureDir(dtoDir);
 
-  // 1. Sync ORM Schema
+  // Detect the existing primary key from the module's response DTO
+  const primaryKey = await detectModulePrimaryKey(moduleDir, kebabName);
+
+  // 1. Sync ORM Schema (forceUpdate=true so existing definitions are replaced)
   if (orm === 'prisma') {
-    await syncPrismaSchema(targetDir, singularPascal, kebabName, primaryKey, fields, [], true);
+    await syncPrismaSchema(targetDir, singularPascal, kebabName, primaryKey, fields, [], true, true);
   } else if (orm === 'typeorm') {
     await syncTypeOrmSchema(moduleDir, singularPascal, kebabName, primaryKey, fields, [], true);
   } else if (orm === 'mongoose') {
@@ -1464,7 +1456,8 @@ async function regenerateModuleComponents(moduleName, fields, targetDir = proces
     const details = getFieldDetails(f.type);
     details.valDecorators.forEach((dec) => {
       const name = dec.replace('@', '').replace(/\(.*\)/, '');
-      if (name) allValDecorators.add(name);
+      // Only class-validator Is* decorators — Type comes from class-transformer, not here
+      if (name && name.startsWith('Is')) allValDecorators.add(name);
     });
   });
 
@@ -1506,7 +1499,7 @@ export class ${updateDtoName} extends PartialType(${createDtoName}) {}
 
 export class ${responseDtoName} {
   @ApiProperty({ example: '123e4567-e89b-12d3-a456-426614174000', format: 'uuid' })
-  id: string;
+  ${primaryKey}: string;
 
 ${responseFieldsText}
 
@@ -1530,6 +1523,9 @@ module.exports = {
   generateModule,
   promptForModuleOptions,
   detectOrm,
+  detectModulePrimaryKey,
+  getOrmFieldChoices,
+  toKebabCase,
   registerInAppModule,
   ensureBaseArchitecture,
   regenerateModuleComponents,