nestcraftx 0.3.0 → 1.0.0

package/tests/unit/listCommand.spec.js

@@ -0,0 +1,91 @@
+const fs = require("fs");
+const path = require("path");
+const listCommand = require("../../commands/list");
+const { logError } = require("../../utils/loggers/logError");
+const { logWarning } = require("../../utils/loggers/logWarning");
+
+jest.mock("fs");
+jest.mock("../../utils/loggers/logError");
+jest.mock("../../utils/loggers/logWarning");
+jest.mock("../../utils/loggers/logInfo");
+
+describe("listCommand - nestcraftx list", () => {
+  let logSpy;
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    logSpy = jest.spyOn(console, "log").mockImplementation(() => {});
+  });
+
+  afterEach(() => {
+    logSpy.mockRestore();
+  });
+
+  it("should print an error if .nestcraftxrc does not exist", async () => {
+    fs.existsSync.mockReturnValue(false);
+
+    await listCommand();
+
+    expect(logError).toHaveBeenCalledWith(
+      expect.stringContaining("Aucun fichier de configuration NestcraftX trouvé.")
+    );
+  });
+
+  it("should print a warning if there are no entities", async () => {
+    fs.existsSync.mockReturnValue(true);
+    fs.readFileSync.mockReturnValue(
+      JSON.stringify({
+        name: "test-app",
+        mode: "full",
+        orm: "prisma",
+        database: "postgresql",
+        entities: [],
+        relations: []
+      })
+    );
+
+    await listCommand();
+
+    expect(logWarning).toHaveBeenCalledWith(
+      expect.stringContaining("Aucune entité configurée pour le moment.")
+    );
+  });
+
+  it("should print a beautiful table if entities and relations exist", async () => {
+    fs.existsSync.mockReturnValue(true);
+    fs.readFileSync.mockReturnValue(
+      JSON.stringify({
+        name: "test-app",
+        mode: "full",
+        orm: "prisma",
+        database: "postgresql",
+        entities: [
+          {
+            name: "user",
+            fields: [
+              { name: "email", type: "string" },
+              { name: "password", type: "string" }
+            ]
+          }
+        ],
+        relations: [
+          {
+            from: "user",
+            to: "session",
+            type: "1-n"
+          }
+        ]
+      })
+    );
+
+    await listCommand();
+
+    // Verify console.log prints the table structure
+    expect(logSpy).toHaveBeenCalledWith(expect.stringContaining("Project:"));
+    expect(logSpy).toHaveBeenCalledWith(expect.stringContaining("ENTITIES"));
+    expect(logSpy).toHaveBeenCalledWith(expect.stringContaining("user"));
+    expect(logSpy).toHaveBeenCalledWith(expect.stringContaining("email (string)"));
+    expect(logSpy).toHaveBeenCalledWith(expect.stringContaining("RELATIONSHIPS"));
+    expect(logSpy).toHaveBeenCalledWith(expect.stringContaining("user ──► session"));
+  });
+});

package/tests/unit/middlewareGenerator.spec.js

@@ -0,0 +1,64 @@
+const { generateMiddlewares } = require('../../utils/generators/infrastructure/middlewareGenerator');
+const { createFile, updateFile } = require('../../utils/file-system');
+
+// Mock file-system
+jest.mock('../../utils/file-system', () => ({
+  createDirectory: jest.fn().mockResolvedValue(undefined),
+  createFile: jest.fn().mockResolvedValue(undefined),
+  updateFile: jest.fn().mockResolvedValue(undefined),
+}));
+
+describe('middlewareGenerator - generateMiddlewares', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it('should generate typed exception filter for prisma ORM', async () => {
+    await generateMiddlewares('prisma');
+
+    // Vérifier la création de all-exceptions.filter.ts
+    const filterCall = createFile.mock.calls.find(call => 
+      call[0].path.endsWith('all-exceptions.filter.ts')
+    );
+
+    expect(filterCall).toBeDefined();
+    const content = filterCall[0].contente;
+
+    expect(content).toContain('export interface ErrorResponse');
+    expect(content).toContain('AllExceptionsFilter implements ExceptionFilter');
+    expect(content).toContain('PrismaClientKnownRequestError');
+    expect(content).toContain('process.env.NODE_ENV === \'production\'');
+    expect(content).toContain('payload: ErrorResponse');
+  });
+
+  it('should generate typed exception filter for mongoose ORM', async () => {
+    await generateMiddlewares('mongoose');
+
+    const filterCall = createFile.mock.calls.find(call => 
+      call[0].path.endsWith('all-exceptions.filter.ts')
+    );
+
+    expect(filterCall).toBeDefined();
+    const content = filterCall[0].contente;
+
+    expect(content).toContain('export interface ErrorResponse');
+    expect(content).toContain('MongoError');
+  });
+
+  it('should generate fallback/universal typed exception filter', async () => {
+    await generateMiddlewares('global');
+
+    const filterCall = createFile.mock.calls.find(call => 
+      call[0].path.endsWith('all-exceptions.filter.ts')
+    );
+
+    expect(filterCall).toBeDefined();
+    const content = filterCall[0].contente;
+
+    expect(content).toContain('export interface ErrorResponse');
+    // Doit contenir les vérifications spécifiques des différents ORM pour la version universelle
+    expect(content).toContain('PrismaClientKnownRequestError');
+    expect(content).toContain('MongoError');
+    expect(content).toContain('QueryFailedError');
+  });
+});

