nestcraftx 0.2.6 → 0.3.0

package/utils/file-system.js

@@ -0,0 +1,75 @@
+/**
+ * utils/file-system.js
+ *
+ * Fonctions d'accès au système de fichiers utilisées par tous les générateurs.
+ * Extraites de userInput.js pour centraliser les opérations I/O.
+ *
+ * Les fichiers qui importent depuis userInput.js continuent de fonctionner
+ * sans modification grâce aux ré-exports dans userInput.js.
+ */
+
+const fs = require("fs");
+
+/**
+ * Crée un répertoire de manière récursive s'il n'existe pas déjà.
+ * @param {string} directoryPath - Le chemin du répertoire à créer.
+ */
+async function createDirectory(directoryPath) {
+  try {
+    if (!fs.existsSync(directoryPath)) {
+      fs.mkdirSync(directoryPath, { recursive: true });
+    }
+  } catch (error) {
+    console.error(
+      `Erreur lors de la création du dossier ${directoryPath}:`,
+      error,
+    );
+  }
+}
+
+/**
+ * Crée un fichier avec le contenu fourni.
+ * Si le fichier existe déjà :
+ *   - Si `fileData.overwrite === false` : skip silencieusement
+ *   - Sinon : écrase le fichier existant
+ *
+ * @param {{ path: string, contente: string, overwrite?: boolean }} fileData
+ */
+async function createFile(fileData) {
+  try {
+    if (!fs.existsSync(fileData.path)) {
+      fs.writeFileSync(`${fileData.path}`, `${fileData.contente}`);
+    } else {
+      if (fileData.overwrite === false) {
+        console.log(`File already exists, skipping: ${fileData.path}`);
+        return;
+      }
+      console.log(`Existing file : ${fileData.path}`);
+      fs.writeFileSync(`${fileData.path}`, `${fileData.contente}`);
+    }
+  } catch (error) {
+    console.error(`Erreur creating file ${fileData.path}:`, error);
+  }
+}
+
+/**
+ * Met à jour un fichier existant en remplaçant un pattern par un remplacement.
+ * Utilise `String.prototype.replace` : supporte les chaînes et les RegExp.
+ *
+ * @param {{ path: string, pattern: string|RegExp, replacement: string }} options
+ */
+async function updateFile({ path, pattern, replacement }) {
+  try {
+    let mainTs = fs.readFileSync(path, "utf8");
+    const updatedContent = mainTs.replace(pattern, replacement);
+    fs.writeFileSync(path, updatedContent, "utf-8");
+  } catch (error) {
+    console.error(` Error updating file ${path}:`, error);
+  }
+}
+
+module.exports = {
+  createDirectory,
+  createFile,
+  updateFile,
+};

package/utils/generators/application/dtoGenerator.js

