nestcraftx 0.2.6 → 0.3.0

package/utils/generators/infrastructure/mongooseSchemaGenerator.js

@@ -0,0 +1,196 @@
+/**
+ * utils/generators/infrastructure/mongooseSchemaGenerator.js
+ *
+ * Générateur du schéma Mongoose (Document Schema).
+ * Extrait de utils.js — Phase 1B.
+ *
+ * Supporte les modes "full" et "light" :
+ *   - full  : chemins d'import depuis infrastructure/persistence/mongoose/
+ *   - light : chemins d'import depuis entities/
+ *   - Role  : full → domain/enums/role.enum | light → common/enums/role.enum
+ */
+
+const { capitalize } = require("../../helpers");
+
+/**
+ * Vérifie si un champ est un objet relationnel (non scalaire).
+ * Utilisé pour filtrer les champs qui ne doivent pas être inclus dans le schéma.
+ *
+ * @param {object} field - Le champ { name, type }
+ * @param {object} entitiesData - Les données complètes { entities[], relations[] }
+ * @returns {boolean}
+ */
+function isRelationObjectField(field, entitiesData) {
+  const typeLower = field.type.toLowerCase();
+  return entitiesData.entities?.some((e) => e.name.toLowerCase() === typeLower);
+}
+
+/**
+ * Génère le contenu TypeScript du schéma Mongoose pour une entité.
+ *
+ * @param {object} entity - L'objet entité { name, fields[] }
+ * @param {object} entitiesData - { entities[], relations[] }
+ * @param {"full"|"light"} mode - Mode d'architecture
+ * @returns {Promise<string>} Le code TypeScript du schéma Mongoose
+ */
+async function generateMongooseSchemaFileContent(
+  entity,
+  entitiesData,
+  mode = "full",
+) {
+  const entityName = capitalize(entity.name);
+  const entityNameLower = entity.name.toLowerCase();
+  const isFull = mode === "full";
+
+  // --- 1. IMPORTS DYNAMIQUES ---
+  const relatedEntities = entitiesData.relations
+    .filter((rel) => rel.from === entityNameLower || rel.to === entityNameLower)
+    .map((rel) => (rel.from === entityNameLower ? rel.to : rel.from));
+
+  const uniqueRelated = [...new Set(relatedEntities)].filter(
+    (e) => e !== entityNameLower,
+  );
+
+  let extraImports = "";
+
+  uniqueRelated.forEach((target) => {
+    const targetCap = capitalize(target);
+    const moduleName = target === "session" ? "auth" : target;
+
+    let importPath = "";
+
+    if (isFull) {
+      // Mode Clean Architecture (Full)
+      importPath = `../../../../${moduleName}/infrastructure/persistence/mongoose/${target}.schema`;
+    } else {
+      // Mode Light
+      if (target === "session") {
+        importPath = `../../auth/persistence/${target}.schema`;
+      } else {
+        importPath = `../../${moduleName}/entities/${target}.schema`;
+      }
+    }
+
+    extraImports += `import { ${targetCap} } from '${importPath}';\n`;
+  });
+
+  if (entityNameLower === "user") {
+    const rolePath = isFull
+      ? "../../../domain/enums/role.enum"
+      : "../../common/enums/role.enum";
+    extraImports += `import { Role } from '${rolePath}';\n`;
+  }
+
+  // --- 2. LOGIQUE DES RELATIONS DYNAMIQUES (Prioritaire) ---
+  const dynamicRelations = entitiesData.relations
+    .map((rel) => {
+      const isFrom = rel.from === entityNameLower;
+      const isTo = rel.to === entityNameLower;
+      if (!isFrom && !isTo) return null;
+
+      const otherEntity = isFrom ? rel.to : rel.from;
+      const otherCap = capitalize(otherEntity);
+
+      switch (rel.type) {
+        case "1-n":
+          return isTo
+            ? `  @Prop({ type: mongoose.Schema.Types.ObjectId, ref: ${otherCap}.name, required: true })\n  ${otherEntity}Id: mongoose.Types.ObjectId;`
+            : null;
+        case "n-1":
+          return isFrom
+            ? `  @Prop({ type: mongoose.Schema.Types.ObjectId, ref: ${otherCap}.name, required: true })\n  ${otherEntity}Id: mongoose.Types.ObjectId;`
+            : null;
+        case "1-1":
+          return isFrom
+            ? `  @Prop({ type: mongoose.Schema.Types.ObjectId, ref: ${otherCap}.name, unique: true })\n  ${otherEntity}Id: mongoose.Types.ObjectId;`
+            : null;
+        case "n-n":
+          return `  @Prop({ type: [{ type: mongoose.Schema.Types.ObjectId, ref: ${otherCap}.name }] })\n  ${otherEntity}Ids: mongoose.Types.ObjectId[];`;
+        default:
+          return null;
+      }
+    })
+    .filter(Boolean);
+
+  // --- 3. FILTRAGE DES CHAMPS DIRECTS (Scalaires uniquement) ---
+  const scalarTypes = [
+    "string",
+    "text",
+    "number",
+    "int",
+    "float",
+    "boolean",
+    "date",
+    "uuid",
+    "json",
+  ];
+
+  const directFields = entity.fields
+    .filter((f) => {
+      const nameLow = f.name.toLowerCase();
+      const isRelId = uniqueRelated.some(
+        (rel) => nameLow === rel + "id" || nameLow === rel,
+      );
+      return scalarTypes.includes(f.type.toLowerCase()) && !isRelId;
+    })
+    .map((f) => {
+      const fieldName = f.name;
+      const rawType = f.type.toLowerCase();
+
+      // 1. Gestion spécifique du Role
+      if (entityNameLower === "user" && fieldName === "role") {
+        return `  @Prop({ type: String, enum: Role, default: Role.USER })\n  role: Role;`;
+      }
+
+      // 2. Mapping des types CLI -> TypeScript/Mongoose
+      let tsType = "string";
+      let propOptions = "required: true";
+
+      switch (rawType) {
+        case "text":
+        case "uuid":
+        case "string":
+          tsType = "string";
+          break;
+        case "int":
+        case "number":
+        case "float":
+        case "decimal":
+          tsType = "number";
+          break;
+        case "boolean":
+          tsType = "boolean";
+          break;
+        case "date":
+          tsType = "Date";
+          break;
+        case "json":
+          tsType = "Record<string, any>";
+          propOptions = "type: Object, required: true";
+          break;
+        default:
+          tsType = "any";
+      }
+
+      return `  @Prop({ ${propOptions} })\n  ${fieldName}: ${tsType};`;
+    });
+
+  const allFields = [...new Set([...directFields, ...dynamicRelations])].join(
+    "\n\n",
+  );
+
+  return `import { Prop, Schema, SchemaFactory } from '@nestjs/mongoose';
+import * as mongoose from 'mongoose';
+import { Document } from 'mongoose';
+${extraImports}
+export type ${entityName}Document = ${entityName} & Document;
+
+@Schema({ timestamps: true })
+export class ${entityName} {
+${allFields}
+}
+
+export const ${entityName}Schema = SchemaFactory.createForClass(${entityName});`.trim();
+}
+
+module.exports = { generateMongooseSchemaFileContent };