package/tests/unit/newCommand.spec.js

@@ -0,0 +1,88 @@
+const { getFullModeInputs } = require("../../utils/fullModeInput");
+const { getLightModeInputs } = require("../../utils/lightModeInput");
+const { runProjectSetupPipeline } = require("../../utils/setups/projectSetup");
+const readline = require("readline-sync");
+
+// Mock dependencies at the top before requiring commands/new
+jest.mock("../../utils/fullModeInput", () => ({
+  getFullModeInputs: jest.fn()
+}));
+jest.mock("../../utils/lightModeInput", () => ({
+  getLightModeInputs: jest.fn()
+}));
+jest.mock("../../utils/setups/projectSetup");
+jest.mock("readline-sync");
+jest.mock("../../utils/loggers/logSuccess");
+jest.mock("../../utils/loggers/logInfo");
+jest.mock("../../utils/loggers/logWarning");
+
+const newCommand = require("../../commands/new");
+
+describe("newCommand - Interactive vs Non-Interactive Mode", () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it("should run non-interactively in full mode if --orm and --full are passed", async () => {
+    runProjectSetupPipeline.mockResolvedValue();
+
+    const flags = { orm: "prisma", full: true, docker: false, auth: false, swagger: false };
+    await newCommand("test-non-interactive", flags);
+
+    expect(runProjectSetupPipeline).toHaveBeenCalledWith(
+      expect.objectContaining({
+        projectName: "test-non-interactive",
+        mode: "full",
+        useAuth: false,
+        useSwagger: false,
+        useDocker: false,
+        packageManager: "npm",
+        dbConfig: expect.objectContaining({
+          orm: "prisma"
+        })
+      })
+    );
+  });
+
+  it("should run non-interactively in light mode if --orm and --light are passed", async () => {
+    runProjectSetupPipeline.mockResolvedValue();
+
+    const flags = { orm: "mongoose", light: true, auth: true, swagger: true };
+    await newCommand("test-light-non-interactive", flags);
+
+    expect(runProjectSetupPipeline).toHaveBeenCalledWith(
+      expect.objectContaining({
+        projectName: "test-light-non-interactive",
+        mode: "light",
+        useAuth: true,
+        useSwagger: true,
+        useDocker: true, // defaults to true
+        packageManager: "npm",
+        dbConfig: expect.objectContaining({
+          orm: "mongoose"
+        })
+      })
+    );
+  });
+
+  it("should prompt if mandatory flags are missing", async () => {
+    getFullModeInputs.mockResolvedValue({
+      projectName: "test-app",
+      mode: "full",
+      useAuth: false,
+      useSwagger: false,
+      useDocker: true,
+      packageManager: "npm",
+      entitiesData: { entities: [], relations: [] },
+      selectedDB: "postgresql",
+      dbConfig: { orm: "prisma" }
+    });
+
+    runProjectSetupPipeline.mockResolvedValue();
+
+    // No mode/light/full flags, only orm -> should fall back to interactive
+    await newCommand("test-app", { orm: "prisma" });
+
+    expect(getFullModeInputs).toHaveBeenCalled();
+  });
+});

package/tests/unit/relationCommand.spec.js