@@ -0,0 +1,251 @@
+/**
+ * utils/generators/application/dtoGenerator.js
+ *
+ * Générateur des DTOs (Data Transfer Objects) Create/Update.
+ * Extrait de utils.js — Phase 1B.
+ *
+ * Supporte les modes "full" et "light" via le paramètre `mode` :
+ *   - full  : import Role depuis src/user/domain/enums/role.enum
+ *   - light : import Role depuis src/common/enums/role.enum
+ *
+ * Génère deux classes : Create{Entity}Dto et Update{Entity}Dto
+ * Gère optionnellement les décorateurs Swagger (@ApiProperty etc.)
+ */
+
+const { capitalize, formatType } = require("../../helpers");
+
+/**
+ * Génère le contenu TypeScript des DTOs pour une entité.
+ *
+ * @param {object} entity - L'objet entité { name, fields[] }
+ * @param {boolean} useSwagger - Inclure les décorateurs Swagger
+ * @param {boolean} isAuthDto - Mode Auth DTO (classe unique sans CRUD)
+ * @param {"full"|"light"} mode - Mode d'architecture (impacte l'import de Role)
+ * @returns {Promise<string>} Le code TypeScript des DTOs
+ */
+async function generateDto(
+  entity,
+  useSwagger,
+  isAuthDto = false,
+  mode = "full",
+) {
+  const entityName = capitalize(entity.name);
+  const entityNameLower = entity.name.toLowerCase();
+
+  /* ===============================
+     ENUM IMPORT
+  =============================== */
+  let enumImport = "";
+  if (entityName === "User") {
+    enumImport =
+      mode === "light"
+        ? "\nimport { Role } from 'src/common/enums/role.enum';"
+        : "\nimport { Role } from 'src/user/domain/enums/role.enum';";
+  }
+
+  /* ===============================
+     SWAGGER HELPERS
+  =============================== */
+  const getFieldDescription = (f) => {
+    const name = f.name.toLowerCase();
+    if (name.includes("email")) return "The official email address of the user";
+    if (name.includes("password"))
+      return "Must contain at least 8 characters, one letter and one number";
+    if (name.includes("token")) return "Authentication token";
+    if (name.includes("id") && name !== "id")
+      return `Unique identifier of the related ${name.replace("id", "")}`;
+    return `The ${f.name} of the ${entityNameLower}`;
+  };
+
+  const getExampleForField = (f) => {
+    const fieldName = f.name.toLowerCase();
+    const isArray = f.type.endsWith("[]");
+    const cleanType = f.type.toLowerCase().replace("[]", "");
+
+    const getBaseExample = () => {
+      if (fieldName.includes("email")) return "user@example.com";
+      if (fieldName.includes("password")) return "SecurePass@2024";
+      if (fieldName.includes("token")) return "eyJhbGciOi...";
+      if (fieldName.includes("id") && fieldName !== "id")
+        return "550e8400-e29b-41d4-a716-446655440000";
+      if (fieldName.includes("title") || fieldName.includes("name"))
+        return `${capitalize(entityName)} Example`;
+      if (cleanType === "boolean") return true;
+      if (cleanType === "number" || cleanType === "int") return 42;
+      return `${f.name.toLowerCase()}_val`;
+    };
+
+    const base = getBaseExample();
+    return isArray ? [base, base] : base;
+  };
+
+  /* ===============================
+     FIELD GENERATOR
+  =============================== */
+  const generateFieldLine = (f, optional = false, forceNoSwagger = false) => {
+    if (entityName === "User" && f.name.toLowerCase() === "role") return null;
+
+    const name = f.name;
+    const cleanType = f.type.toLowerCase().replace("[]", "");
+    const isArray = f.type.endsWith("[]");
+
+    const SCALAR_TYPES = [
+      "string",
+      "text",
+      "uuid",
+      "json",
+      "number",
+      "decimal",
+      "int",
+      "float",
+      "boolean",
+      "date",
+    ];
+    if (!SCALAR_TYPES.includes(cleanType)) return null;
+
+    let validators = [];
+    if (optional) validators.push("@IsOptional()");
+    if (name.toLowerCase().includes("email")) validators.push("@IsEmail()");
+    else if (name.toLowerCase().includes("password"))
+      validators.push(
+        "@MinLength(8, { message: 'Password is too short (min 8 characters)' })",
+      );
+
+    switch (cleanType) {
+      case "string":
+      case "text":
+        validators.push(isArray ? "@IsString({ each: true })" : "@IsString()");
+        if (!isArray && !name.toLowerCase().includes("password"))
+          validators.push("@MinLength(2)");
+        break;
+      case "number":
+      case "int":
+      case "float":
+        validators.push(
+          isArray ? "@IsNumber({}, { each: true })" : "@IsNumber()",
+        );
+        break;
+      case "boolean":
+        validators.push(
+          isArray ? "@IsBoolean({ each: true })" : "@IsBoolean()",
+        );
+        break;
+      case "uuid":
+        validators.push("@IsUUID()");
+        break;
+      case "date":
+        validators.push("@IsDateString()");
+        break;
+    }
+    if (isArray) validators.push("@IsArray()");
+
+    let swaggerDecorator = "";
+    if (useSwagger && !forceNoSwagger) {
+      const decorator = optional ? "@ApiPropertyOptional" : "@ApiProperty";
+      const options = JSON.stringify(
+        {
+          example: getExampleForField(f),
+          description: getFieldDescription(f),
+        },
+        null,
+        2,
+      ).replace(/"([^"]+)":/g, "$1:");
+      swaggerDecorator = `${decorator}(${options})\n  `;
+    }
+
+    return `${swaggerDecorator}${validators.join("\n  ")}\n  ${name}${
+      optional ? "?" : "!"
+    }: ${formatType(f.type)};`;
+  };
+
+  /* ======================================================
+      AUTH DTO (Strict & Clean)
+  ====================================================== */
+  if (isAuthDto) {
+    const authFields = entity.fields
+      .map((f) => generateFieldLine(f, false))
+      .filter(Boolean)
+      .join("\n\n  ");
+
+    return `import {
+  IsString, IsInt, IsBoolean, IsEmail, IsArray,
+  IsUUID, IsDateString, MinLength, IsOptional
+} from 'class-validator';
+${useSwagger ? "import { ApiProperty } from '@nestjs/swagger';" : ""}
+
+/**
+ * Auth DTO - Strict contract for authentication
+ */
+export class ${entityName}Dto {
+  ${authFields}
+}
+`;
+  }
+
+  /* ======================================================
+      CRUD DTOs (Create / Update)
+  ====================================================== */
+  const createFields = entity.fields
+    .map((f) => generateFieldLine(f, false))
+    .filter(Boolean)
+    .join("\n\n  ");
+
+  const updateFields = entity.fields
+    .map((f) => generateFieldLine(f, true))
+    .filter(Boolean)
+    .join("\n\n  ");
+
+  // Imports Swagger dynamiques
+  let swaggerImports = ["ApiProperty", "ApiPropertyOptional", "PartialType"];
+  if (entityName === "User") swaggerImports.push("ApiHideProperty");
+
+  return `import {
+  IsOptional, IsString, IsInt, IsBoolean, IsEmail,
+  IsArray, IsUUID, IsDateString, MinLength, IsEnum
+} from 'class-validator';
+${
+  useSwagger
+    ? `import { ${swaggerImports.join(", ")} } from '@nestjs/swagger';`
+    : ""
+}
+${enumImport}
+
+/**
+ * DTO for creating a ${entityName}
+ */
+export class Create${entityName}Dto {
+  ${createFields}
+
+  ${
+    entityName === "User"
+      ? `
+  ${useSwagger ? "@ApiHideProperty()" : ""}
+  @IsOptional()
+  @IsEnum(Role)
+  role: Role = Role.USER;`
+      : ""
+  }
+}
+
+/**
+ * DTO for updating a ${entityName}
+ */
+${
+  useSwagger
+    ? `export class Update${entityName}Dto extends PartialType(Create${entityName}Dto) {}`
+    : `export class Update${entityName}Dto {
+  ${updateFields}
+
+  ${
+    entityName === "User"
+      ? `@IsEnum(Role)
+  @IsOptional()
+  role?: Role;`
+      : ""
+  }
+}`
+}
+`;
+}
+
+module.exports = { generateDto };

