nestcraftx 0.2.6 → 0.3.0

package/utils/helpers.js

@@ -0,0 +1,109 @@
+/**
+ * utils/helpers.js
+ *
+ * Fonctions utilitaires de manipulation de chaînes et de types.
+ * Partagées entre les générateurs full-mode et light-mode.
+ *
+ * Ces fonctions sont purement stateless : aucune dépendance externe,
+ * aucun effet de bord, aucune logique métier.
+ */
+
+/**
+ * Met en majuscule la première lettre d'une chaîne.
+ * @param {string} str
+ * @returns {string}
+ */
+function capitalize(str) {
+  if (!str) return str;
+  return str.charAt(0).toUpperCase() + str.slice(1);
+}
+
+/**
+ * Met en minuscule la première lettre d'une chaîne.
+ * @param {string} str
+ * @returns {string}
+ */
+function decapitalize(str) {
+  if (!str) return str;
+  return str.charAt(0).toLowerCase() + str.slice(1);
+}
+
+/**
+ * Retourne le pluriel simple d'un nom.
+ * - si finit par 'y' → remplace par 'ies' (category → categories)
+ * - si finit déjà par 's' → retourne tel quel
+ * - sinon → ajoute 's'
+ * @param {string} name
+ * @returns {string}
+ */
+function pluralize(name) {
+  if (name.endsWith("y")) {
+    return name.slice(0, -1) + "ies";
+  } else if (name.endsWith("s")) {
+    return name;
+  }
+  return name + "s";
+}
+
+/**
+ * Mappe le type de champ interne (sélectionné par l'utilisateur) au type
+ * TypeScript correspondant pour la génération de code.
+ *
+ * @param {string} type - Le type de base (string, number, boolean, Date, json, etc.)
+ * @returns {string} Le type formaté TypeScript
+ */
+function formatType(type) {
+  switch (type.toLowerCase()) {
+    case "number":
+    case "decimal":
+      return "number";
+
+    case "boolean":
+      return "boolean";
+
+    case "date":
+      return "Date";
+
+    case "json":
+      return "Record<string, any>";
+
+    case "string":
+    case "text":
+    case "uuid":
+      return "string";
+  }
+
+  // Gère les tableaux (ex: 'string[]', 'number[]')
+  if (type.endsWith("[]")) {
+    return `${formatType(type.slice(0, -2))}[]`;
+  }
+
+  // Laisse passer les types complexes (DTO, Enum, classe custom)
+  if (type.match(/^[A-Za-z][A-Za-z0-9_]*$/)) {
+    return type;
+  }
+
+  return "any";
+}
+
+/**
+ * Gère les cas spéciaux avant l'application de formatType.
+ * Ex: le champ 'role' de type string est traité comme le type 'Role' (enum).
+ *
+ * @param {object} field - L'objet champ { name, type }
+ * @returns {string} Le type final formaté
+ */
+function getFormattedType(field) {
+  if (field.name === "role" && field.type.toLowerCase().startsWith("string")) {
+    return "Role";
+  }
+  return formatType(field.type);
+}
+
+module.exports = {
+  capitalize,
+  decapitalize,
+  pluralize,
+  formatType,
+  getFormattedType,
+};

package/utils/setups/setupAuth.js

