speedrun-cli 2.8.0 → 2.9.0

package/CHANGELOG.md

@@ -5,6 +5,28 @@ All notable changes to create-nestjs-auth will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [2.9.0] - 2026-08-22
+
+### Added
+- **Realistic Seed Generator (`speedrun-cli seed [module]` / alias `s` or `sd`)** — Introduced a new core CLI command and generator module (`src/seedGenerator.js`) to interactively generate realistic dummy data tailored to a module's active fields (emails, titles, prices, dates, UUIDs) targeting Prisma seed scripts (`prisma/seeds/[module].seed.ts` & master `prisma/seed.ts`), TypeORM custom scripts (`src/database/seeds/[module].seed.ts`), or raw JSON mock files (`src/modules/[module]/mock-data.json`).
+- **Interconnected CLI Ecosystem** — Integrated `seed` (`s`) with existing module parser (`parseExistingFields`), ORM detector (`detectOrm`), primary key resolver (`detectModulePrimaryKey`), and package manager runner.
+
+---
+
+## [2.8.2] - 2026-08-22
+
+### Added
+- **Duplicate Module Validation & Overwrite Guard** — When running `speedrun-cli g [module]`, the CLI now checks if the module directory (e.g. `src/modules/orange`) already exists. If detected, it displays a warning with hints to use `speedrun-cli field` (`f`) or `speedrun-cli config` (`c`), and prompts for explicit confirmation before proceeding (`default: false`), preventing accidental overwrites.
+
+---
+
+## [2.8.1] - 2026-08-22
+
+### Fixed
+- **Fixed TS2307: Cannot find module `../../common/guards/jwt-auth.guard`** — Enhanced `ensureBaseArchitecture(targetDir)` in `src/moduleGenerator.js` to automatically verify and scaffold placeholder guards (`src/common/guards/jwt-auth.guard.ts`, `src/common/guards/roles.guard.ts`) and decorators (`src/common/decorators/roles.decorator.ts`) whenever generating (`speedrun-cli g`) or configuring (`speedrun-cli c`) protected CRUD modules.
+
+---
+
 ## [2.8.0] - 2026-08-22
 
 ### Added

package/README.md

@@ -42,6 +42,7 @@ npx speedrun-cli create my-app
 * 🔗 **Relationship Builder:** Add `Many-to-One` or `One-to-Many` relationships to other modules directly from the terminal with automatic foreign key wiring.
 * ✏️ **Sub-Menu Interactive Field Manager (`speedrun-cli field` / `f`):** Modify existing generated modules on the fly. Selectively edit specific field attributes (Name, Type, or Optional status), add new fields, or delete fields with automated DTO and ORM schema re-sync.
 * ⚙️ **Dynamic Module Configurator (`speedrun-cli config` / `c`):** Customize Auth Guards, change role permissions (`@Roles('ADMIN', 'SUPERADMIN')`), and enable/disable active CRUD endpoints on existing controllers without rewriting code.
+* 🌱 **Realistic Seed Generator (`speedrun-cli seed` / `s` / `sd`):** Interactively generate dummy/seed data tailored to module fields (emails, titles, prices, dates, UUIDs) targeting Prisma seed scripts, TypeORM seed scripts, or raw JSON mock files.
 * 🏗️ **Automated Base Architecture:** Ensures `src/common/base` (`BaseController`, `BaseService`, and Swagger helpers) exists to eliminate missing import compilation errors (`TS2307`/`TS4112`).
 * 🔄 **Auto AppModule Registration:** Automatically injects generated modules into `src/app.module.ts`.
 
@@ -55,6 +56,7 @@ npx speedrun-cli create my-app
 | `speedrun-cli generate [module]` | `g` | Generates a new CRUD module with PKs, fields, ORM sync, and Auth Guards. |
 | `speedrun-cli field [module]` | `f` | Interactive Field Manager to Add, Edit (sub-menu), or Delete fields on existing modules. |
 | `speedrun-cli config [module]` | `c` | Customize role guards (`@Roles`), auth protection, and active CRUD operations. |