package/utils/generators/database/setupDatabase.js

@@ -1,5 +1,7 @@
 const { logInfo } = require("../../loggers/logInfo");
 const { updatePrismaSchema } = require("../../setups/setupPrisma");
+const { createDirectory, createFile } = require("../../userInput");
+const { generateMongooseSchemaFileContent } = require("../../utils");
 
 async function setupDatabase(config, entityData) {
   logInfo("Configuring the database...");
@@ -8,23 +10,39 @@ async function setupDatabase(config, entityData) {
     case "prisma":
       await updatePrismaSchema(entityData);
       break;
-    case "typeorm":
-      await setupMySQL(inputs);
-      break;
     case "mongoose":
-      await setupMongoDB(inputs); // MongoDB Configuration
-      break;
-    case "sqlite":
-      await setupSQLite(inputs); // SQLite Configuration
-      break;
-    case "firebase":
-      await setupFirebase(inputs); // Firebase Configuration
-      break;
-    case "redis":
-      await setupRedis(inputs); // Redis Configuration
+      const entityNameLower = entityData.name.toLowerCase();
+      const isFull = config.mode === "full";
+      const schemaPath = isFull
+        ? `src/${entityNameLower}/infrastructure/persistence/mongoose`
+        : `src/${entityNameLower}/entities`;
+      await createDirectory(schemaPath);
+
+      // Reconstruct entitiesData with the single entity and relations for generateMongooseSchemaFileContent
+      const entitiesData = {
+        relations: entityData.relation ? [
+          {
+            from: entityData.name.toLowerCase(),
+            to: entityData.relation.target.toLowerCase(),
+            type: entityData.relation.type
+          }
+        ] : []
+      };
+
+      const mongooseSchemaContent = await generateMongooseSchemaFileContent(
+        entityData,
+        entitiesData,
+        config.mode
+      );
+
+      await createFile({
+        path: `${schemaPath}/${entityNameLower}.schema.ts`,
+        contente: mongooseSchemaContent,
+      });
       break;
     default:
-      throw new Error("Unsupported database.");
+      // Other database types don't require database-level updates on module generation
+      break;
   }
 }
 