package/utils/generators/infrastructure/repositoryGenerator.js

@@ -0,0 +1,334 @@
+/**
+ * utils/generators/infrastructure/repositoryGenerator.js
+ *
+ * Générateur du Repository (Full/Clean Architecture uniquement).
+ * Extrait de utils.js — Phase 1B.
+ *
+ * ATTENTION : Ce générateur est UNIQUEMENT pour le mode Full (Clean Architecture).
+ * Il implémente l'interface I${Entity}Repository et utilise le Mapper.
+ *
+ * Le mode Light a son propre générateur `generateLightRepository` dans
+ * setupLightArchitecture.js avec une implémentation entièrement différente :
+ *   - Pas de Mapper, méthode toEntity() locale
+ *   - Imports depuis '../dtos/' et '../entities/' (chemins relatifs simples)
+ *   - Pas d'interface IEntityRepository
+ *
+ * Ne jamais fusionner les deux.
+ */
+
+const { capitalize } = require("../../helpers");
+const { createFile } = require("../../file-system");
+
+/**
+ * Génère et écrit le fichier repository pour une entité (Full Architecture).
+ *
+ * @param {string} entityName - Le nom de l'entité (ex: "post", "user")
+ * @param {"prisma"|"typeorm"|"mongoose"|"sequelize"} orm - L'ORM cible
+ * @returns {Promise<void>}
+ */
+async function generateRepository(entityName, orm) {
+  const entityNameCapitalized = capitalize(entityName);
+  const entityNameLower = entityName.toLowerCase();
+  const entityPath = `src/${entityNameLower}`;
+
+  // Méthode supplémentaire findByEmail pour l'entité User
+  const isUser = entityNameLower === "user";
+  const getExtraMethods = (ormType) => {
+    if (!isUser) return "";
+
+    switch (ormType) {
+      case "typeorm":
+        return `
+async findByEmail(email: string): Promise<${entityNameCapitalized}Entity | null> {
+  const record = await this.repository.findOne({ where: { email } as any });
+  return record ? this.mapper.toDomain(record) : null;
+}`;
+      case "prisma":
+        return `
+async findByEmail(email: string): Promise<${entityNameCapitalized}Entity | null> {
+  const record = await this.prisma.${entityNameLower}.findFirst({ where: { email } });
+  return record ? this.mapper.toDomain(record) : null;
+}`;
+      case "mongoose":
+        return `
+async findByEmail(email: string): Promise<${entityNameCapitalized}Entity | null> {
+  const record = await this.model.findOne({ email }).exec();
+  return record ? this.mapper.toDomain(record) : null;
+}`;
+      case "sequelize":
+        return `
+async findByEmail(email: string): Promise<${entityNameCapitalized}Entity | null> {
+  const record = await this.model.findOne({ where: { email } });
+  return record ? this.mapper.toDomain(record) : null;
+}`;
+      default:
+        return "";
+    }
+  };
+
+  const extraMethods = getExtraMethods(orm);
+
+  switch (orm) {
+    case "typeorm":
+      await createFile({
+        path: `${entityPath}/infrastructure/repositories/${entityNameLower}.repository.ts`,
+        contente: `/**
+ * PostRepository handles data persistence
+ * for the Post entity.
+ *
+ * This layer abstracts the database engine (Prisma/TypeORM)
+ * and provides a clean interface for data operations.
+ */
+
+import { Injectable, NotFoundException } from '@nestjs/common';
+import { Repository } from 'typeorm';
+import { InjectRepository } from '@nestjs/typeorm';
+import { ${entityNameCapitalized}Entity } from '${entityPath}/domain/entities/${entityNameLower}.entity';
+import { ${entityNameCapitalized} } from 'src/entities/${entityNameCapitalized}.entity';
+import type { I${entityNameCapitalized}Repository } from '${entityPath}/domain/interfaces/${entityNameLower}.repository.interface';
+import { Create${entityNameCapitalized}Dto, Update${entityNameCapitalized}Dto } from '${entityPath}/application/dtos/${entityNameLower}.dto';
+import { ${entityNameCapitalized}Mapper } from '${entityPath}/infrastructure/mappers/${entityNameLower}.mapper';
+
+@Injectable()
+export class ${entityNameCapitalized}Repository implements I${entityNameCapitalized}Repository {
+  constructor(
+    @InjectRepository(${entityNameCapitalized})
+    private readonly repository: Repository<${entityNameCapitalized}>,
+    private readonly mapper: ${entityNameCapitalized}Mapper,
+  ) {}
+
+  // create
+  async create(data: Create${entityNameCapitalized}Dto): Promise<${entityNameCapitalized}Entity> {
+    const toPersist = this.mapper.toPersistence(data);
+    const created = await this.repository.save(toPersist);
+    return this.mapper.toDomain(created);
+  }
+
+  // find by id
+  async findById(id: string): Promise<${entityNameCapitalized}Entity | null> {
+    const record = await this.repository.findOne({
+      where: { id },
+    });
+
+    if (!record) return null;
+
+    return this.mapper.toDomain(record);
+  }
+
+  ${extraMethods}
+
+  // update
+  async update(id: string, data: Update${entityNameCapitalized}Dto): Promise<${entityNameCapitalized}Entity> {
+    const toUpdate = this.mapper.toUpdatePersistence(data);
+    const updated = await this.repository.save({ ...toUpdate, id });
+    return this.mapper.toDomain(updated);
+  }
+
+  // find all
+  async findAll(): Promise<${entityNameCapitalized}Entity[]> {
+    const records = await this.repository.find();
+    return records.map(record => this.mapper.toDomain(record));
+  }
+
+  // delete
+  async delete(id: string): Promise<void> {
+    await this.repository.delete(id);
+  }
+}
+`,
+      });
+      break;
+
+    case "prisma":
+      await createFile({
+        path: `${entityPath}/infrastructure/repositories/${entityNameLower}.repository.ts`,
+        contente: `import { Injectable, NotFoundException } from '@nestjs/common';
+import { PrismaService } from 'src/prisma/prisma.service';
+import { Create${entityNameCapitalized}Dto, Update${entityNameCapitalized}Dto } from '${entityPath}/application/dtos/${entityNameLower}.dto';
+import { I${entityNameCapitalized}Repository } from '${entityPath}/domain/interfaces/${entityNameLower}.repository.interface';
+import { ${entityNameCapitalized}Entity } from '${entityPath}/domain/entities/${entityNameLower}.entity';
+import { ${entityNameCapitalized}Mapper } from '${entityPath}/infrastructure/mappers/${entityNameLower}.mapper';
+
+@Injectable()
+export class ${entityNameCapitalized}Repository implements I${entityNameCapitalized}Repository {
+  constructor(
+    private readonly prisma: PrismaService,
+    private readonly mapper: ${entityNameCapitalized}Mapper,
+  ) {}
+
+  // create
+  async create(data: Create${entityNameCapitalized}Dto): Promise<${entityNameCapitalized}Entity> {
+    const toPersist = this.mapper.toPersistence(data);
+    const created = await this.prisma.${entityNameLower}.create({ data: toPersist });
+    return this.mapper.toDomain(created);
+  }
+
+  // find by id
+  async findById(id: string): Promise<${entityNameCapitalized}Entity | null> {
+    const record = await this.prisma.${entityNameLower}.findUnique({
+      where: { id },
+    });
+
+    if (!record) return null;
+
+    return this.mapper.toDomain(record);
+  }
+
+  ${extraMethods}
+
+  // update
+  async update(id: string, data: Update${entityNameCapitalized}Dto): Promise<${entityNameCapitalized}Entity> {
+    const toUpdate = this.mapper.toUpdatePersistence(data);
+    const updated = await this.prisma.${entityNameLower}.update({
+      where: { id },
+      data: toUpdate,
+    });
+
+    return this.mapper.toDomain(updated);
+  }
+
+  // find all
+  async findAll(): Promise<${entityNameCapitalized}Entity[]> {
+    const records = await this.prisma.${entityNameLower}.findMany();
+    return records.map(record => this.mapper.toDomain(record));
+  }
+
+  // delete
+  async delete(id: string): Promise<void> {
+    await this.prisma.${entityNameLower}.delete({
+      where: { id },
+    });
+  }
+}
+`,
+      });
+      break;
+
+    case "mongoose":
+      await createFile({
+        path: `${entityPath}/infrastructure/repositories/${entityNameLower}.repository.ts`,
+        contente: `import { Injectable, NotFoundException } from '@nestjs/common';
+import { InjectModel } from '@nestjs/mongoose';
+import { Model } from 'mongoose';
+import { ${entityNameCapitalized}Entity } from '${entityPath}/domain/entities/${entityNameLower}.entity';
+import { Create${entityNameCapitalized}Dto, Update${entityNameCapitalized}Dto } from '${entityPath}/application/dtos/${entityNameLower}.dto';
+import { I${entityNameCapitalized}Repository } from '${entityPath}/domain/interfaces/${entityNameLower}.repository.interface';
+import { ${entityNameCapitalized} } from '${entityPath}/infrastructure/persistence/mongoose/${entityNameLower}.schema';
+import { ${entityNameCapitalized}Mapper } from '${entityPath}/infrastructure/mappers/${entityNameLower}.mapper';
+
+@Injectable()
+export class ${entityNameCapitalized}Repository implements I${entityNameCapitalized}Repository {
+  constructor(
+    @InjectModel(${entityNameCapitalized}.name)
+    private readonly model: Model<${entityNameCapitalized}>,
+    private readonly mapper: ${entityNameCapitalized}Mapper,
+  ) {}
+
+  // create
+  async create(data: Create${entityNameCapitalized}Dto): Promise<${entityNameCapitalized}Entity> {
+    const toPersist = this.mapper.toPersistence(data);
+    const created = await this.model.create(toPersist);
+    return this.mapper.toDomain(created);
+  }
+
+  // find by id
+  async findById(id: string): Promise<${entityNameCapitalized}Entity | null> {
+    const record = await this.model.findById(id).exec();
+
+    if (!record) return null;
+
+    return this.mapper.toDomain(record);
+  }
+
+  ${extraMethods}
+
+  // update
+  async update(id: string, data: Update${entityNameCapitalized}Dto): Promise<${entityNameCapitalized}Entity> {
+    const toUpdate = this.mapper.toUpdatePersistence(data);
+    const updated = await this.model.findByIdAndUpdate(id, toUpdate, { new: true }).exec();
+    return this.mapper.toDomain(updated);
+  }
+
+  // find all
+  async findAll(): Promise<${entityNameCapitalized}Entity[]> {
+    const records = await this.model.find().exec();
+    return records.map(record => this.mapper.toDomain(record));
+  }
+
+  // delete
+  async delete(id: string): Promise<void> {
+    await this.model.findByIdAndDelete(id).exec();
+  }
+}
+`,
+      });
+      break;
+
+    case "sequelize":
+      await createFile({
+        path: `${entityPath}/infrastructure/repositories/${entityNameLower}.repository.ts`,
+        contente: `import { Injectable, NotFoundException } from '@nestjs/common';
+import { InjectModel } from '@nestjs/sequelize';
+import { Model } from 'sequelize-typescript';
+import { Create${entityNameCapitalized}Dto, Update${entityNameCapitalized}Dto } from '${entityPath}/application/dtos/${entityNameLower}.dto';
+import { I${entityNameCapitalized}Repository } from '${entityPath}/domain/interfaces/${entityNameLower}.repository.interface';
+import { ${entityNameCapitalized}Entity } from '${entityPath}/domain/entities/${entityNameLower}.entity';
+import { ${entityNameCapitalized}Mapper } from '${entityPath}/infrastructure/mappers/${entityNameLower}.mapper';
+
+@Injectable()
+export class ${entityNameCapitalized}Repository implements I${entityNameCapitalized}Repository {
+  constructor(
+    @InjectModel(${entityNameCapitalized}Entity)
+    private readonly model: Model<${entityNameCapitalized}Entity>,
+    private readonly mapper: ${entityNameCapitalized}Mapper,
+  ) {}
+
+  // create
+  async create(data: Create${entityNameCapitalized}Dto): Promise<${entityNameCapitalized}Entity> {
+    const toPersist = this.mapper.toPersistence(data);
+    const created = await this.model.create(toPersist);
+    return this.mapper.toDomain(created);
+  }
+
+  // find by id
+  async findById(id: string): Promise<${entityNameCapitalized}Entity> {
+    const record = await this.model.findByPk(id);
+
+    if (!record) {
+      throw new NotFoundException(\`${entityNameCapitalized}Entity with id \${id} not found\`);
+    }
+
+    return this.mapper.toDomain(record);
+  }
+
+  ${extraMethods}
+
+  // update
+  async update(id: string, data: Update${entityNameCapitalized}Dto): Promise<${entityNameCapitalized}Entity> {
+    const toUpdate = this.mapper.toUpdatePersistence(data);
+    const updated = await this.model.update(toUpdate, { where: { id } });
+    return this.mapper.toDomain(updated);
+  }
+
+  // find all
+  async findAll(): Promise<${entityNameCapitalized}Entity[]> {
+    const records = await this.model.find();
+    return records.map(record => this.mapper.toDomain(record));
+  }
+
+  // delete
+  async delete(id: string): Promise<void> {
+    await this.model.destroy({ where: { id } });
+  }
+}
+`,
+      });
+      break;
+
+    default:
+      console.error("Unsupported ORM: " + orm);
+      break;
+  }
+}
+
+module.exports = { generateRepository };