@@ -0,0 +1,202 @@
+// tests/unit/relationCommand.spec.js
+//
+// Tests unitaires pour la commande `nestcraftx g relation` (FEAT-14).
+// Valide :
+//  - askRelationCommand : validation idempotence, entités insuffisantes
+//  - handleRelationGeneration : orchestration correcte (mocks)
+//  - addPrismaRelation : génération des bons champs selon le type de relation
+
+const inquirer = require('inquirer');
+
+// Mock inquirer globalement avant d'importer askRelationCommand
+jest.mock('inquirer', () => {
+  const mockPrompt = jest.fn();
+  return {
+    prompt: mockPrompt,
+    default: {
+      prompt: mockPrompt,
+    },
+  };
+});
+
+const { askRelationCommand } = require('../../utils/interactive/askRelationCommand');
+const { resolveForeignKeyOwner } = require('../../utils/generators/relation/relation.engine');
+
+// ─── Helpers ────────────────────────────────────────────────────────────────
+
+function makeConfig({ entities = [], relations = [] } = {}) {
+  return {
+    mode: 'full',
+    orm: 'prisma',
+    swagger: false,
+    auth: false,
+    entities,
+    relations,
+  };
+}
+
+// ─── Tests : askRelationCommand ──────────────────────────────────────────────
+
+describe('askRelationCommand', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it('should return null and log error if fewer than 2 entities exist', async () => {
+    const config = makeConfig({ entities: [{ name: 'Post' }] });
+
+    // Intercepter logError sans faire crasher le test
+    const errorSpy = jest.spyOn(console, 'error').mockImplementation(() => {});
+
+    const result = await askRelationCommand(config);
+
+    expect(result).toBeNull();
+    errorSpy.mockRestore();
+  });
+
+  it('should return null and log warning if relation already exists (idempotence)', async () => {
+    const config = makeConfig({
+      entities: [{ name: 'Post' }, { name: 'User' }],
+      relations: [{ from: 'post', to: 'user', type: 'n-1' }],
+    });
+
+    const mockPrompt = inquirer.prompt;
+    mockPrompt
+      .mockResolvedValueOnce({ source: 'Post' })
+      .mockResolvedValueOnce({ target: 'User' })
+      .mockResolvedValueOnce({ type: 'n-1' });
+
+    const warnSpy = jest.spyOn(console, 'warn').mockImplementation(() => {});
+
+    const result = await askRelationCommand(config);
+
+    // Relation already exists — should be blocked
+    expect(result).toBeNull();
+    warnSpy.mockRestore();
+  });
+
+  it('should return relation data when valid inputs are provided', async () => {
+    const config = makeConfig({
+      entities: [{ name: 'Post' }, { name: 'User' }],
+      relations: [], // Aucune relation existante
+    });
+
+    const mockPrompt = inquirer.prompt;
+    mockPrompt
+      .mockResolvedValueOnce({ source: 'Post' })
+      .mockResolvedValueOnce({ target: 'User' })
+      .mockResolvedValueOnce({ type: 'n-1' });
+
+    const result = await askRelationCommand(config);
+
+    expect(result).toEqual({
+      source: 'post',
+      target: 'user',
+      type: 'n-1',
+    });
+  });
+});
+
+// ─── Tests : resolveForeignKeyOwner ─────────────────────────────────────────
+
+describe('relation.engine - resolveForeignKeyOwner', () => {
+  it('should return null for 1-n (FK on the target side)', () => {
+    const result = resolveForeignKeyOwner('Post', 'User', '1-n');
+    expect(result).toBeNull();
+  });
+
+  it('should return owner for n-1 (FK on the source side)', () => {
+    const result = resolveForeignKeyOwner('Post', 'User', 'n-1');
+    expect(result).not.toBeNull();
+    expect(result.ownerEntity).toBe('User');
+    expect(result.relatedEntity).toBe('Post');
+  });
+
+  it('should return owner for 1-1 (FK on source by convention)', () => {
+    const result = resolveForeignKeyOwner('Post', 'User', '1-1');
+    expect(result).not.toBeNull();
+    expect(result.ownerEntity).toBe('User');
+  });
+
+  it('should return null for n-n (pivot table, no direct FK)', () => {
+    const result = resolveForeignKeyOwner('Post', 'Tag', 'n-n');
+    expect(result).toBeNull();
+  });
+
+  it('should throw for unknown relation type', () => {
+    expect(() => resolveForeignKeyOwner('Post', 'User', 'x-y')).toThrow('Unknown relation type');
+  });
+});
+
+// ─── Tests : addPrismaRelation (génération de champs) ───────────────────────
+
+describe('addPrismaRelation - field generation logic', () => {
+  function resolveSourceFields(source, target, type) {
+    const targetLow = target.toLowerCase();
+    const targetCap = target.charAt(0).toUpperCase() + target.slice(1);
+    switch (type) {
+      case 'n-1': return `${targetLow}   ${targetCap} @relation(fields: [${targetLow}Id], references: [id])\n  ${targetLow}Id String`;
+      case '1-n': return `${targetLow}s  ${targetCap}[]`;
+      case '1-1': return `${targetLow}   ${targetCap}? @relation(fields: [${targetLow}Id], references: [id])\n  ${targetLow}Id String? @unique`;
+      case 'n-n': return `${targetLow}s  ${targetCap}[]`;
+      default: throw new Error(`Unknown relation type: ${type}`);
+    }
+  }
+
+  it('n-1: source should get a FK field and @relation decorator', () => {
+    const fields = resolveSourceFields('post', 'user', 'n-1');
+    expect(fields).toContain('userId String');
+    expect(fields).toContain('@relation(fields: [userId], references: [id])');
+  });
+
+  it('1-n: source should get an array field', () => {
+    const fields = resolveSourceFields('user', 'post', '1-n');
+    expect(fields).toContain('posts  Post[]');
+  });
+
+  it('1-1: source should get a unique FK field', () => {
+    const fields = resolveSourceFields('profile', 'user', '1-1');
+    expect(fields).toContain('userId String? @unique');
+    expect(fields).toContain('@relation(fields: [userId], references: [id])');
+  });
+
+  it('n-n: source should get an array field (pivot)', () => {
+    const fields = resolveSourceFields('post', 'tag', 'n-n');
+    expect(fields).toContain('tags  Tag[]');
+  });
+
+  it('should throw for unknown relation type', () => {
+    expect(() => resolveSourceFields('post', 'user', 'bad')).toThrow('Unknown relation type');
+  });
+});
+
+// ─── Tests : .nestcraftxrc persistence logic ─────────────────────────────────
+
+describe('handleRelationGeneration - .nestcraftxrc update logic', () => {
+  it('should add a new relation to config.relations', () => {
+    const config = makeConfig({ relations: [] });
+    const newRelation = { from: 'post', to: 'user', type: 'n-1' };
+
+    config.relations.push(newRelation);
+
+    expect(config.relations).toHaveLength(1);
+    expect(config.relations[0]).toMatchObject({ from: 'post', to: 'user', type: 'n-1' });
+  });
+
+  it('should not duplicate a relation already in config.relations', () => {
+    const config = makeConfig({
+      relations: [{ from: 'post', to: 'user', type: 'n-1' }],
+    });
+
+    const source = 'post';
+    const target = 'user';
+    const type = 'n-1';
+
+    config.relations = config.relations.filter(
+      (r) => !(r.from.toLowerCase() === source && r.to.toLowerCase() === target && r.type === type),
+    );
+    config.relations.push({ from: source, to: target, type });
+
+    expect(config.relations).toHaveLength(1);
+  });
+});