package/utils/generators/domain/entityGenerator.js

@@ -0,0 +1,126 @@
+/**
+ * utils/generators/domain/entityGenerator.js
+ *
+ * Générateur de l'Entité de Domaine (Domain Entity).
+ * Extrait de utils.js — Phase 1B.
+ *
+ * Supporte les modes "full" (Clean Architecture) et "light" (MVP).
+ * La différence entre les deux modes porte uniquement sur le chemin
+ * d'import de l'enum Role :
+ *   - full  : src/user/domain/enums/role.enum
+ *   - light : src/common/enums/role.enum
+ */
+
+const { capitalize, getFormattedType } = require("../../helpers");
+
+/**
+ * Génère le contenu TypeScript de l'entité de domaine.
+ *
+ * @param {object} entity - L'objet entité { name, fields[] }
+ * @param {"full"|"light"} mode - Le mode d'architecture cible
+ * @returns {Promise<string>} Le code TypeScript de l'entité
+ */
+async function generateEntityFileContent(entity, mode = "full") {
+  if (!entity || !entity.name) {
+    throw new Error("Nom de l'entité manquant !");
+  }
+
+  const entityName = capitalize(entity.name);
+  const className = `${entityName}Entity`;
+
+  const defaultFields = [
+    {
+      name: "id",
+      type: "string",
+      comment:
+        "L'identifiant unique de l'entité.\n * Utilisé pour retrouver de manière unique un enregistrement dans la base de données.\n *\n * Exemple : '123e4567-e89b-12d3-a456-426614174000'",
+    },
+    {
+      name: "createdAt",
+      type: "Date",
+      comment:
+        "La date de création de l'entité.\n * Définie lors de la création et ne change pas.\n *\n * Exemple : new Date('2022-01-01T10:00:00Z')",
+    },
+    {
+      name: "updatedAt",
+      type: "Date",
+      comment:
+        "La date de dernière mise à jour de l'entité.\n * Mise à jour à chaque modification.\n *\n * Exemple : new Date('2022-02-01T15:00:00Z')",
+    },
+  ];
+
+  // Types de base autorisés dans une Entité de Domaine
+  const DOMAIN_SCALAR_TYPES = [
+    "string",
+    "number",
+    "boolean",
+    "date",
+    "json",
+    "text",
+    "uuid",
+    "decimal",
+    "float",
+    "int",
+    "role",
+  ];
+
+  // Filtrage : on ne garde que les types scalaires ou les IDs techniques
+  const filteredFields = entity.fields.filter((f) => {
+    const typeLower = f.type.toLowerCase().replace("[]", "");
+    return DOMAIN_SCALAR_TYPES.includes(typeLower) || f.name.endsWith("Id");
+  });
+
+  const isUserEntityWithRole =
+    entity.name.toLowerCase() === "user" &&
+    entity.fields.some((f) => f.name === "role");
+
+  const allFields = [...defaultFields, ...filteredFields];
+
+  const constructorParams = allFields
+    .map((f) => `\n    private readonly ${f.name}: ${getFormattedType(f)},`)
+    .join("");
+
+  const getters = allFields
+    .map(
+      (f) => `
+  get${capitalize(f.name)}(): ${getFormattedType(f)}
+ {
+    return this.${f.name};
+  }`,
+    )
+    .join("\n");
+
+  const jsonFields = allFields
+    .map((f) => `      ${f.name}: this.${f.name},`)
+    .join("\n");
+
+  let importStatements = "";
+  if (isUserEntityWithRole) {
+    importStatements +=
+      mode == "full"
+        ? `import { Role } from 'src/user/domain/enums/role.enum';\n\n`
+        : `import { Role } from 'src/common/enums/role.enum'; \n\n`;
+  }
+
+  return `${importStatements}/**
+ * ${className} représente l'entité principale de ${entityName} dans le domaine.
+ * Elle contient les propriétés de base nécessaires à la gestion des données liées à ${entityName}.
+ */
+export class ${className} {
+  constructor(${constructorParams}
+  ) {}
+${getters}
+
+  /**
+ * transforme entity data to json
+ */
+  toJSON() {
+    return {
+${jsonFields}
+    };
+  }
+}
+`;
+}
+
+module.exports = { generateEntityFileContent };

