speedrun-cli 2.7.5 → 2.7.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "speedrun-cli",
-  "version": "2.7.5",
+  "version": "2.7.7",
   "description": "CLI tool to scaffold a production-ready NestJS authentication system with JWT, refresh tokens, and RBAC",
   "keywords": [
     "nestjs",

package/src/moduleGenerator.js

@@ -79,6 +79,81 @@ async function detectOrm(targetDir) {
   return 'prisma';
 }
 
+/**
+ * Ensures src/common/base exists with required abstract classes & DTOs
+ */
+async function ensureBaseArchitecture(targetDir) {
+  try {
+    const commonBaseDir = path.join(targetDir, 'src', 'common', 'base');
+
+    if (!(await fs.pathExists(commonBaseDir))) {
+      await fs.ensureDir(commonBaseDir);
+
+      // 1. base.controller.ts
+      await fs.writeFile(
+        path.join(commonBaseDir, 'base.controller.ts'),
+        `import { Type } from '@nestjs/common';
+
+export abstract class BaseController<T, CreateDto, UpdateDto> {
+  constructor(protected readonly service: any) {}
+  protected abstract getDtoClass(): Type<T>;
+  async create(dto: CreateDto): Promise<any> { return this.service.create(dto); }
+  async findAll(query: any): Promise<any> { return this.service.findAll(query); }
+  async findOne(id: string): Promise<any> { return this.service.findOne(id); }
+  async update(id: string, dto: UpdateDto): Promise<any> { return this.service.update(id, dto); }
+  async remove(id: string): Promise<any> { return this.service.remove(id); }
+}
+`
+      );
+
+      // 2. base.service.ts
+      await fs.writeFile(
+        path.join(commonBaseDir, 'base.service.ts'),
+        `import { Injectable } from '@nestjs/common';
+
+export interface PaginationQueryDto { page?: number; limit?: number; }
+export interface IBaseRepository<T, CreateDto, UpdateDto> {
+  create(dto: CreateDto): Promise<T>;
+  findAll(pagination: PaginationQueryDto): Promise<{ data: T[]; total: number }>;
+  findOne(id: string): Promise<T | null>;
+  update(id: string, dto: UpdateDto): Promise<T>;
+  remove(id: string): Promise<T>;
+}
+
+@Injectable()
+export abstract class BaseService<T, CreateDto, UpdateDto> {
+  protected abstract getRepository(): IBaseRepository<T, CreateDto, UpdateDto>;
+  async create(dto: CreateDto): Promise<T> { return this.getRepository().create(dto); }
+  async findAll(pagination: PaginationQueryDto): Promise<{ data: T[]; total: number }> { return this.getRepository().findAll(pagination); }
+  async findOne(id: string): Promise<T | null> { return this.getRepository().findOne(id); }
+  async update(id: string, dto: UpdateDto): Promise<T> { return this.getRepository().update(id, dto); }
+  async remove(id: string): Promise<T> { return this.getRepository().remove(id); }
+}
+`
+      );
+
+      // 3. index.ts (Re-exports & DTO helpers)
+      await fs.writeFile(
+        path.join(commonBaseDir, 'index.ts'),
+        `export * from './base.controller';
+export * from './base.service';
+
+export class ApiResponseDto<T> { statusCode: number; message: string; data: T; }
+export class PaginatedResponseDto<T> { statusCode: number; message: string; data: T[]; total: number; page: number; limit: number; }
+export class PaginationQueryDto { page?: number; limit?: number; }
+
+export function ApiResponseSchema(dto: any): any { return {}; }
+export function PaginatedResponseSchema(dto: any): any { return {}; }
+`
+      );
+
+      console.log(chalk.green('  ✓ Auto-generated missing src/common/base architecture'));
+    }
+  } catch (error) {
+    console.warn(chalk.yellow(`  ⚠️ Could not verify/create base architecture: ${error.message}`));
+  }
+}
+
 /**
  * Interactive prompt for module options (Name, CRUD Mode, Fields)
  */
@@ -124,6 +199,7 @@ async function promptForModuleOptions(providedModuleName) {
     selectedOperations = customOps;
   }
 
+  // Interactive Field Builder Loop
   // Interactive Field Builder Loop
   const { addCustomFields } = await inquirer.prompt([{
     type: 'confirm',
@@ -135,13 +211,16 @@ async function promptForModuleOptions(providedModuleName) {
   const fields = [];
 
   if (addCustomFields) {
-    let addAnother = true;
-    while (addAnother) {
-      const fieldAnswers = await inquirer.prompt([
+    let building = true;
+
+    // Helper untuk input field baru / edit
+    const promptSingleField = async (initialValues = {}) => {
+      return await inquirer.prompt([
         {
           type: 'input',
           name: 'fieldName',
           message: 'Enter field name (e.g., totalAmount, title):',
+          default: initialValues.name,
           validate: (input) => {
             if (!input || !input.trim()) return 'Field name is required';
             if (!/^[a-zA-Z][a-zA-Z0-9_]*$/.test(input.trim())) {
@@ -155,30 +234,96 @@ async function promptForModuleOptions(providedModuleName) {
           name: 'fieldType',
           message: (answers) => `Select field type for '${answers.fieldName}':`,
           choices: ['String', 'Number', 'Boolean', 'Date'],
-          default: 'String',
+          default: initialValues.type || 'String',
         },
         {
           type: 'confirm',
           name: 'isOptional',
           message: (answers) => `Is '${answers.fieldName}' optional?`,
-          default: false,
+          default: initialValues.isOptional !== undefined ? initialValues.isOptional : false,
         },
       ]);
+    };
+
+    // Tambah field pertama
+    console.log(chalk.cyan('\n--- Add Field 1 ---'));
+    const firstField = await promptSingleField();
+    fields.push({
+      name: firstField.fieldName.trim(),
+      type: firstField.fieldType,
+      isOptional: firstField.isOptional,
+    });
 
-      fields.push({
-        name: fieldAnswers.fieldName.trim(),
-        type: fieldAnswers.fieldType,
-        isOptional: fieldAnswers.isOptional,
-      });
-
-      const { continueLoop } = await inquirer.prompt([{
-        type: 'confirm',
-        name: 'continueLoop',
-        message: 'Do you want to add another field?',
-        default: false,
+    // Menu Navigasi (Add, Edit, Delete, Finish)
+    while (building) {
+      console.log(chalk.gray(`\nCurrent Fields (${fields.length}): `) + fields.map(f => chalk.yellow(`${f.name} (${f.type}${f.isOptional ? '?' : ''})`)).join(', '));
+
+      const { action } = await inquirer.prompt([{
+        type: 'list',
+        name: 'action',
+        message: 'What do you want to do next?',
+        choices: [
+          { name: '➕ Add another field', value: 'add' },
+          { name: '✏️  Edit an existing field', value: 'edit' },
+          { name: '🗑️  Delete a field', value: 'delete' },
+          { name: '✅ Finish and generate module', value: 'done' },
+        ],
       }]);
 
-      addAnother = continueLoop;
+      if (action === 'add') {
+        console.log(chalk.cyan(`\n--- Add Field ${fields.length + 1} ---`));
+        const newField = await promptSingleField();
+        fields.push({
+          name: newField.fieldName.trim(),
+          type: newField.fieldType,
+          isOptional: newField.isOptional,
+        });
+      } else if (action === 'edit') {
+        if (fields.length === 0) {
+          console.log(chalk.yellow('⚠️ No fields available to edit.'));
+          continue;
+        }
+
+        const { fieldToEditIndex } = await inquirer.prompt([{
+          type: 'list',
+          name: 'fieldToEditIndex',
+          message: 'Select field to edit:',
+          choices: fields.map((f, index) => ({
+            name: `${f.name} (${f.type}${f.isOptional ? '?' : ''})`,
+            value: index,
+          })),
+        }]);
+
+        console.log(chalk.cyan(`\n--- Editing Field '${fields[fieldToEditIndex].name}' ---`));
+        const editedField = await promptSingleField(fields[fieldToEditIndex]);
+        fields[fieldToEditIndex] = {
+          name: editedField.fieldName.trim(),
+          type: editedField.fieldType,
+          isOptional: editedField.isOptional,
+        };
+        console.log(chalk.green(`✓ Field '${fields[fieldToEditIndex].name}' updated successfully.`));
+      } else if (action === 'delete') {
+        if (fields.length === 0) {
+          console.log(chalk.yellow('⚠️ No fields available to delete.'));
+          continue;
+        }
+
+        const { fieldToDeleteIndex } = await inquirer.prompt([{
+          type: 'list',
+          name: 'fieldToDeleteIndex',
+          message: 'Select field to delete:',
+          choices: fields.map((f, index) => ({
+            name: `${f.name} (${f.type}${f.isOptional ? '?' : ''})`,
+            value: index,
+          })),
+        }]);
+
+        const deletedName = fields[fieldToDeleteIndex].name;
+        fields.splice(fieldToDeleteIndex, 1);
+        console.log(chalk.red(`🗑️ Field '${deletedName}' removed.`));
+      } else if (action === 'done') {
+        building = false;
+      }
     }
   }
 
@@ -186,12 +331,6 @@ async function promptForModuleOptions(providedModuleName) {
   if (fields.length === 0) {
     fields.push({ name: 'name', type: 'String', isOptional: false });
   }
-
-  return {
-    moduleName,
-    operations: selectedOperations,
-    fields,
-  };
 }
 
 function getFieldExampleValue(field, pascalName) {
@@ -284,9 +423,9 @@ ${fieldLines.join('\n')}
 
     content += modelDefinition;
     await fs.writeFile(schemaPath, content, 'utf8');
-    console.log(chalk.green(`   ✓ Updated prisma/schema.prisma with model ${singularPascal}`));
+    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}`));
+    console.warn(chalk.yellow(`    ⚠️ Could not sync prisma/schema.prisma: ${error.message}`));
   }
 }
 
@@ -341,9 +480,9 @@ ${fieldLines.join('\n\n')}
 `;
 
     await fs.writeFile(entityPath, entityContent, 'utf8');
-    console.log(chalk.green(`   ✓ Generated TypeORM entity at src/modules/${kebabName}/entities/${toSingularKebab(kebabName)}.entity.ts`));
+    console.log(chalk.green(`    ✓ Generated TypeORM entity at src/modules/${kebabName}/entities/${toSingularKebab(kebabName)}.entity.ts`));
   } catch (error) {
-    console.warn(chalk.yellow(`   ⚠️ Could not generate TypeORM entity: ${error.message}`));
+    console.warn(chalk.yellow(`    ⚠️ Could not generate TypeORM entity: ${error.message}`));
   }
 }
 
@@ -394,9 +533,9 @@ export const ${singularPascal}Schema = SchemaFactory.createForClass(${singularPa
 `;
 
     await fs.writeFile(schemaPath, schemaContent, 'utf8');
-    console.log(chalk.green(`   ✓ Generated Mongoose schema at src/modules/${kebabName}/schemas/${toSingularKebab(kebabName)}.schema.ts`));
+    console.log(chalk.green(`    ✓ Generated Mongoose schema at src/modules/${kebabName}/schemas/${toSingularKebab(kebabName)}.schema.ts`));
   } catch (error) {
-    console.warn(chalk.yellow(`   ⚠️ Could not generate Mongoose schema: ${error.message}`));
+    console.warn(chalk.yellow(`    ⚠️ Could not generate Mongoose schema: ${error.message}`));
   }
 }
 
@@ -442,9 +581,9 @@ export type New${singularPascal} = typeof ${toCamelCase(kebabName)}s.$inferInser
 `;
 
     await fs.writeFile(schemaPath, schemaContent, 'utf8');
-    console.log(chalk.green(`   ✓ Generated Drizzle schema at src/modules/${kebabName}/schema/${kebabName}.schema.ts`));
+    console.log(chalk.green(`    ✓ Generated Drizzle schema at src/modules/${kebabName}/schema/${kebabName}.schema.ts`));
   } catch (error) {
-    console.warn(chalk.yellow(`   ⚠️ Could not generate Drizzle schema: ${error.message}`));
+    console.warn(chalk.yellow(`    ⚠️ Could not generate Drizzle schema: ${error.message}`));
   }
 }
 
@@ -478,7 +617,7 @@ ${dummyObjFields}
 }
 `;
       await fs.writeFile(seedPath, seedContent, 'utf8');
-      console.log(chalk.green(`   ✓ Generated Prisma seed template at prisma/seeds/${kebabName}.seed.ts`));
+      console.log(chalk.green(`    ✓ Generated Prisma seed template at prisma/seeds/${kebabName}.seed.ts`));
     } else {
       const seedsDir = path.join(targetDir, 'src', 'database', 'seeds');
       await fs.ensureDir(seedsDir);
@@ -502,10 +641,10 @@ ${dummyObjFields}
 }
 `;
       await fs.writeFile(seedPath, seedContent, 'utf8');
-      console.log(chalk.green(`   ✓ Generated seed template at src/database/seeds/${kebabName}.seed.ts`));
+      console.log(chalk.green(`    ✓ Generated seed template at src/database/seeds/${kebabName}.seed.ts`));
     }
   } catch (error) {
-    console.warn(chalk.yellow(`   ⚠️ Could not generate seed template: ${error.message}`));
+    console.warn(chalk.yellow(`    ⚠️ Could not generate seed template: ${error.message}`));
   }
 }
 
@@ -843,6 +982,9 @@ async function registerInAppModule(targetDir, pascalName, kebabName) {
  */
 async function generateModule(providedModuleName, targetDir = process.cwd(), specifiedOrm = null) {
   try {
+    // Ensure src/common/base exists before generating any module components
+    await ensureBaseArchitecture(targetDir);
+
     const options = await promptForModuleOptions(providedModuleName);
     const kebabName = toKebabCase(options.moduleName);
     const pascalName = toPascalCase(options.moduleName);
@@ -991,11 +1133,10 @@ ${responseFieldsText}
     );
     await fs.writeFile(path.join(moduleDir, `${kebabName}.service.ts`), serviceContent);
 
-    // 4. Generate Controller
+    // 4. Generate Controller (Fixed single clean import path from common/base)
     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 } from '@nestjs/common';
 import { ApiTags, ApiBearerAuth, ApiExtraModels, ApiOperation, ApiResponse, ApiParam } from '@nestjs/swagger';
-import { BaseController } from '../../common/base/base.controller';
-import { ApiResponseDto, ApiResponseSchema, PaginatedResponseDto, PaginatedResponseSchema, PaginationQueryDto } from '../../common/base';
+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';
@@ -1074,7 +1215,7 @@ ${ops.create ? `
     await generateSeedFileTemplate(targetDir, orm, singularPascal, kebabName, options.fields);
 
     console.log(chalk.green(`\n✅ Module "${kebabName}" successfully generated in ${path.relative(process.cwd(), moduleDir)}`));
-    console.log(chalk.gray(`   Detected ORM: ${orm}`));
+    console.log(chalk.gray(`    Detected ORM: ${orm}`));
 
     if (!isAutoRegistered) {
       console.log(chalk.yellow(`\n⚠️ Please manually register ${pascalName}Module in src/app.module.ts:`));