package/tests/unit/throttler.spec.js

@@ -0,0 +1,117 @@
+// tests/unit/throttler.spec.js
+//
+// Tests unitaires pour la configuration de @nestjs/throttler (FEAT-08).
+// Valide :
+//  - L'installation du package avec le bon package manager
+//  - La configuration correcte de app.module.ts (imports, modules, providers)
+//  - L'idempotence de la configuration
+
+const fs = require('fs');
+const { setupThrottler } = require('../../utils/setups/setupThrottler');
+const { runCommand } = require('../../utils/shell');
+const { updateFile } = require('../../utils/file-system');
+
+// Mock shell et file-system
+jest.mock('../../utils/shell', () => ({
+  runCommand: jest.fn().mockResolvedValue(undefined),
+}));
+
+jest.mock('../../utils/file-system', () => ({
+  updateFile: jest.fn().mockResolvedValue(undefined),
+  createFile: jest.fn().mockResolvedValue(undefined),
+}));
+
+describe('setupThrottler', () => {
+  const mockAppModulePath = 'src/app.module.ts';
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    jest.spyOn(fs, 'existsSync').mockReturnValue(true);
+  });
+
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  it('should run installation with selected package manager', async () => {
+    const fsReadSpy = jest.spyOn(fs, 'readFileSync').mockReturnValue(`
+import { Module } from '@nestjs/common';
+@Module({
+  imports: [],
+})
+export class AppModule {}
+    `);
+    const fsWriteSpy = jest.spyOn(fs, 'writeFileSync').mockImplementation(() => {});
+
+    await setupThrottler({ packageManager: 'pnpm' });
+
+    expect(runCommand).toHaveBeenCalledWith(
+      'pnpm add @nestjs/throttler@^6.0.0',
+      expect.any(String),
+      expect.any(Object)
+    );
+
+    fsReadSpy.mockRestore();
+    fsWriteSpy.mockRestore();
+  });
+
+  it('should update app.module.ts with imports, module and guard provider', async () => {
+    const originalContent = `import { Module } from '@nestjs/common';
+import { AppController } from './app.controller';
+
+@Module({
+  imports: [],
+  controllers: [AppController],
+  providers: [],
+})
+export class AppModule {}`;
+
+    let writtenContent = '';
+    const fsReadSpy = jest.spyOn(fs, 'readFileSync').mockReturnValue(originalContent);
+    const fsWriteSpy = jest.spyOn(fs, 'writeFileSync').mockImplementation((path, content) => {
+      writtenContent = content;
+    });
+
+    await setupThrottler({ packageManager: 'npm' });
+
+    // Doit avoir écrit le fichier
+    expect(fsWriteSpy).toHaveBeenCalledWith(mockAppModulePath, expect.any(String), 'utf8');
+
+    // Doit contenir les nouveaux imports
+    expect(writtenContent).toContain("import { ThrottlerModule, ThrottlerGuard } from '@nestjs/throttler';");
+    expect(writtenContent).toContain("import { APP_GUARD } from '@nestjs/core';");
+
+    // Doit contenir ThrottlerModule.forRoot
+    expect(writtenContent).toContain('ThrottlerModule.forRoot');
+    expect(writtenContent).toContain('ttl: 60000');
+    expect(writtenContent).toContain('limit: 10');
+
+    // Doit contenir le provider APP_GUARD
+    expect(writtenContent).toContain('provide: APP_GUARD');
+    expect(writtenContent).toContain('useClass: ThrottlerGuard');
+
+    fsReadSpy.mockRestore();
+    fsWriteSpy.mockRestore();
+  });
+
+  it('should not modify app.module.ts if Throttler is already configured (idempotence)', async () => {
+    const alreadyConfiguredContent = `import { Module } from '@nestjs/common';
+import { ThrottlerModule } from '@nestjs/throttler';
+
+@Module({
+  imports: [ThrottlerModule.forRoot()],
+})
+export class AppModule {}`;
+
+    const fsReadSpy = jest.spyOn(fs, 'readFileSync').mockReturnValue(alreadyConfiguredContent);
+    const fsWriteSpy = jest.spyOn(fs, 'writeFileSync').mockImplementation(() => {});
+
+    await setupThrottler({ packageManager: 'npm' });
+
+    // writeFileSync ne doit pas être appelé car Throttler est déjà configuré
+    expect(fsWriteSpy).not.toHaveBeenCalled();
+
+    fsReadSpy.mockRestore();
+    fsWriteSpy.mockRestore();
+  });
+});

package/utils/app-module.updater.js

@@ -24,6 +24,12 @@ const { capitalize } = require("./helpers");
  * @param {string} entity - Le nom de l'entité en minuscule (ex: "user", "post")
  */
 async function safeUpdateAppModule(entity) {
+  const isDryRun = process.argv.includes("--dry-run");
+  if (isDryRun) {
+    console.log(`[DRY-RUN] Simulated: safe update app.module.ts with ${capitalize(entity)}Module`);
+    return;
+  }
+
   const filePath = "src/app.module.ts";
   const moduleName = `${capitalize(entity)}Module`;
   const importLine = `import { ${moduleName} } from 'src/${entity}/${entity}.module';`;

package/utils/configs/setupCleanArchitecture.js

@@ -124,7 +124,7 @@ async function setupCleanArchitecture(inputs) {
       });
 
       // 3. Repository Implémentation
-      await generateRepository(entity.name, dbConfig.orm);
+      await generateRepository(entity.name, dbConfig.orm, entity);
 
       // 4. Use Cases
       const useCases = ["Create", "GetById", "GetAll", "Update", "Delete"];