package/utils/generators/infrastructure/mapperGenerator.js

@@ -0,0 +1,114 @@
+/**
+ * utils/generators/infrastructure/mapperGenerator.js
+ *
+ * Générateur du Mapper infrastructure (Full/Clean Architecture uniquement).
+ * Extrait de utils.js — Phase 1B.
+ *
+ * Le mapper n'est JAMAIS utilisé en mode light :
+ * - light : le repository utilise une méthode `private toEntity()` inline
+ * - full  : le mapper découple persistence <-> domaine <-> DTO
+ */
+
+const { capitalize, decapitalize } = require("../../helpers");
+
+/**
+ * Génère le contenu TypeScript du Mapper pour une entité.
+ *
+ * @param {object} entity - L'objet entité { name, fields[] }
+ * @returns {Promise<string>} Le code TypeScript du mapper
+ */
+async function generateMapper(entity) {
+  const entityName = capitalize(entity.name);
+
+  // 1. Types scalaires / primitifs autorisés dans le mapper
+  const SCALAR_TYPES = [
+    "string",
+    "text",
+    "uuid",
+    "json",
+    "number",
+    "int",
+    "float",
+    "decimal",
+    "boolean",
+    "date",
+    "role",
+  ];
+
+  // 2. Filtrage cohérent : scalaires + IDs techniques
+  const filterDomainFields = (f) => {
+    const typeName = f.type.toLowerCase().replace("[]", "");
+    return (
+      SCALAR_TYPES.includes(typeName) || f.name.toLowerCase().endsWith("id")
+    );
+  };
+
+  // 3. Champs filtrés pour le constructeur de l'Entity
+  const filteredFields = entity.fields.filter(filterDomainFields);
+
+  const domainArgs = ["data.id"]
+    .concat(["data.createdAt", "data.updatedAt"])
+    .concat(filteredFields.map((f) => `data.${f.name}`))
+    .join(",\n    ");
+
+  // 4. Champs pour la persistence
+  const toPersistenceFields = filteredFields
+    .map((f) => `${f.name}: dto.${f.name},`)
+    .join("\n    ");
+
+  const toUpdateFields = filteredFields
+    .map(
+      (f) => `if (dto.${f.name} !== undefined) data.${f.name} = dto.${f.name};`,
+    )
+    .join("\n   ");
+
+  return `/**
+ * ${entityName}Mapper transforms data between
+ * different layers (Persistence <-> Domain <-> DTO).
+ *
+ * Ensures that the internal database structure
+ * never leaks into the API responses.
+ */
+
+import { Injectable } from '@nestjs/common';
+import { ${entityName}Entity } from 'src/${decapitalize(
+    entity.name,
+  )}/domain/entities/${decapitalize(entity.name)}.entity';
+import { Create${entityName}Dto, Update${entityName}Dto } from 'src/${decapitalize(
+    entity.name,
+  )}/application/dtos/${decapitalize(entity.name)}.dto';
+
+@Injectable()
+export class ${entityName}Mapper {
+
+  /**
+   * Transforme les données (Prisma/TypeORM) en Entité de Domaine
+   */
+  toDomain(data: any): ${entityName}Entity {
+    return new ${entityName}Entity(
+      ${domainArgs}
+    );
+  }
+
+  /**
+   * Transforme le DTO en objet pour la création en base de données
+   */
+  toPersistence(dto: Create${entityName}Dto): any {
+    return {
+      ${toPersistenceFields}
+    };
+  }
+
+  /**
+   * Prépare l'objet de mise à jour partielle
+   */
+  toUpdatePersistence(dto: Update${entityName}Dto): any {
+    const data: any = {};
+    ${toUpdateFields}
+    return data;
+  }
+}
+`;
+}
+
+module.exports = { generateMapper };