nestcraftx 0.4.0 → 1.0.0

package/commands/list.js

@@ -0,0 +1,93 @@
+const fs = require("fs");
+const path = require("path");
+const { logError } = require("../utils/loggers/logError");
+const { logInfo } = require("../utils/loggers/logInfo");
+const { logWarning } = require("../utils/loggers/logWarning");
+const { bold } = require("../utils/colors");
+
+async function listCommand() {
+  const configPath = path.join(process.cwd(), ".nestcraftx", ".nestcraftxrc");
+
+  if (!fs.existsSync(configPath)) {
+    logError("Aucun fichier de configuration NestcraftX trouvé.");
+    logInfo("Assurez-vous d'être à la racine d'un projet NestcraftX.");
+    return;
+  }
+
+  let projectConfig;
+  try {
+    const rawData = fs.readFileSync(configPath, "utf8");
+    projectConfig = JSON.parse(rawData);
+  } catch (err) {
+    logError("Erreur lors de la lecture du fichier .nestcraftxrc. Le JSON est peut-être corrompu.");
+    return;
+  }
+
+  const { name, mode, orm, database, entities = [], relations = [] } = projectConfig;
+
+  console.log("\n" + "=".repeat(74));
+  console.log(`📋  Project: ${bold(name)} | Mode: ${bold(mode ? mode.toUpperCase() : "FULL")} | ORM: ${bold(orm ? orm.toUpperCase() : "")} | DB: ${bold(database || "")}`);
+  console.log("=".repeat(74));
+
+  if (entities.length === 0) {
+    logWarning("Aucune entité configurée pour le moment.");
+    return;
+  }
+
+  // 1. Draw Entities Table
+  console.log("\n" + bold("ENTITIES"));
+  console.log("┌" + "─".repeat(20) + "┬" + "─".repeat(50) + "┐");
+  console.log("│ " + "Entity Name".padEnd(18) + " │ " + "Fields (Type)".padEnd(48) + " │");
+  console.log("├" + "─".repeat(20) + "┼" + "─".repeat(50) + "┤");
+
+  entities.forEach(entity => {
+    const nameStr = entity.name || "";
+    const fieldsStr = (entity.fields || []).map(f => `${f.name} (${f.type})`).join(", ");
+    
+    // Chunk fields if they are too long to prevent table layout breakage
+    if (fieldsStr.length <= 48) {
+      console.log("│ " + nameStr.padEnd(18) + " │ " + fieldsStr.padEnd(48) + " │");
+    } else {
+      // Print first line
+      let chunk = fieldsStr.substring(0, 48);
+      let lastSpace = chunk.lastIndexOf(", ");
+      if (lastSpace > 30) {
+        chunk = fieldsStr.substring(0, lastSpace + 1);
+      }
+      console.log("│ " + nameStr.padEnd(18) + " │ " + chunk.padEnd(48) + " │");
+      
+      let remaining = fieldsStr.substring(chunk.length).trim();
+      while (remaining.length > 0) {
+        let nextChunk = remaining.substring(0, 48);
+        if (remaining.length > 48) {
+          let spaceIndex = nextChunk.lastIndexOf(", ");
+          if (spaceIndex > 30) {
+            nextChunk = remaining.substring(0, spaceIndex + 1);
+          }
+        }
+        console.log("│ " + "".padEnd(18) + " │ " + nextChunk.padEnd(48) + " │");
+        remaining = remaining.substring(nextChunk.length).trim();
+      }
+    }
+  });
+
+  console.log("└" + "─".repeat(20) + "┴" + "─".repeat(50) + "┘");
+
+  // 2. Draw Relations Table
+  if (relations && relations.length > 0) {
+    console.log("\n" + bold("RELATIONSHIPS"));
+    console.log("┌" + "─".repeat(40) + "┬" + "─".repeat(15) + "┐");
+    console.log("│ " + "Relation".padEnd(38) + " │ " + "Type".padEnd(13) + " │");
+    console.log("├" + "─".repeat(40) + "┼" + "─".repeat(15) + "┤");
+
+    relations.forEach(rel => {
+      const relationStr = `${rel.from} ──► ${rel.to}`;
+      const typeStr = rel.type || "";
+      console.log("│ " + relationStr.padEnd(38) + " │ " + typeStr.padEnd(13) + " │");
+    });
+
+    console.log("└" + "─".repeat(40) + "┴" + "─".repeat(15) + "┘\n");
+  }
+}
+
+module.exports = listCommand;