+| `speedrun-cli seed [module]` | `s` / `sd` | Generates realistic dummy/seed data scripts (Prisma, TypeORM, JSON) for a module. |
 
 ---
 
@@ -89,6 +91,12 @@ npx speedrun-cli f orders
 npx speedrun-cli c orders
 ```
 
+### 5. Generate Seed & Dummy Data
+```bash
+# Generate realistic seed data for Prisma, TypeORM, or raw JSON mock files
+npx speedrun-cli s orders
+```
+
 ---
 
 ## 💡 Why This Exists

package/bin/cli.js

@@ -30,6 +30,7 @@ const {
   generateModule,
   manageFields,
   configureModule,
+  generateSeed,
 } = require(path.join(packageRoot, 'src'));
 
 program
@@ -81,6 +82,21 @@ program
     }
   });
 
+// ==================== SEED GENERATOR COMMAND ====================
+program
+  .command('seed [module-name]')
+  .alias('s')
+  .alias('sd')
+  .description('Generate realistic seed/dummy data for a module')
+  .action(async (moduleName) => {
+    try {
+      console.log(chalk.cyan(`\n😱🤯🤯 speedrun-cli v${CLI_VERSION} seed generator 🤧🥶🥶🥶 (real)\n`));
+      await generateSeed(moduleName, process.cwd());
+    } catch (error) {
+      console.error(chalk.red('\n❌ Seed generation failed:'), error);
+    }
+  });
+
 // ==================== MAIN SCAFFOLD COMMAND (DEFAULT) ====================
 program
   .command('create [app-name]', { isDefault: true })

package/package.json

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

package/src/fieldManager.js

@@ -336,4 +336,4 @@ async function manageFields(providedModuleName, targetDir = process.cwd()) {
   }
 }
 
-module.exports = { manageFields };
+module.exports = { manageFields, parseExistingFields };

package/src/index.js

@@ -11,6 +11,7 @@ const postSetup = require('./postSetup');
 const moduleGenerator = require('./moduleGenerator');
 const fieldManager = require('./fieldManager');
 const moduleConfigurator = require('./moduleConfigurator');
+const seedGenerator = require('./seedGenerator');
 
 module.exports = {
   ...constants,
@@ -21,4 +22,5 @@ module.exports = {
   ...moduleGenerator,
   ...fieldManager,
   ...moduleConfigurator,
+  ...seedGenerator,
 };

package/src/moduleConfigurator.js

@@ -176,6 +176,9 @@ ${ops.create ? `
  */
 async function configureModule(providedModuleName, targetDir = process.cwd()) {
   try {
+    const { ensureBaseArchitecture } = require('./moduleGenerator');
+    await ensureBaseArchitecture(targetDir);
+
     let moduleName = providedModuleName;
 
     if (!moduleName) {

package/src/moduleGenerator.js

@@ -80,11 +80,13 @@ async function detectOrm(targetDir) {
 }
 
 /**
- * Ensures src/common/base exists with required abstract classes & DTOs
+ * Ensures src/common/base, src/common/guards, and src/common/decorators exist with required abstract classes, DTOs, guards & decorators
  */
 async function ensureBaseArchitecture(targetDir) {
   try {
     const commonBaseDir = path.join(targetDir, 'src', 'common', 'base');
+    const commonGuardsDir = path.join(targetDir, 'src', 'common', 'guards');
+    const commonDecoratorsDir = path.join(targetDir, 'src', 'common', 'decorators');
 
     if (!(await fs.pathExists(commonBaseDir))) {
       const templateBaseDir = path.join(__dirname, '..', 'templates', 'base-crud', 'src', 'common', 'base');
@@ -93,6 +95,54 @@ async function ensureBaseArchitecture(targetDir) {
         console.log(chalk.green('   ✓ Scaffolded Base CRUD architecture at src/common/base'));
       }
     }
+
+    // Scaffold Guards if missing
+    await fs.ensureDir(commonGuardsDir);
+    const jwtGuardPath = path.join(commonGuardsDir, 'jwt-auth.guard.ts');
+    const authGuardPath = path.join(commonGuardsDir, 'auth.guard.ts');
+    const rolesGuardPath = path.join(commonGuardsDir, 'roles.guard.ts');
+
+    if (!(await fs.pathExists(jwtGuardPath)) && !(await fs.pathExists(authGuardPath))) {
+      const jwtGuardContent = `import { Injectable, CanActivate, ExecutionContext } from '@nestjs/common';
+
+@Injectable()
+export class JwtAuthGuard implements CanActivate {
+  canActivate(context: ExecutionContext): boolean {
+    return true;
+  }
+}
+`;
+      await fs.writeFile(jwtGuardPath, jwtGuardContent, 'utf8');
+      console.log(chalk.green('   ✓ Scaffolded JwtAuthGuard at src/common/guards/jwt-auth.guard.ts'));
+    }
+
+    if (!(await fs.pathExists(rolesGuardPath))) {
+      const rolesGuardContent = `import { Injectable, CanActivate, ExecutionContext } from '@nestjs/common';
+
+@Injectable()
+export class RolesGuard implements CanActivate {
+  canActivate(context: ExecutionContext): boolean {
+    return true;
+  }
+}
+`;
+      await fs.writeFile(rolesGuardPath, rolesGuardContent, 'utf8');
+      console.log(chalk.green('   ✓ Scaffolded RolesGuard at src/common/guards/roles.guard.ts'));
+    }
+
+    // Scaffold Decorators if missing
+    await fs.ensureDir(commonDecoratorsDir);
+    const rolesDecoratorPath = path.join(commonDecoratorsDir, 'roles.decorator.ts');
+
+    if (!(await fs.pathExists(rolesDecoratorPath))) {
+      const rolesDecoratorContent = `import { SetMetadata } from '@nestjs/common';
+
+export const ROLES_KEY = 'roles';
+export const Roles = (...roles: string[]) => SetMetadata(ROLES_KEY, roles);
+`;
+      await fs.writeFile(rolesDecoratorPath, rolesDecoratorContent, 'utf8');
+      console.log(chalk.green('   ✓ Scaffolded Roles decorator at src/common/decorators/roles.decorator.ts'));
+    }
   } catch (error) {
     console.warn(chalk.yellow(`   ⚠️ Could not scaffold Base CRUD architecture: ${error.message}`));
   }
@@ -152,7 +202,7 @@ function getFieldDetails(fieldType) {
 /**
  * Interactive prompt for module options (Name, CRUD Mode, PK, Fields, Relations, Auth Guards)
  */
-async function promptForModuleOptions(providedModuleName, detectedOrm = 'prisma') {
+async function promptForModuleOptions(providedModuleName, detectedOrm = 'prisma', targetDir = process.cwd()) {
   let moduleName = providedModuleName;
 
   if (!moduleName) {
@@ -166,6 +216,30 @@ async function promptForModuleOptions(providedModuleName, detectedOrm = 'prisma'
   }
 
   const kebabName = toKebabCase(moduleName);
+  const srcDir = path.join(targetDir, 'src');
+  const moduleDir = (await fs.pathExists(srcDir))
+    ? path.join(srcDir, 'modules', kebabName)
+    : path.join(targetDir, 'modules', kebabName);
+
+  if (await fs.pathExists(moduleDir)) {
+    const relPath = path.relative(targetDir, moduleDir);
+    console.log(chalk.yellow(`\n⚠️  Module "${kebabName}" already exists at ${relPath}`));
+    console.log(chalk.gray(`   - Use "speedrun-cli field ${kebabName}" (alias: f) to add or edit fields.`));
+    console.log(chalk.gray(`   - Use "speedrun-cli config ${kebabName}" (alias: c) to configure guards & routes.\n`));
+
+    const { overwrite } = await inquirer.prompt([{
+      type: 'confirm',
+      name: 'overwrite',
+      message: `Do you still want to overwrite existing module "${kebabName}"?`,
+      default: false,
+    }]);
+
+    if (!overwrite) {
+      console.log(chalk.gray('Cancelled module generation. Existing module files preserved.\n'));
+      return null;
+    }
+  }
+
   const pascalName = toPascalCase(moduleName);
   const singularPascal = toSingularPascal(pascalName);
   const singularSnake = toSnakeCase(singularPascal);
@@ -1152,7 +1226,9 @@ async function generateModule(providedModuleName, targetDir = process.cwd(), spe
     // Detect ORM first so prompt choices match
     const orm = specifiedOrm || (await detectOrm(targetDir));
 
-    const options = await promptForModuleOptions(providedModuleName, orm);
+    const options = await promptForModuleOptions(providedModuleName, orm, targetDir);
+    if (!options) return false;
+
     const kebabName = toKebabCase(options.moduleName);
     const pascalName = toPascalCase(options.moduleName);
     const camelName = toCamelCase(options.moduleName);
@@ -1526,6 +1602,11 @@ module.exports = {
   detectModulePrimaryKey,
   getOrmFieldChoices,
   toKebabCase,
+  toCamelCase,
+  toPascalCase,
+  toSingularPascal,
+  toSingularCamel,
+  toSnakeCase,
   registerInAppModule,
   ensureBaseArchitecture,
   regenerateModuleComponents,

package/src/seedGenerator.js

@@ -0,0 +1,236 @@
+/**
+ * Seed Generator for speedrun-cli
+ * Generates realistic dummy/seed data for a target CRUD module based on its DTOs / ORM Schema.
+ * @module seedGenerator
+ */
+
+const inquirer = require('inquirer');
+const fs = require('fs-extra');
+const path = require('path');
+const chalk = require('chalk');
+const crypto = require('crypto');
+const {
+  detectOrm,
+  detectModulePrimaryKey,
+  toKebabCase,
+  toPascalCase,
+  toSingularPascal,
+  toSingularCamel,
+} = require('./moduleGenerator');
+const { parseExistingFields } = require('./fieldManager');
+const { detectPackageManager, getRunPrefix } = require('./utils');
+
+/**
+ * Generates realistic mock values based on field name and field type.
+ */
+function generateMockValue(fieldName, fieldType, index = 1) {
+  const lowerName = fieldName.toLowerCase();
+
+  if (lowerName.includes('email')) {
+    return `user${index}@example.com`;
+  }
+  if (lowerName.includes('phone') || lowerName.includes('mobile')) {
+    return `+1555010${(index % 100).toString().padStart(4, '0')}`;
+  }
+  if (lowerName.includes('name') || lowerName.includes('title')) {
+    return `Sample ${fieldName} ${index}`;
+  }
+  if (lowerName.includes('price') || lowerName.includes('amount') || lowerName.includes('cost') || lowerName.includes('total')) {
+    return Number((10 + index * 5.5).toFixed(2));
+  }
+  if (lowerName.includes('count') || lowerName.includes('quantity') || lowerName.includes('stock')) {
+    return 10 * index;
+  }
+  if (lowerName.includes('url') || lowerName.includes('image') || lowerName.includes('avatar')) {
+    return `https://example.com/assets/${lowerName}-${index}.jpg`;
+  }
+  if (lowerName.includes('description') || lowerName.includes('note') || lowerName.includes('remark') || lowerName.includes('comment')) {
+    return `This is a sample ${fieldName} content for item #${index}.`;
+  }
+
+  // Type fallbacks
+  const ft = (fieldType || '').toLowerCase();
+  if (['int', 'integer', 'number'].includes(ft)) {
+    return index * 10;
+  }
+  if (['float', 'decimal', 'numeric'].includes(ft)) {
+    return Number((9.99 + index).toFixed(2));
+  }
+  if (['boolean'].includes(ft)) {
+    return index % 2 === 0;
+  }
+  if (['datetime', 'date', 'timestamp'].includes(ft)) {
+    return new Date(Date.now() - index * 86400000).toISOString();
+  }
+  if (['json', 'object'].includes(ft)) {
+    return { key: `value_${index}` };
+  }
+  if (ft === 'array') {
+    return [`item_${index}_a`, `item_${index}_b`];
+  }
+
+  return `Sample ${fieldName} ${index}`;
+}
+
+/**
+ * Main Interactive Seed Generator Entry Point
+ */
+async function generateSeed(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 generate seed data for? (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 singularCamel = toSingularCamel(kebabName);
+
+    const srcDir = path.join(targetDir, 'src');
+    const moduleDir = (await fs.pathExists(srcDir))
+      ? path.join(srcDir, 'modules', kebabName)
+      : path.join(targetDir, 'modules', kebabName);
+
+    if (!(await fs.pathExists(moduleDir))) {
+      console.error(chalk.red(`\n❌ Module "${kebabName}" not found at ${moduleDir}`));
+      return false;
+    }
+
+    const orm = await detectOrm(targetDir);
+    const primaryKey = await detectModulePrimaryKey(moduleDir, kebabName);
+    const fields = await parseExistingFields(moduleDir, kebabName, orm);
+    const pm = detectPackageManager();
+    const runPrefix = getRunPrefix(pm);
+
+    console.log(chalk.cyan(`\n🌱 Generating seed data for module: ${chalk.bold(kebabName)} (Detected ORM: ${orm})`));
+
+    // 1. Prompt for count
+    const { countStr } = await inquirer.prompt([{
+      type: 'input',
+      name: 'countStr',
+      message: 'How many seed records do you want to generate?',
+      default: '10',
+      validate: (input) => {
+        const num = parseInt(input, 10);
+        return !isNaN(num) && num > 0 ? true : 'Please enter a positive integer';
+      },
+    }]);
+    const count = parseInt(countStr, 10);
+
+    // 2. Prompt for seed strategy
+    const { seedStrategy } = await inquirer.prompt([{
+      type: 'list',
+      name: 'seedStrategy',
+      message: 'Select target output format / seeding strategy:',
+      choices: [
+        { name: 'Prisma Seed Script (prisma/seeds/[module].seed.ts integration)', value: 'prisma' },
+        { name: 'TypeORM / Custom Script (src/database/seeds/[module].seed.ts)', value: 'typeorm' },
+        { name: 'Raw JSON Mock File (src/modules/[module]/mock-data.json)', value: 'json' },
+      ],
+      default: orm === 'prisma' ? 'prisma' : 'typeorm',
+    }]);
+
+    // 3. Generate Records
+    const records = [];
+    for (let i = 1; i <= count; i++) {
+      const uuidVal = crypto.randomUUID ? crypto.randomUUID() : `123e4567-e89b-12d3-a456-${(100000000000 + i).toString()}`;
+      const rec = {
+        [primaryKey]: uuidVal,
+      };
+
+      fields.forEach((f) => {
+        rec[f.name] = generateMockValue(f.name, f.type, i);
+      });
+
+      rec['status'] = 'ACTIVE';
+      records.push(rec);
+    }
+
+    // 4. Output according to selected strategy
+    if (seedStrategy === 'prisma') {
+      const prismaSeedsDir = path.join(targetDir, 'prisma', 'seeds');
+      await fs.ensureDir(prismaSeedsDir);
+      const moduleSeedPath = path.join(prismaSeedsDir, `${kebabName}.seed.ts`);
+
+      const seedScriptContent = `import { PrismaClient } from '@prisma/client';
+
+export const ${singularCamel}SeedData = ${JSON.stringify(records, null, 2)};
+
+export async function seed${pascalName}(prisma: PrismaClient) {
+  console.log('🌱 Seeding ${kebabName}...');
+  for (const item of ${singularCamel}SeedData) {
+    await (prisma as any).${singularCamel}.upsert({
+      where: { ${primaryKey}: item.${primaryKey} },
+      update: {},
+      create: item,
+    });
+  }
+  console.log('   ✓ Seeded ${count} ${kebabName} records');
+}
+`;
+      await fs.writeFile(moduleSeedPath, seedScriptContent, 'utf8');
+      console.log(chalk.green(`\n⚡ Generated Prisma seed script at: ${path.relative(targetDir, moduleSeedPath)}`));
+
+      // Check master prisma/seed.ts
+      const masterSeedPath = path.join(targetDir, 'prisma', 'seed.ts');
+      if (await fs.pathExists(masterSeedPath)) {
+        let masterContent = await fs.readFile(masterSeedPath, 'utf8');
+        const importLine = `import { seed${pascalName} } from './seeds/${kebabName}.seed';`;
+        const callLine = `await seed${pascalName}(prisma);`;
+
+        if (!masterContent.includes(importLine)) {
+          masterContent = `${importLine}\n` + masterContent;
+        }
+
+        if (!masterContent.includes(callLine)) {
+          masterContent = masterContent.replace(/async function main\(\) \{/, `async function main() {\n  ${callLine}`);
+        }
+
+        await fs.writeFile(masterSeedPath, masterContent, 'utf8');
+        console.log(chalk.green(`✨ Integrated seed${pascalName} into prisma/seed.ts`));
+      }
+
+      console.log(chalk.cyan(`\n💡 To execute this seed script, run:`));
+      console.log(chalk.bold(`   ${runPrefix} prisma:seed (or npx prisma db seed)\n`));
+    } else if (seedStrategy === 'typeorm') {
+      const seedsDir = path.join(targetDir, 'src', 'database', 'seeds');
+      await fs.ensureDir(seedsDir);
+      const customSeedPath = path.join(seedsDir, `${kebabName}.seed.ts`);
+
+      const customSeedContent = `/**
+ * Seed data for module "${kebabName}"
+ */
+export const ${singularCamel}SeedData = ${JSON.stringify(records, null, 2)};
+
+export async function seed${pascalName}() {
+  console.log('🌱 Seeding ${kebabName} with ${count} records...');
+  return ${singularCamel}SeedData;
+}
+`;
+      await fs.writeFile(customSeedPath, customSeedContent, 'utf8');
+      console.log(chalk.green(`\n⚡ Generated seed script at: ${path.relative(targetDir, customSeedPath)}`));
+      console.log(chalk.cyan(`\n💡 To execute custom seeds, run:`));
+      console.log(chalk.bold(`   ${runPrefix} db:seed (or ${runPrefix} seed)\n`));
+    } else if (seedStrategy === 'json') {
+      const jsonMockPath = path.join(moduleDir, 'mock-data.json');
+      await fs.writeFile(jsonMockPath, JSON.stringify(records, null, 2), 'utf8');
+      console.log(chalk.green(`\n⚡ Generated raw JSON mock data file at: ${path.relative(targetDir, jsonMockPath)}`));
+      console.log(chalk.gray(`   Contains ${count} mock records.\n`));
+    }
+
+    return true;
+  } catch (error) {
+    console.error(chalk.red('\n❌ Seed generation failed:'), error.message);
+    return false;
+  }
+}
+
+module.exports = { generateSeed, generateMockValue };

package/templates/base-crud/src/common/base/index.ts

@@ -18,3 +18,4 @@ export {
   PaginatedResponseDto,
   PaginatedResponseSchema,
 } from './swagger/paginated.dto';
+