package/utils/generators/presentation/controllerGenerator.js

@@ -0,0 +1,142 @@
+/**
+ * utils/generators/presentation/controllerGenerator.js
+ *
+ * Générateur du Controller (présentation) pour le mode Full/Clean Architecture.
+ * Extrait de utils.js — Phase 1B.
+ *
+ * ATTENTION : Ce générateur est UNIQUEMENT pour le mode Full.
+ * Le mode Light a son propre générateur dans setupLightArchitecture.js
+ * avec des différences comportementales :
+ *   - Full  : chemins "presentation/controllers/", méthodes getAll()/getById()
+ *   - Light : chemins "controllers/", méthodes findAll()/findById(), Logger intégré
+ *
+ * Ne jamais fusionner les deux.
+ */
+
+const { capitalize, decapitalize, pluralize } = require("../../helpers");
+
+/**
+ * Génère le contenu TypeScript du Controller NestJS (Full Architecture).
+ *
+ * @param {string} entityName - Le nom de l'entité (ex: "Post")
+ * @param {string} entityPath - Le chemin de base (ex: "src/post")
+ * @param {boolean} useSwagger - Inclure les décorateurs Swagger
+ * @returns {Promise<string>} Le code TypeScript du controller
+ */
+async function generateController(entityName, entityPath, useSwagger) {
+  const entityNameLower = decapitalize(entityName);
+  const entityNameCapitalized = capitalize(entityName);
+  const pluralName = pluralize(entityNameLower);
+
+  const swaggerImports = useSwagger
+    ? `import { ApiTags, ApiOperation, ApiResponse, ApiParam } from '@nestjs/swagger';`
+    : "";
+
+  const swaggerClassDecorator = useSwagger
+    ? `@ApiTags('${capitalize(pluralName)}')`
+    : "";
+
+  return `
+import { Controller, Get, Post, Body, Param, Patch, Delete, HttpCode, HttpStatus, Query } from '@nestjs/common';
+${swaggerImports}
+import { ${entityNameCapitalized}Service } from '${entityPath}/application/services/${entityNameLower}.service';
+import { Create${entityNameCapitalized}Dto, Update${entityNameCapitalized}Dto } from 'src/${entityNameLower}/application/dtos/${entityNameLower}.dto';
+
+
+/**
+ * Controller for ${entityNameCapitalized} management.
+ * Handles incoming HTTP requests and delegates logic to the service layer.
+ */
+${swaggerClassDecorator}
+@Controller('${pluralName}')
+export class ${entityNameCapitalized}Controller {
+  constructor(private readonly service: ${entityNameCapitalized}Service) {}
+
+  ${
+    entityNameLower !== "user"
+      ? `
+  @Post()
+  @HttpCode(HttpStatus.CREATED)
+  ${
+    useSwagger
+      ? `
+  @ApiOperation({ summary: 'Create a new ${entityNameLower}', description: 'Creates a new record for ${entityNameLower} in the database.' })
+  @ApiResponse({ status: 201, description: 'The ${entityNameLower} has been successfully created.' })
+  @ApiResponse({ status: 400, description: 'Invalid input data.' })`
+      : ""
+  }
+  async create(@Body() dto: Create${entityNameCapitalized}Dto) {
+    const result = await this.service.create(dto);
+    return {
+      message: '${entityNameCapitalized} created successfully',
+      data: result
+    };
+  }
+  `
+      : ""
+  }
+
+  @Get()
+  ${
+    useSwagger
+      ? `
+  @ApiOperation({ summary: 'Get all ${pluralName}', description: 'Retrieves a list of all ${pluralName} available.' })
+  @ApiResponse({ status: 200, description: 'Return all ${pluralName}.' })`
+      : ""
+  }
+  async getAll() {
+    return await this.service.getAll();
+  }
+
+  @Get(':id')
+  ${
+    useSwagger
+      ? `
+  @ApiOperation({ summary: 'Get ${entityNameLower} by ID' })
+  @ApiParam({ name: 'id', description: 'The unique identifier of the ${entityNameLower}' })
+  @ApiResponse({ status: 200, description: 'The ${entityNameLower} has been found.' })
+  @ApiResponse({ status: 404, description: '${entityNameCapitalized} not found.' })`
+      : ""
+  }
+  async getById(@Param('id') id: string) {
+    return await this.service.getById(id);
+  }
+
+  @Patch(':id')
+  ${
+    useSwagger
+      ? `
+  @ApiOperation({ summary: 'Update an existing ${entityNameLower}' })
+  @ApiParam({ name: 'id', description: 'The unique identifier of the ${entityNameLower} to update' })
+  @ApiResponse({ status: 200, description: 'The ${entityNameLower} has been successfully updated.' })
+  @ApiResponse({ status: 404, description: '${entityNameCapitalized} not found.' })`
+      : ""
+  }
+  async update(
+    @Param('id') id: string,
+    @Body() dto: Update${entityNameCapitalized}Dto,
+  ) {
+    await this.service.update(id, dto);
+    return { message: '${entityNameCapitalized} updated successfully' };
+  }
+
+  @Delete(':id')
+  @HttpCode(HttpStatus.NO_CONTENT)
+  ${
+    useSwagger
+      ? `
+  @ApiOperation({ summary: 'Delete a ${entityNameLower}' })
+  @ApiParam({ name: 'id', description: 'The unique identifier of the ${entityNameLower} to delete' })
+  @ApiResponse({ status: 204, description: 'The ${entityNameLower} has been successfully deleted.' })
+  @ApiResponse({ status: 404, description: '${entityNameCapitalized} not found.' })`
+      : ""
+  }
+  async delete(@Param('id') id: string) {
+    await this.service.delete(id);
+    return { message: '${entityNameCapitalized} deleted successfully' };
+  }
+}
+`;
+}
+
+module.exports = { generateController };