nestcraftx 0.2.5 → 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/lightModuleGenerator.js

@@ -0,0 +1,131 @@
+const {
+  createDirectory,
+  createFile,
+  safeUpdateAppModule,
+  capitalize,
+  decapitalize,
+} = require("../userInput");
+const { generateEntityFileContent, generateDto } = require("../utils");
+const {
+  generateLightRepository,
+  generateLightService,
+  generateLightController,
+  generateLightModule,
+} = require("../configs/setupLightArchitecture");
+const { logSuccess } = require("../loggers/logSuccess");
+const { logError } = require("../loggers/logError");
+const setupDatabase = require("./database/setupDatabase");
+const { logInfo } = require("../loggers/logInfo");
+const { updateExistingEntityRelation } = require("./domain/entityUpdater");
+const { applyRelationPatches } = require("./relation/relation.engine");
+
+async function lightModuleGenerator(entity, config) {
+  try {
+    const entityNameCap = capitalize(entity.name);
+    const entityNameLow = decapitalize(entity.name);
+    const entityPath = `src/${entityNameLow}`;
+    const mode = "light";
+
+    logInfo(`🚀 Generating light module for ${entityNameCap}`);
+
+    // 1️⃣ Créer les dossiers
+    await createDirectory(`${entityPath}/entities`);
+    await createDirectory(`${entityPath}/dtos`);
+    await createDirectory(`${entityPath}/services`);
+    await createDirectory(`${entityPath}/repositories`);
+    await createDirectory(`${entityPath}/controllers`);
+
+    // 2️⃣ Générer l'entité
+    const entityContent = await generateEntityFileContent(entity, "light");
+    await createFile({
+      path: `${entityPath}/entities/${entityNameLow}.entity.ts`,
+      contente: entityContent,
+    });
+
+    // 3️⃣ Générer les DTOs
+    const dtoContent = await generateDto(
+      entity,
+      config.swagger,
+      false,
+      "light",
+    );
+    await createFile({
+      path: `${entityPath}/dtos/${entityNameLow}.dto.ts`,
+      contente: dtoContent,
+    });
+
+    // 4️⃣ Générer le repository
+    const repositoryContent = generateLightRepository(
+      entityNameCap,
+      entityNameLow,
+      config.orm,
+      entity,
+    );
+    await createFile({
+      path: `${entityPath}/repositories/${entityNameLow}.repository.ts`,
+      contente: repositoryContent,
+    });
+
+    // 5️⃣ Générer le service
+    const serviceContent = generateLightService(entityNameCap, entityNameLow);
+    await createFile({
+      path: `${entityPath}/services/${entityNameLow}.service.ts`,
+      contente: serviceContent,
+    });
+
+    // 6️⃣ Générer le controller
+    const controllerContent = generateLightController(
+      entityNameCap,
+      entityNameLow,
+      config.swagger,
+    );
+    await createFile({
+      path: `${entityPath}/controllers/${entityNameLow}.controller.ts`,
+      contente: controllerContent,
+    });
+
+    // 7️⃣ Générer le module
+    const moduleContent = generateLightModule(
+      entityNameCap,
+      entityNameLow,
+      entityPath,
+      config.orm,
+      config.auth,
+    );
+    await createFile({
+      path: `${entityPath}/${entityNameLow}.module.ts`,
+      contente: moduleContent,
+    });
+
+    // ÉTAPE RELATIONS : Patching des fichiers si une relation existe
+    if (entity.relation) {
+      const { target, type } = entity.relation;
+      logInfo(
+        `🔗 Linking ${entityNameCap} with ${capitalize(target)} (${type})...`,
+      );
+
+      await updateExistingEntityRelation(target, entity.name, type);
+
+      await applyRelationPatches(
+        entity.name,
+        target,
+        type,
+        config.swagger,
+        mode,
+      );
+    }
+
+    // 8️  Auto-enregistrement dans AppModule
+    await safeUpdateAppModule(entityNameLow);
+
+    // 9
+    await setupDatabase(config, entity);
+
+    logSuccess(`✨ Light module ${entityNameCap} generated successfully!`);
+  } catch (error) {
+    logError(`Error generating light module: ${error}`);
+    throw error;
+  }
+}
+
+module.exports = lightModuleGenerator;