nestcraftx 0.4.0 → 1.0.0

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/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"];

package/utils/configs/setupLightArchitecture.js

@@ -124,6 +124,7 @@ async function setupLightArchitecture(inputs) {
         entityNameCapitalized,
         entityNameLower,
         useSwagger,
+        useAuth || false,
       );
       await createFile({
         path: `${entityPath}/controllers/${entityNameLower}.controller.ts`,
@@ -282,9 +283,19 @@ export class ${entityName}Repository {
 
   ${extraMethods}
 
-  async findAll(): Promise<${entityName}Entity[]> {
-    const results = await this.prisma.${entityLower}.findMany();
-    return results.map(r => this.toEntity(r));
+  async findAll(page: number = 1, limit: number = 10): Promise<{ data: ${entityName}Entity[], total: number }> {
+    const skip = (page - 1) * limit;
+    const [results, total] = await this.prisma.$transaction([
+      this.prisma.${entityLower}.findMany({
+        skip,
+        take: limit,
+      }),
+      this.prisma.${entityLower}.count(),
+    ]);
+    return {
+      data: results.map(r => this.toEntity(r)),
+      total,
+    };
   }
 
   async update(id: string, data: Update${entityName}Dto): Promise<${entityName}Entity | null> {
@@ -346,9 +357,16 @@ export class ${entityName}Repository {
 
   ${extraMethods}
 
-  async findAll(): Promise<${entityName}Entity[]> {
-    const results = await this.repository.find();
-    return results.map(r => this.toEntity(r));
+  async findAll(page: number = 1, limit: number = 10): Promise<{ data: ${entityName}Entity[], total: number }> {
+    const skip = (page - 1) * limit;
+    const [results, total] = await this.repository.findAndCount({
+      skip,
+      take: limit,
+    });
+    return {
+      data: results.map(r => this.toEntity(r)),
+      total,
+    };
   }
 
   async update(id: string, data: Update${entityName}Dto): Promise<${entityName}Entity | null> {
@@ -415,9 +433,16 @@ export class ${entityName}Repository {
 
   ${extraMethods}
 
-  async findAll(): Promise<${entityName}Entity[]> {
-    const results = await this.model.find().exec();
-    return results.map(r => this.toEntity(r));
+  async findAll(page: number = 1, limit: number = 10): Promise<{ data: ${entityName}Entity[], total: number }> {
+    const skip = (page - 1) * limit;
+    const [results, total] = await Promise.all([
+      this.model.find().skip(skip).limit(limit).exec(),
+      this.model.countDocuments().exec(),
+    ]);
+    return {
+      data: results.map(r => this.toEntity(r)),
+      total,
+    };
   }
 
   async update(id: string, data: Update${entityName}Dto): Promise<${entityName}Entity | null> {
@@ -457,7 +482,7 @@ export class ${entityName}Repository {
 
   ${extraMethods}
 
-  async findAll(): Promise<${entityName}Entity[]> {
+  async findAll(page: number = 1, limit: number = 10): Promise<{ data: ${entityName}Entity[], total: number }> {
     throw new Error('Repository not implemented');
   }
 
@@ -513,11 +538,20 @@ export class ${entityName}Service {
     return entity;
   }
 
-  async findAll(): Promise<${entityName}Entity[]> {
-    this.logger.log('Fetching all ${entityName} records');
-    const results = await this.repository.findAll();
-    this.logger.log(\`Successfully retrieved \${results.length} ${entityName}(s)\`);
-    return results;
+  async findAll(page: number = 1, limit: number = 10): Promise<{ data: ${entityName}Entity[], meta: { total: number, page: number, limit: number, totalPages: number } }> {
+    this.logger.log(\`Fetching page \${page} of ${entityName} records (limit: \${limit})\`);
+    const { data, total } = await this.repository.findAll(page, limit);
+    const totalPages = Math.ceil(total / limit);
+    this.logger.log(\`Successfully retrieved \${data.length} of \${total} ${entityName}(s)\`);
+    return {
+      data,
+      meta: {
+        total,
+        page,
+        limit,
+        totalPages,
+      },
+    };
   }
 
   async update(id: string, dto: Update${entityName}Dto): Promise<${entityName}Entity> {
@@ -549,21 +583,46 @@ export class ${entityName}Service {
 }`;
 }
 
-function generateLightController(entityName, entityLower, useSwagger) {
+function generateLightController(entityName, entityLower, useSwagger, useAuth = false) {
   const entityCap = capitalize(entityName);
   const pluralName = pluralize(entityLower);
 
+  // --- Imports NestJS de base ---
+  const nestCoreImports = useAuth
+    ? `import { Controller, Get, Post, Patch, Delete, Body, Param, Query, Logger, HttpCode, HttpStatus, UseGuards } from '@nestjs/common';`
+    : `import { Controller, Get, Post, Patch, Delete, Body, Param, Query, Logger, HttpCode, HttpStatus } from '@nestjs/common';`;
+
+  // --- Imports Swagger ---
   const swaggerImports = useSwagger
-    ? `import { ApiTags, ApiOperation, ApiResponse, ApiParam } from '@nestjs/swagger';\n`
+    ? `import { ApiTags, ApiOperation, ApiResponse, ApiParam, ApiQuery${useAuth ? ', ApiBearerAuth, ApiUnauthorizedResponse, ApiForbiddenResponse' : ''} } from '@nestjs/swagger';\n`
+    : "";
+
+  // --- Imports Guards & Décorateurs (uniquement si auth activé) ---
+  const guardImports = useAuth
+    ? `import { JwtAuthGuard } from 'src/auth/guards/jwt-auth.guard';
+import { RolesGuard } from 'src/auth/guards/role.guard';
+import { Roles } from 'src/common/decorators/role.decorator';
+import { Public } from 'src/common/decorators/public.decorator';`
     : "";
 
   const swaggerDecorators = useSwagger
     ? `@ApiTags('${capitalize(pluralName)}')\n`
     : "";
 
-  return `import { Controller, Get, Post, Patch, Delete, Body, Param, Logger, HttpCode, HttpStatus } from '@nestjs/common';
+  // --- Snippets décorateurs ---
+  const adminGuards = useAuth
+    ? `  @UseGuards(JwtAuthGuard, RolesGuard)\n  @Roles('ADMIN')`
+    : "";
+  const apiBearerAuth = useAuth && useSwagger ? `  @ApiBearerAuth()` : "";
+  const apiUnauthorized = useAuth && useSwagger
+    ? `  @ApiUnauthorizedResponse({ description: 'Missing or invalid JWT token.' })\n  @ApiForbiddenResponse({ description: 'Insufficient permissions (ADMIN required).' })`
+    : "";
+  const publicDecorator = useAuth ? `  @Public()` : "";
+
+  return `${nestCoreImports}
 ${swaggerImports}import { ${entityCap}Service } from '../services/${entityLower}.service';
 import { Create${entityCap}Dto, Update${entityCap}Dto } from '../dtos/${entityLower}.dto';
+${guardImports}
 
 ${swaggerDecorators}@Controller('${pluralName}')
 export class ${entityCap}Controller {
@@ -571,10 +630,12 @@ export class ${entityCap}Controller {
 
   constructor(private readonly service: ${entityCap}Service) {}
 
+${apiBearerAuth}
+${adminGuards}
   @Post()
   ${
     useSwagger
-      ? `@ApiOperation({ summary: 'Create a new ${entityLower}' })\n  @ApiResponse({ status: 201, description: 'The record has been successfully created.' })`
+      ? `@ApiOperation({ summary: 'Create a new ${entityLower}' })\n  @ApiResponse({ status: 201, description: 'The record has been successfully created.' })\n  ${apiUnauthorized}`
       : ""
   }
   async create(@Body() dto: Create${entityCap}Dto) {
@@ -585,17 +646,24 @@ export class ${entityCap}Controller {
     };
   }
 
+${publicDecorator}
   @Get()
   ${
     useSwagger
-      ? `@ApiOperation({ summary: 'Get all ${pluralName}' })\n  @ApiResponse({ status: 200, description: 'List of records retrieved.' })`
+      ? `@ApiOperation({ summary: 'Get all ${pluralName}' })\n  @ApiQuery({ name: 'page', required: false, type: Number, schema: { default: 1 } })\n  @ApiQuery({ name: 'limit', required: false, type: Number, schema: { default: 10 } })\n  @ApiResponse({ status: 200, description: 'List of records retrieved.' })`
       : ""
   }
-  async findAll() {
-    this.logger.log(\`Fetching all ${pluralName}\`);
-    return await this.service.findAll();
+  async findAll(
+    @Query('page') page?: number,
+    @Query('limit') limit?: number,
+  ) {
+    this.logger.log(\`Fetching all ${pluralName} (page: \${page}, limit: \${limit})\`);
+    const pageNum = page ? Number(page) : 1;
+    const limitNum = limit ? Number(limit) : 10;
+    return await this.service.findAll(pageNum, limitNum);
   }
 
+${publicDecorator}
   @Get(':id')
   ${
     useSwagger
@@ -607,10 +675,12 @@ export class ${entityCap}Controller {
     return await this.service.findById(id);
   }
 
+${apiBearerAuth}
+${adminGuards}
   @Patch(':id')
   ${
     useSwagger
-      ? `@ApiOperation({ summary: 'Update ${entityLower}' })\n  @ApiParam({ name: 'id', type: String })\n  @ApiResponse({ status: 200, description: 'Record updated.' })`
+      ? `@ApiOperation({ summary: 'Update ${entityLower}' })\n  @ApiParam({ name: 'id', type: String })\n  @ApiResponse({ status: 200, description: 'Record updated.' })\n  ${apiUnauthorized}`
       : ""
   }
   async update(@Param('id') id: string, @Body() dto: Update${entityCap}Dto) {
@@ -619,11 +689,13 @@ export class ${entityCap}Controller {
     return { message: '${entityCap} updated successfully' };
   }
 
+${apiBearerAuth}
+${adminGuards}
   @Delete(':id')
   @HttpCode(HttpStatus.NO_CONTENT)
   ${
     useSwagger
-      ? `@ApiOperation({ summary: 'Delete ${entityLower}' })\n  @ApiParam({ name: 'id', type: String })\n  @ApiResponse({ status: 204, description: 'Record deleted.' })`
+      ? `@ApiOperation({ summary: 'Delete ${entityLower}' })\n  @ApiParam({ name: 'id', type: String })\n  @ApiResponse({ status: 204, description: 'Record deleted.' })\n  ${apiUnauthorized}`
       : ""
   }
   async delete(@Param('id') id: string) {
@@ -631,7 +703,7 @@ export class ${entityCap}Controller {
     await this.service.delete(id);
     return {
       message: '${entityCap} deleted successfully',
-    };;
+    };
   }
 }`;
 }

package/utils/envGenerator.js

@@ -21,7 +21,8 @@ PORT=3000
 `;
 
   // --- AUTHENTICATION SECTION ---
-  content += `# ------------------------------------------------------------------------------
+  if (inputs.useAuth) {
+    content += `# ------------------------------------------------------------------------------
 # AUTHENTICATION (JWT)
 # ------------------------------------------------------------------------------
 # Auto-generated secrets to secure tokens.
@@ -34,6 +35,7 @@ JWT_EXPIRES_IN=15m
 JWT_REFRESH_EXPIRES_IN=7d
 
 `;
+  }
 
   // --- DATABASE SECTION ---
   content += `# ------------------------------------------------------------------------------

package/utils/file-utils/saveProjectConfig.js

@@ -18,8 +18,11 @@ async function saveProjectConfig(inputs) {
     database: inputs.selectedDB,
     auth: inputs.useAuth,
     swagger: inputs.useSwagger,
+    throttler: inputs.useThrottler,
     packageManager: inputs.packageManager,
     docker: inputs.useDocker,
+    entities: inputs.entitiesData ? inputs.entitiesData.entities : [],
+    relations: inputs.entitiesData ? inputs.entitiesData.relations : [],
     generatedAt: new Date().toISOString(),
   };