@@ -13,12 +13,15 @@ async function setupAuth(inputs) {
   const isFull = mode === "full";
 
   // 1. INSTALLATION DES DÉPENDANCES
+  const pkgManager = inputs.packageManager || "npm";
+  const installCmd = pkgManager === "yarn" || pkgManager === "pnpm" ? `${pkgManager} add` : "npm install";
+
   await runCommand(
-    `npm install @nestjs/jwt @nestjs/passport passport passport-jwt bcrypt uuid`,
+    `${installCmd} @nestjs/jwt @nestjs/passport passport passport-jwt bcrypt uuid`,
     "Erreur install deps auth",
   );
   await runCommand(
-    `npm install -D @types/passport-jwt @types/bcrypt @types/uuid`,
+    `${installCmd} -D @types/passport-jwt @types/bcrypt @types/uuid`,
     "Erreur install dev-deps auth",
   );
 
@@ -773,9 +776,6 @@ export class JwtAuthGuard extends AuthGuard('jwt') {
     const request = context.switchToHttp().getRequest();
     const user = request.user;
 
-    console.log('🔍 Required Roles:', requiredRoles);
-    console.log('👤 User Role:', user?.role);
-
     // Check if the user has one of the required roles
     return user && user.role && requiredRoles.includes(user.role);
    }

package/utils/setups/setupDatabase.js

@@ -9,7 +9,8 @@ async function setupDatabase(inputs) {
 
   await runCommand(
     "npm install dotenv",
-    "Error installing dotenv automatically, please run it manually now"
+    "Error installing dotenv automatically, please run it manually now",
+    { critical: false },
   );
 
   switch (inputs.selectedDB) {

package/utils/setups/setupMongoose.js

@@ -1,5 +1,6 @@
 const { runCommand } = require("../shell");
 const path = require("path");
+const fs = require("fs");
 const {
   createFile,
   updateFile,
@@ -68,11 +69,27 @@ async function setupMongoose(inputs) {
   );
 
   // --- Base Configuration (app.module.ts and .env) --- // Generating the .env file
-  const envContent = `
-  MONGO_URI=${inputs.dbConfig.MONGO_URI}
-  MONGO_DB=${inputs.dbConfig.MONGO_DB}
-   `.trim();
-  await createFile({ path: ".env", contente: envContent });
+  const envPath = ".env";
+  const mongoUriLine = `MONGO_URI=${inputs.dbConfig.MONGO_URI}`;
+  const mongoDbLine = `MONGO_DB=${inputs.dbConfig.MONGO_DB}`;
+
+  if (!fs.existsSync(envPath)) {
+    const envContent = `${mongoUriLine}\n${mongoDbLine}\n`;
+    await createFile({ path: envPath, contente: envContent });
+  } else {
+    let content = fs.readFileSync(envPath, "utf8");
+    if (content.includes("MONGO_URI=")) {
+      content = content.replace(/MONGO_URI=.*/g, mongoUriLine);
+    } else {
+      content += `\n${mongoUriLine}`;
+    }
+    if (content.includes("MONGO_DB=")) {
+      content = content.replace(/MONGO_DB=.*/g, mongoDbLine);
+    } else {
+      content += `\n${mongoDbLine}`;
+    }
+    fs.writeFileSync(envPath, content, "utf8");
+  }
 
   const appModulePath = path.join("src", "app.module.ts");
   const mongooseImport = `import { MongooseModule } from '@nestjs/mongoose';`;

package/utils/setups/setupPrisma.js

@@ -86,36 +86,41 @@ async function setupPrisma(inputs) {
     for (const relation of inputs.entitiesData.relations) {
       const fromLower = relation.from.toLowerCase();
       const toLower = relation.to.toLowerCase();
-      const fromCapitalized = capitalize(relation.from);
-      const toCapitalized = capitalize(relation.to); // 'from' side (source)
 
       if (relation.type === "1-n") {
         // 'One' side: exclude the name of the other entity's list (e.g., 'articles')
         fieldsToExcludeMap.get(fromLower).push(`${toLower}s`);
-      } else if (relation.type === "n-1") {
-        // 'Many' side: exclude the foreign key (e.g., 'articleId') and the relation name (e.g., 'article')
-        fieldsToExcludeMap.get(fromLower).push(`${toLower}id`, toLower);
-      } // Add other relation types (1-1, n-n) if necessary here... // 'to' side (target)
-      if (relation.type === "1-n") {
         // 'Many' side: exclude the foreign key (e.g., 'userId') and the relation name (e.g., 'user')
         fieldsToExcludeMap.get(toLower).push(`${fromLower}id`, fromLower);
       } else if (relation.type === "n-1") {
+        // 'Many' side: exclude the foreign key (e.g., 'articleId') and the relation name (e.g., 'article')
+        fieldsToExcludeMap.get(fromLower).push(`${toLower}id`, toLower);
         // 'One' side: exclude the name of the other entity's list (e.g., 'comments')
         fieldsToExcludeMap.get(toLower).push(`${fromLower}s`);
+      } else if (relation.type === "1-1") {
+        // 'from' side (source of relation, holds the FK): exclude foreign key and relation name
+        fieldsToExcludeMap.get(fromLower).push(`${toLower}id`, toLower);
+        // 'to' side (target of relation): exclude relation name
+        fieldsToExcludeMap.get(toLower).push(fromLower);
+      } else if (relation.type === "n-n") {
+        // Both sides hold list of other entity: exclude plurals
+        fieldsToExcludeMap.get(fromLower).push(`${toLower}s`);
+        fieldsToExcludeMap.get(toLower).push(`${fromLower}s`);
       }
     }
   }
   // 2. Initial generation of models WITHOUT incorrect relationship fields
   for (const entity of inputs.entitiesData.entities) {
     const entityNameLower = entity.name.toLowerCase();
+    const entityNameCap = capitalize(entity.name);
     // On utilise un Set pour suivre les noms de champs déjà écrits dans ce modèle
     const addedFields = new Set(["id", "createdat", "updatedat"]);
 
     schemaContent += `
     /**
-    * ${entity.name} Model
+    * ${entityNameCap} Model
     */
-    model ${entity.name} {
+    model ${entityNameCap} {
       id        String   @id @default(uuid())
       createdAt DateTime @default(now())
       updatedAt DateTime @updatedAt`;
@@ -159,30 +164,35 @@ async function setupPrisma(inputs) {
       const to = relation.to;
       const type = relation.type;
 
+      const fromCap = capitalize(from);
+      const toCap = capitalize(to);
+      const fromLow = from.toLowerCase();
+      const toLow = to.toLowerCase();
+
       // The replacement must be done on the entire generated schemaContent // Using a replacement function to update the content of `schemaContent`
       if (type === "1-n") {
         // "One" side (source): adds the list (to[])
         schemaContent = schemaContent.replace(
-          new RegExp(`model ${from} \{([\\s\\S]*?)\n\\}`, "m"),
+          new RegExp(`model ${fromCap} \\{([\\s\\S]*?)\\n\\}`, "m"),
           (match, content) => {
-            const fieldLine = `  ${to}s ${to}[]`;
+            const fieldLine = `  ${toLow}s ${toCap}[]`;
             return match.includes(fieldLine)
               ? match
-              : `model ${from} {${content}\n${fieldLine}\n}`;
+              : `model ${fromCap} {${content}\n${fieldLine}\n}`;
           },
         );
 
         // "Many" side (target): adds the relation and the foreign key
         schemaContent = schemaContent.replace(
-          new RegExp(`model ${to} \{([\\s\\S]*?)\n\\}`, "m"),
+          new RegExp(`model ${toCap} \\{([\\s\\S]*?)\\n\\}`, "m"),
           (match, content) => {
-            const relationLine = `  ${from} ${from} @relation(fields: [${from}Id], references: [id])`;
-            const fkLine = `  ${from}Id String`;
+            const relationLine = `  ${fromLow} ${fromCap} @relation(fields: [${fromLow}Id], references: [id])`;
+            const fkLine = `  ${fromLow}Id String`;
             let result = match.includes(relationLine)
               ? content
               : `${content}\n${relationLine}`;
             result = result.includes(fkLine) ? result : `${result}\n${fkLine}`;
-            return `model ${to} {${result}\n}`;
+            return `model ${toCap} {${result}\n}`;
           },
         );
       }
@@ -192,27 +202,26 @@ async function setupPrisma(inputs) {
 
         // "Many" side (source = from): adds the relation and the foreign key
         schemaContent = schemaContent.replace(
-          new RegExp(`model ${from} \{([\\s\\S]*?)\n\\}`, "m"),
+          new RegExp(`model ${fromCap} \\{([\\s\\S]*?)\\n\\}`, "m"),
           (match, content) => {
-            const relationLine = `  ${to} ${to} @relation(fields: [${to}Id], references: [id])`;
-            const fkLine = `  ${to}Id String`;
+            const relationLine = `  ${toLow} ${toCap} @relation(fields: [${toLow}Id], references: [id])`;
+            const fkLine = `  ${toLow}Id String`;
             let result = match.includes(relationLine)
               ? content
               : `${content}\n${relationLine}`;
             result = result.includes(fkLine) ? result : `${result}\n${fkLine}`;
-            return `model ${from} {${result}\n}`;
+            return `model ${fromCap} {${result}\n}`;
           },
         );
 
         // "One" side (target = to): adds the list (from[])
         schemaContent = schemaContent.replace(
-          new RegExp(`model ${to} \{([\\s\\S]*?)\n\\}`, "m"),
+          new RegExp(`model ${toCap} \\{([\\s\\S]*?)\\n\\}`, "m"),
           (match, content) => {
-            const fromCapitalized = capitalize(from);
-            const fieldLine = `  ${from}s ${from}[]`;
+            const fieldLine = `  ${fromLow}s ${fromCap}[]`;
             return match.includes(fieldLine)
               ? match
-              : `model ${to} {${content}\n${fieldLine}\n}`;
+              : `model ${toCap} {${content}\n${fieldLine}\n}`;
           },
         );
       }
@@ -220,28 +229,28 @@ async function setupPrisma(inputs) {
       if (type === "1-1") {
         // 'from' side (source): adds the relation, foreign key, and @unique attribute
         schemaContent = schemaContent.replace(
-          new RegExp(`model ${from} \{([\\s\\S]*?)\n\\}`, "m"),
+          new RegExp(`model ${fromCap} \\{([\\s\\S]*?)\\n\\}`, "m"),
           (match, content) => {
-            const relationLine = `  ${to} ${to}? @relation(fields: [${to}Id], references: [id])`; // The foreign key must be unique in a 1-1 relationship, and optional for flexibility
-            const fkLine = `  ${to}Id String? @unique`;
+            const relationLine = `  ${toLow} ${toCap}? @relation(fields: [${toLow}Id], references: [id])`; // The foreign key must be unique in a 1-1 relationship, and optional for flexibility
+            const fkLine = `  ${toLow}Id String? @unique`;
 
             let result = match.includes(relationLine)
               ? content
               : `${content}\n${relationLine}`;
             result = result.includes(fkLine) ? result : `${result}\n${fkLine}`;
-            return `model ${from} {${result}\n}`;
+            return `model ${fromCap} {${result}\n}`;
           },
         );
 
         // 'to' side (target): adds the inverse relation (optional)
         schemaContent = schemaContent.replace(
-          new RegExp(`model ${to} \{([\\s\\S]*?)\n\\}`, "m"),
+          new RegExp(`model ${toCap} \\{([\\s\\S]*?)\\n\\}`, "m"),
           (match, content) => {
             // Inverse relation (optional because 'from' holds the FK)
-            const fieldLine = `  ${from} ${from}?`;
+            const fieldLine = `  ${fromLow} ${fromCap}?`;
             return match.includes(fieldLine)
               ? match
-              : `model ${to} {${content}\n${fieldLine}\n}`;
+              : `model ${toCap} {${content}\n${fieldLine}\n}`;
           },
         );
       }
@@ -249,23 +258,23 @@ async function setupPrisma(inputs) {
       if (type === "n-n") {
         // 'from' side (source): adds the list (to[])
         schemaContent = schemaContent.replace(
-          new RegExp(`model ${from} \{([\\s\\S]*?)\n\\}`, "m"),
+          new RegExp(`model ${fromCap} \\{([\\s\\S]*?)\\n\\}`, "m"),
           (match, content) => {
-            const fieldLine = `  ${to}s ${to}[]`;
+            const fieldLine = `  ${toLow}s ${toCap}[]`;
             return match.includes(fieldLine)
               ? match
-              : `model ${from} {${content}\n${fieldLine}\n}`;
+              : `model ${fromCap} {${content}\n${fieldLine}\n}`;
           },
         );
 
         // 'to' side (target): adds the list (from[])
         schemaContent = schemaContent.replace(
-          new RegExp(`model ${to} \{([\\s\\S]*?)\n\\}`, "m"),
+          new RegExp(`model ${toCap} \\{([\\s\\S]*?)\\n\\}`, "m"),
           (match, content) => {
-            const fieldLine = `  ${from}s ${from}[]`;
+            const fieldLine = `  ${fromLow}s ${fromCap}[]`;
             return match.includes(fieldLine)
               ? match
-              : `model ${to} {${content}\n${fieldLine}\n}`;
+              : `model ${toCap} {${content}\n${fieldLine}\n}`;
           },
         );
       }
@@ -289,7 +298,7 @@ async function setupPrisma(inputs) {
     path: schemaPath,
     contente: baseSchema,
   });
-  await runCommand(`npx prisma format`, "❌ Failed to format prisma schema");
+  await runCommand(`npx prisma format`, "❌ Failed to format prisma schema — run 'npx prisma format' manually", { critical: false });
 
   // 📁 Step 6: Creating the `src/prisma` structure
   const defaultPatch = "src/prisma";
@@ -344,6 +353,7 @@ async function setupPrisma(inputs) {
   await runCommand(
     `${inputs.packageManager} add dotenv`,
     "❌ Failed to install dotenv",
+    { critical: false },
   );
 
   // Creating prisma.config.ts file to load environment variables
@@ -362,7 +372,7 @@ async function setupPrisma(inputs) {
   }
 
   // Step 7: Generating the Prisma client
-  await runCommand("npx prisma generate", "❌ Prisma generation failed");
+  await runCommand("npx prisma generate", "❌ Prisma client generation failed — run 'npx prisma generate' manually", { critical: false });
 
   // Step 8: Migration (ONLY in 'new' mode)
   if (inputs.isDemo) {
@@ -645,18 +655,18 @@ async function updatePrismaSchema(entityData) {
 
     switch (relation.type) {
       case "n-1": // "Many to One" : Le nouveau module appartient à une cible
-        relationFields += `\n  ${targetLow}   ${targetLow} @relation(fields: [${targetLow}Id], references: [id])`;
+        relationFields += `\n  ${targetLow}   ${targetCap} @relation(fields: [${targetLow}Id], references: [id])`;
         relationFields += `\n  ${targetLow}Id String`;
         break;
       case "1-n": // "One to Many" : Le nouveau module possède plusieurs cibles
-        relationFields += `\n  ${targetLow}s  ${targetLow}[]`;
+        relationFields += `\n  ${targetLow}s  ${targetCap}[]`;
         break;
       case "1-1":
-        relationFields += `\n  ${targetLow}   ${targetLow}? @relation(fields: [${targetLow}Id], references: [id])`;
+        relationFields += `\n  ${targetLow}   ${targetCap}? @relation(fields: [${targetLow}Id], references: [id])`;
         relationFields += `\n  ${targetLow}Id String? @unique`;
         break;
       case "n-n":
-        relationFields += `\n  ${targetLow}s  ${targetLow}[]`;
+        relationFields += `\n  ${targetLow}s  ${targetCap}[]`;
         break;
     }
   }
@@ -665,7 +675,7 @@ async function updatePrismaSchema(entityData) {
   let modelBlock = `\n/**
  * ${capitalizedName} Model
  */
-model ${lowercasedName} {
+model ${capitalizedName} {
   id        String   @id @default(uuid())
   createdAt DateTime @default(now())
   updatedAt DateTime @updatedAt${relationFields}`;
@@ -686,117 +696,53 @@ model ${lowercasedName} {
   // 4️⃣ Injection de l'INVERSE dans le modèle cible (Target)
   if (relation) {
     const targetCap = capitalize(relation.target);
-    const targetLow = capitalize(relation.target);
+    const targetLow = relation.target.toLowerCase();
     const newCap = capitalizedName;
     const newLow = name.toLowerCase();
 
     let inverseField = "";
     switch (relation.type) {
       case "n-1": // Inverse d'un Many-to-One est un One-to-Many
-        inverseField = `  ${newLow}s ${newLow}[]`;
+        inverseField = `  ${newLow}s ${newCap}[]`;
         break;
       case "1-n": // Inverse d'un One-to-Many est un Many-to-One
-        inverseField = `  ${newLow}   ${newLow} @relation(fields: [${newLow}Id], references: [id])\n  ${newLow}Id String`;
+        inverseField = `  ${newLow}   ${newCap} @relation(fields: [${newLow}Id], references: [id])\n  ${newLow}Id String`;
         break;
       case "1-1":
-        inverseField = `  ${newLow}   ${newLow}?`;
+        inverseField = `  ${newLow}   ${newCap}?`;
         break;
       case "n-n":
-        inverseField = `  ${newLow}s ${newLow}[]`;
+        inverseField = `  ${newLow}s ${newCap}[]`;
         break;
     }
 
     // On utilise une RegEx pour trouver le bloc du modèle cible et insérer avant la fermeture "}"
     await updateFile({
       path: schemaPath,
-      pattern: new RegExp(`model ${targetLow} \\{([\\s\\S]*?)\\}`, "g"),
-      replacement: `model ${targetLow} {$1\n${inverseField}\n}`,
+      pattern: new RegExp(`model ${targetCap} \\{([\\s\\S]*?)\\}`, "g"),
+      replacement: `model ${targetCap} {$1\n${inverseField}\n}`,
     });
   }
 
   // 3️⃣ Prisma Commands Sync (meilleur sur Windows)
-  try {
-    console.log(info("Running: prisma format..."));
-    execSync("npx prisma format", { stdio: "pipe" });
-
-    console.log(info("Running: prisma generate..."));
-    execSync("npx prisma generate", { stdio: "pipe" });
-
-    console.log(info("Running: prisma migrate dev..."));
-    execSync(
-      `npx prisma migrate dev --name add_module_${entityData.name} --force`,
-      {
-        stdio: "pipe",
-      },
-    );
-
-    // console.log(success("🎉 Prisma migration completed successfully!"));
-  } catch (err) {
-    // 4️⃣ Gestion spécifique Windows EPERM
-    if (
-      err.message.includes("operation not permitted") ||
-      err.message.includes("EPERM") ||
-      err.message.includes("EBUSY")
-    ) {
-      logWarning("System Lock Detected!");
-      console.log(
-        `${info("Prisma Client binary is locked because your server is running.")}`,
-      );
-      console.log(
-        `${info("ACTION:")} Stop NestJS (Ctrl+C) and run manually:\n`,
-      );
-      console.log(`${success("npx prisma generate")}`);
-      console.log(`${success("npx prisma migrate dev")}\n`);
-    } else {
-      console.log(error("❌ Prisma error: " + err.message));
-    }
-  }
-}
-
-/* async function updatePrismaSchema(entityData) {
-  const schemaPath = "prisma/schema.prisma";
-
-  // Construction du bloc modèle
-  let modelBlock = `\nmodel ${capitalize(entityData.name)} {
-  id        String   @id @default(uuid())
-  createdAt DateTime @default(now())
-  updatedAt DateTime @updatedAt`;
-
-  entityData.fields.forEach((field) => {
-    // Note: On réutilise ta fonction mapTypeToPrisma ici
-    modelBlock += `\n  ${field.name} ${mapTypeToPrisma(field.type)}`;
-  });
-
-  modelBlock += `\n}\n`;
-
-  // Injection à la fin du fichier
-  await updateFile({
-    path: schemaPath,
-    pattern: /$/, // On ajoute à la fin
-    replacement: modelBlock,
-  });
+  await runCommand(
+    "npx prisma format",
+    "❌ Failed to format prisma schema — run 'npx prisma format' manually",
+    { critical: false }
+  );
 
-  // ⚠️ IMPORTANT : On formate et on régénère le client pour supprimer les erreurs TS
-  try {
-    await runCommand("npx prisma format");
-    await runCommand("npx prisma generate");
-    await runCommand(
-      `npx prisma migrate dev --name add_module_${entityData.name}`,
-    );
-  } catch (err) {
-    if (err.message.includes("EPERM")) {
-      console.log(
-        `\n${warning("⚠️  System Lock:")} Could not update Prisma Client binary because your app is currently running.`,
-      );
-      console.log(
-        `${info("ACTION REQUIRED:")} Stop your dev server (Ctrl+C) and run: ${success("| npx prisma generate | and | npx prisma migrate dev |")}\n`,
-      );
-    } else {
-      logError("Prisma error: " + err.message);
-    }
-  }
+  await runCommand(
+    "npx prisma generate",
+    "❌ Failed to generate prisma client — run 'npx prisma generate' manually",
+    { critical: false }
+  );
 
-  throw new Error(err);
-} */
+  await runCommand(
+    `npx prisma migrate dev --name add_module_${entityData.name} --force`,
+    `❌ Failed to run prisma migration — run 'npx prisma migrate dev --name add_module_${entityData.name}' manually`,
+    { critical: false }
+  );
+}
 
 module.exports = { setupPrisma, updatePrismaSchema };
+