package/commands/new.js

@@ -36,7 +36,11 @@ async function newCommand(projectName, flags = {}) {
       }
     }
 
-    const inputs = await getFullModeInputs(currentProjectName, flags);
+    const mode = determineMode(flags);
+    const inputs =
+      mode === "light"
+        ? await buildLightModeInputs(currentProjectName, flags)
+        : await buildFullModeInputs(currentProjectName, flags);
     return executeProjectSetup(inputs);
   }
 
@@ -86,7 +90,8 @@ function hasAllLightModeFlags(flags) {
   if (flags.interactive === true) {
     return false;
   }
-  return flags.orm !== undefined;
+  const hasMode = flags.mode !== undefined || flags.light === true || flags.full === true;
+  return flags.orm !== undefined && hasMode;
 }
 
 function buildLightModeFromFlags(projectName, flags) {
@@ -97,13 +102,19 @@ function buildLightModeFromFlags(projectName, flags) {
     logError(`Unrecognized ORM: ${orm}. Using Prisma by default.`);
   }
 
+  let packageManager = "npm";
+  if (flags.pnpm) packageManager = "pnpm";
+  else if (flags.yarn) packageManager = "yarn";
+  else if (flags.packageManager) packageManager = flags.packageManager.toLowerCase();
+
   const inputs = {
     projectName,
     mode: "light",
-    useYarn: false,
+    useYarn: packageManager === "yarn",
     useDocker: flags.docker !== false,
     useAuth: !!flags.auth,
     useSwagger: !!flags.swagger,
+    useThrottler: !!flags.throttler,
     swaggerInputs: flags.swagger
       ? {
           title: `${projectName} API`,
@@ -112,7 +123,7 @@ function buildLightModeFromFlags(projectName, flags) {
           endpoint: "api/docs",
         }
       : undefined,
-    packageManager: "npm",
+    packageManager: packageManager,
     entitiesData: {
       entities: [],
       relations: [],
@@ -155,7 +166,8 @@ function hasAllFullModeFlags(flags) {
   if (flags.interactive === true) {
     return false;
   }
-  return flags.orm !== undefined;
+  const hasMode = flags.mode !== undefined || flags.light === true || flags.full === true;
+  return flags.orm !== undefined && hasMode;
 }
 
 function buildFullModeFromFlags(projectName, flags) {
@@ -164,7 +176,10 @@ function buildFullModeFromFlags(projectName, flags) {
   const validOrms = ["prisma", "typeorm", "mongoose"];
   const finalOrm = validOrms.includes(orm) ? orm : "prisma";
 
-  const packageManager = flags.yarn ? "yarn" : "npm";
+  let packageManager = "npm";
+  if (flags.pnpm) packageManager = "pnpm";
+  else if (flags.yarn) packageManager = "yarn";
+  else if (flags.packageManager) packageManager = flags.packageManager.toLowerCase();
 
   const defaultDBConfig =
     finalOrm === "mongoose"
@@ -182,18 +197,20 @@ function buildFullModeFromFlags(projectName, flags) {
           POSTGRES_PORT: flags.dbPort || "5432",
         };
 
-  const useAuth = flags.auth !== false;
-  const useSwagger = flags.swagger !== false;
+  const useAuth = !!flags.auth;
+  const useSwagger = !!flags.swagger;
   const useDocker = flags.docker !== false;
+  const useThrottler = !!flags.throttler;
 
   const inputs = {
     projectName,
     mode: "full",
-    useYarn: flags.yarn === true,
+    useYarn: packageManager === "yarn",
     packageManager: packageManager,
     useDocker: useDocker,
     useAuth: useAuth,
     useSwagger: useSwagger,
+    useThrottler: useThrottler,
     swaggerInputs: useSwagger
       ? {
           title: flags.swaggerTitle || `${projectName} API`,

package/jest.config.js

@@ -0,0 +1,9 @@
+module.exports = {
+  testEnvironment: 'node',
+  testMatch: ['**/tests/**/*.spec.js'],
+  verbose: true,
+  forceExit: true,
+  clearMocks: true,
+  resetMocks: true,
+  restoreMocks: true
+};

package/package.json

@@ -1,13 +1,15 @@
 {
   "name": "nestcraftx",
-  "version": "0.4.0",
+  "version": "1.0.0",
   "description": "Modern CLI to generate scalable NestJS projects with Clean Architecture (FULL) and MVP mode (LIGHT) - Enhanced with auto-generated .env secrets, complete ORM support, and entity relations",
   "main": "bin/nestcraft.js",
   "bin": {
     "nestcraftx": "bin/nestcraft.js"
   },
   "scripts": {
-    "test": "nestcraftx test"
+    "test": "jest --runInBand tests/unit",
+    "test:unit": "jest --runInBand tests/unit",
+    "test:e2e": "jest --runInBand tests/e2e"
   },
   "repository": {
     "type": "git",
@@ -37,5 +39,8 @@
   "dependencies": {
     "inquirer": "^12.10.0",
     "readline-sync": "^1.4.10"
+  },
+  "devDependencies": {
+    "jest": "^30.4.2"
   }
 }

package/readme.md

@@ -31,13 +31,13 @@ Key Features:
 
 - Smart Config: Automated Swagger decorators, auto-documented .env files, and pre-configured database connections.
 
-> **Version 0.2.5:** Major release — Interactive generation via flags, Auth refactored with session management, professional templates (gitignore, README), and clean code standards maintained by the community!
+> **Version 1.0.0 (Stable Release):** Production-grade NestJS scaffolding with Clean Architecture, JWT authentication, relations updater, conditional RBAC guards, global rate limiting, health checks, advanced pagination/filtering/sorting, Swagger UI, and Docker compose files!
 
 ---
 
 ## Table of Contents
 
-- [What's New in v0.2.5](#whats-new-in-v025)
+- [What's New in v1.0.0](#whats-new-in-v100-stable-release)
 - [Project Objective](#project-objective)
 - [Prerequisites](#prerequisites)
 - [Installation](#installation)
@@ -52,59 +52,32 @@ Key Features:
 
 ---
 
-## What's New in v0.2.5
+## What's New in v1.0.0 (Stable Release)
 
-### Two Architecture Modes
+### 🔗 Standalone Relation Command (`nestcraftx g relation`)
+- Create 1-n, n-1, 1-1, or n-n relations between **existing modules** at any time.
+- Automatically updates domain entities (FK fields and getters), DTOs (Create and Update), and data mappers.
+- Syncs database schemas (runs format, client generation, and migrations dev for Prisma; injects ObjectId references for Mongoose).
 
-**FULL Mode - Complete Architecture**
+### 🛡️ Conditional RBAC Guards & Swagger Integration
+- Mutation endpoints (`POST`, `PATCH`, `DELETE`) are protected with `JwtAuthGuard` and `RolesGuard` (`@Roles('ADMIN')`) only if Auth is enabled.
+- Read endpoints (`GET`, `GET :id`) are decorated with `@Public()`.
+- Generates complete API documentation using `@ApiBearerAuth()` and standard error responses when Swagger is enabled.
 
-- Clean Architecture with use-cases, mappers, adapters
-- Strict separation: domain/application/infrastructure/presentation
-- Ideal for complex and scalable projects
+### 🚦 Global Rate Limiting (Throttler Module)
+- Integrated `@nestjs/throttler` package with preconfigured global rate limiting policies (default: 10 requests per minute).
+- Configurable via interactive prompts or CLI flag `--throttler`.
 
-**LIGHT Mode - MVP Architecture**
+### 🏥 Health Check Endpoint (`/health`)
+- Exposes a native `/health` check route reporting global status (`ok`), timestamp, and application uptime (`process.uptime()`).
+- Fully documented in Swagger UI, optimized with zero third-party packages for fast compilation and maximum safety.
 
-- Simplified structure: controllers → services → repositories
-- Quick start for prototypes
-- Perfect for small projects and MVPs
+### 🚀 Advanced Query Params (Pagination, Filtering, Sorting)
+- Auto-injects paginated data retrieval (e.g. `?page=1&limit=10&search=...&sortBy=createdAt&sortOrder=desc`) into controllers and repository layers.
+- Seamlessly maps incoming query params to Prisma, TypeORM, and Mongoose queries.
 
-### Improved Demo Command
-
-- ✅ Flag options: `--light`, `--orm`, `--auth`, `--swagger`, `--docker`
-- ✅ Interactive mode: only asks questions for missing flags
-- ✅ Intelligent merging of flags and interactive responses
-- ✅ 3 pre-configured entities with relationships
-- ✅ Support for all ORMs (Prisma, TypeORM, Mongoose)
-- ✅ Separate instructions in [Demo Documentation](./DEMO.md)
-
-### Modern CLI with Flags
-
-```bash
-nestcraftx new <project-name> [options]
-
-Options:
-  --light              Simplified architecture mode
-  --full               Complete architecture mode (default)
-  --db=<db>            Database choice: postgresql|mongodb
-  --orm=<orm>          ORM choice: prisma|typeorm|mongoose
-  --auth               Enable JWT authentication
-  --swagger            Enable Swagger documentation
-  --docker             Enable Docker (default: true)
-```
-
-### Automatic Secret Generation
-
-- Auto-generated JWT secrets (64 secure characters)
-- Ready-to-use .env file
-- DATABASE_URL automatically configured
-- Sanitized .env.example file
-
-### Improved UX
-
-- Colored messages (info, success, error)
-- Animated spinners for long operations
-- Detailed post-generation summary
-- Real-time validation of options
+### 📋 Interactive Scaffolding Report
+- Out-of-the-box CLI report with ASCII borders after each module generation summarizing files generated, database schema updates, relations established, and clear next steps.
 
 ### Quick Examples
 
@@ -178,6 +151,21 @@ npm install
 npm link
 ```
 
+### Running Tests
+
+We use Jest to run unit tests and E2E generator compiler tests:
+
+```bash
+# Run unit tests (fast check)
+npm run test:unit
+
+# Run E2E integration tests (scaffolds project, runs npm install & tsc type checks)
+npm run test:e2e
+
+# Run all tests
+npm test
+```
+
 ---
 
 ## Available Commands
@@ -548,31 +536,34 @@ open http://localhost:3000/api/docs
 
 ## Roadmap
 
-### Version 0.2.x — Stabilization
+### Version 0.3.0 — Stabilization & UX (Completed)
+- [x] CommonJS module system unification
+- [x] Dynamic helper versioning and interactive flags checks
+- [x] Dynamic package manager setup
 
-- [x] Light & Full architectures
-- [x] Interactive CLI
-- [x] Multi-ORM support (Prisma / TypeORM / Mongoose)
-- [ ] Comprehensive documentation & realistic examples
+### Version 0.4.0 — Architecture Refactoring (Completed)
+- [x] Split of monolithic files into dedicated generators
+- [x] Interactive state-based `EntityBuilder` with revision menus
+- [x] Dry-run simulation mode (`--dry-run`)
 
-### Version 0.3.0 — Developer Experience
+### Version 0.5.0 — Quality & Security (Completed)
+- [x] Persistent DB storage for OTPs & password reset tokens
+- [x] Strict package version pinning
+- [x] Contextual semantic Swagger DTO descriptions
 
-- [ ] `generate` command (scaffold modules/entities into existing projects)
-- [ ] SQLite support for zero-config demos & prototyping
-- [ ] Enhanced error handling & colored terminal logs
+### Version 0.6.0 — Tests & CI/CD (Completed)
+- [x] Unit test coverage using Jest
+- [x] E2E compiler checks & resolution of upstream peer dependency conflicts
+- [x] Multi-OS Node.js matrix GitHub Actions CI/CD pipeline
 
-### Version 0.4.0 — Production Readiness
-
-- [ ] Pluggable session strategies (In-memory / Database / Redis)
-- [ ] Advanced data seeding templates
-- [ ] Project presets (API Only / Auth / Full CRUD)
+### Version 0.7.0 - 0.9.0 — Missing Features (In Progress)
+- [ ] Interactive `generate auth` and complete non-interactive execution
+- [ ] API Pagination, filtering, rate limiting, and RBAC guards
+- [ ] MySQL/SQLite support
 
 ### Version 1.0.0 — Stable Release
-
-- [ ] TypeScript-native CLI
-- [ ] Enforced conventions & stable API contracts
 - [ ] Official documentation website
-- [ ] Long-term support (LTS) guarantees
+- [ ] Production audit and LTS guarantees
 
 ---
 
@@ -629,7 +620,7 @@ Thanks to all contributors and the NestJS community!
 
 ---
 
-**NestCraftX v0.2.5** - Clean Architecture Made Simple
+**NestCraftX v0.6.0** - Clean Architecture Made Simple
 
 For more information:
 

package/tests/e2e/generator.spec.js

@@ -0,0 +1,71 @@
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+const demoCommand = require('../../commands/demo');
+
+describe('E2E Generator - Compilation Check', () => {
+  const e2eDir = path.join(__dirname, '..', 'e2e-output');
+  const projectDir = path.join(e2eDir, 'blog-demo');
+  const originalCwd = process.cwd();
+
+  beforeAll(() => {
+    // S'assurer que le dossier temporaire e2e-output existe et est vide
+    if (fs.existsSync(e2eDir)) {
+      fs.rmSync(e2eDir, { recursive: true, force: true });
+    }
+    fs.mkdirSync(e2eDir, { recursive: true });
+  });
+
+  afterAll(() => {
+    // Restaurer le CWD original et nettoyer les dossiers générés
+    process.chdir(originalCwd);
+    if (fs.existsSync(e2eDir)) {
+      try {
+        fs.rmSync(e2eDir, { recursive: true, force: true });
+      } catch (err) {
+        console.warn('Cleanup warning (some files might be locked):', err.message);
+      }
+    }
+  });
+
+  it('should generate a project with Prisma, Auth, Swagger and compile successfully', async () => {
+    // Se déplacer dans le dossier e2e-output avant la génération
+    process.chdir(e2eDir);
+
+    console.log('Generating E2E project...');
+    // Exécuter demoCommand en passant les options pour éviter les prompts inquirer
+    await demoCommand({
+      light: false, // Full Clean Architecture
+      orm: 'prisma',
+      docker: false,
+      auth: true,
+      swagger: true,
+      packageManager: 'npm'
+    });
+
+    // Vérifier l'existence physique du projet et de fichiers clés
+    expect(fs.existsSync(projectDir)).toBe(true);
+    expect(fs.existsSync(path.join(projectDir, 'package.json'))).toBe(true);
+    expect(fs.existsSync(path.join(projectDir, 'prisma', 'schema.prisma'))).toBe(true);
+    expect(fs.existsSync(path.join(projectDir, 'src', 'app.module.ts'))).toBe(true);
+
+    // Se déplacer dans le dossier du projet généré
+    process.chdir(projectDir);
+
+    console.log('Running npm install in the generated project...');
+    // Lancer npm install avec --legacy-peer-deps pour installer les dépendances figées
+    execSync('npm install --legacy-peer-deps --no-audit --no-fund', { stdio: 'inherit' });
+
+    console.log('Running tsc --noEmit in the generated project...');
+    // Lancer la vérification de type TypeScript
+    let compilePassed = false;
+    try {
+      execSync('npx tsc --noEmit', { stdio: 'inherit' });
+      compilePassed = true;
+    } catch (error) {
+      console.error('TypeScript compilation failed:', error.message);
+    }
+
+    expect(compilePassed).toBe(true);
+  }, 300000); // 5 minutes timeout pour npm install + compilation
+});

package/tests/unit/appModuleUpdater.spec.js

@@ -0,0 +1,111 @@
+const fs = require('fs');
+const { safeUpdateAppModule } = require('../../utils/app-module.updater');
+const { updateFile } = require('../../utils/file-system');
+
+// On mock fs et file-system
+jest.mock('fs');
+jest.mock('../../utils/file-system', () => ({
+  updateFile: jest.fn()
+}));
+
+describe('appModuleUpdater - safeUpdateAppModule', () => {
+  let originalArgv;
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    originalArgv = [...process.argv];
+  });
+
+  afterEach(() => {
+    process.argv = originalArgv;
+  });
+
+  it('should do nothing and log simulation during dry run', async () => {
+    process.argv.push('--dry-run');
+    const consoleSpy = jest.spyOn(console, 'log').mockImplementation(() => {});
+    
+    await safeUpdateAppModule('product');
+    
+    expect(fs.readFileSync).not.toHaveBeenCalled();
+    expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('[DRY-RUN] Simulated: safe update app.module.ts with ProductModule'));
+    
+    consoleSpy.mockRestore();
+  });
+
+  it('should insert import statement and inject module in @Module imports array', async () => {
+    // Retirer --dry-run
+    process.argv = process.argv.filter(arg => arg !== '--dry-run');
+
+    const initialAppModule = `
+import { Module } from '@nestjs/common';
+import { ConfigModule } from '@nestjs/config';
+
+@Module({
+  imports: [
+    ConfigModule.forRoot({ isGlobal: true }),
+  ],
+  controllers: [],
+  providers: [],
+})
+export class AppModule {}
+`;
+
+    // Mock fs.readFileSync pour retourner le contenu initial
+    fs.readFileSync.mockReturnValue(initialAppModule);
+
+    // Mock updateFile pour simuler la mise à jour de l'import et mettre à jour le mock de readFileSync
+    updateFile.mockImplementation(({ path, pattern, replacement }) => {
+      const updated = initialAppModule.replace(pattern, replacement);
+      fs.readFileSync.mockReturnValue(updated);
+      return Promise.resolve();
+    });
+
+    await safeUpdateAppModule('product');
+
+    // Vérifier l'insertion de l'import
+    expect(updateFile).toHaveBeenCalledWith({
+      path: 'src/app.module.ts',
+      pattern: "import { ConfigModule } from '@nestjs/config';",
+      replacement: "import { ConfigModule } from '@nestjs/config';\nimport { ProductModule } from 'src/product/product.module';"
+    });
+
+    // Vérifier la réécriture du fichier avec ProductModule injecté
+    expect(fs.writeFileSync).toHaveBeenCalledWith(
+      'src/app.module.ts',
+      expect.stringContaining('ProductModule'),
+      'utf-8'
+    );
+
+    // Le contenu final écrit doit ressembler à :
+    const lastWriteCall = fs.writeFileSync.mock.calls[0][1];
+    expect(lastWriteCall).toContain('imports: [ConfigModule.forRoot({ isGlobal: true }), ProductModule,]');
+  });
+
+  it('should be idempotent and not duplicate existing imports', async () => {
+    process.argv = process.argv.filter(arg => arg !== '--dry-run');
+
+    const appModuleWithProduct = `
+import { Module } from '@nestjs/common';
+import { ConfigModule } from '@nestjs/config';
+import { ProductModule } from 'src/product/product.module';
+
+@Module({
+  imports: [
+    ConfigModule.forRoot({ isGlobal: true }), ProductModule,
+  ],
+  controllers: [],
+  providers: [],
+})
+export class AppModule {}
+`;
+
+    fs.readFileSync.mockReturnValue(appModuleWithProduct);
+
+    await safeUpdateAppModule('product');
+
+    // updateFile ne doit pas être appelé car l'import est déjà présent
+    expect(updateFile).not.toHaveBeenCalled();
+    // writeFileSync ne doit pas être appelé car le module est déjà dans imports
+    expect(fs.writeFileSync).not.toHaveBeenCalled();
+  });
+});

package/tests/unit/cliParser.spec.js

@@ -0,0 +1,74 @@
+const { parseCliArgs } = require('../../utils/cliParser');
+
+describe('cliParser - parseCliArgs', () => {
+  it('should parse command "new" with valid project name', () => {
+    const args = ['node', 'bin/nestcraft.js', 'new', 'my-project'];
+    const result = parseCliArgs(args);
+    expect(result.command).toBe('new');
+    expect(result.projectName).toBe('my-project');
+    expect(result.errors).toHaveLength(0);
+  });
+
+  it('should register an error for invalid project name', () => {
+    const args = ['node', 'bin/nestcraft.js', 'new', 'my-project@123'];
+    const result = parseCliArgs(args);
+    expect(result.projectName).toBe('my-project@123');
+    expect(result.errors).toContain('Nom de projet invalide: "my-project@123".');
+  });
+
+  it('should parse "generate" subcommand and target entity name', () => {
+    const args = ['node', 'bin/nestcraft.js', 'generate', 'module', 'Product'];
+    const result = parseCliArgs(args);
+    expect(result.command).toBe('generate');
+    expect(result.subCommand).toBe('module');
+    expect(result.targetName).toBe('Product');
+  });
+
+  it('should support shorthand alias "g"', () => {
+    const args = ['node', 'bin/nestcraft.js', 'g', 'module', 'User'];
+    const result = parseCliArgs(args);
+    expect(result.command).toBe('g');
+    expect(result.subCommand).toBe('module');
+    expect(result.targetName).toBe('User');
+  });
+
+  it('should parse flags with key=value syntax', () => {
+    const args = ['node', 'bin/nestcraft.js', 'new', 'my-project', '--orm=prisma', '--mode=light'];
+    const result = parseCliArgs(args);
+    expect(result.flags.orm).toBe('prisma');
+    expect(result.flags.mode).toBe('light');
+    expect(result.errors).toHaveLength(0);
+  });
+
+  it('should parse flags followed by value', () => {
+    const args = ['node', 'bin/nestcraft.js', 'new', 'my-project', '--orm', 'mongoose'];
+    const result = parseCliArgs(args);
+    expect(result.flags.orm).toBe('mongoose');
+    expect(result.errors).toHaveLength(0);
+  });
+
+  it('should default boolean flags to true when no value is provided', () => {
+    const args = ['node', 'bin/nestcraft.js', 'new', 'my-project', '--docker', '--auth'];
+    const result = parseCliArgs(args);
+    expect(result.flags.docker).toBe(true);
+    expect(result.flags.auth).toBe(true);
+  });
+
+  it('should register an error for invalid ORM', () => {
+    const args = ['node', 'bin/nestcraft.js', 'new', 'my-project', '--orm=redis'];
+    const result = parseCliArgs(args);
+    expect(result.errors).toContain('ORM invalide: "redis". Valeurs acceptées: prisma, typeorm, mongoose');
+  });
+
+  it('should register an error for invalid mode', () => {
+    const args = ['node', 'bin/nestcraft.js', 'new', 'my-project', '--mode=ultra'];
+    const result = parseCliArgs(args);
+    expect(result.errors).toContain('Mode invalide: "ultra". Valeurs acceptées: full, light');
+  });
+
+  it('should register an error if both --full and --light flags are passed', () => {
+    const args = ['node', 'bin/nestcraft.js', 'new', 'my-project', '--full', '--light'];
+    const result = parseCliArgs(args);
+    expect(result.errors).toContain('Les flags --full et --light sont mutuellement exclusifs.');
+  });
+});