nestcraftx 0.3.0 → 1.0.0

package/utils/setups/setupMongoose.js

@@ -63,11 +63,23 @@ async function setupMongoose(inputs) {
 
   logInfo("📦 Installing Mongoose and @nestjs/mongoose...");
 
+  const pkgManager = inputs.packageManager || "npm";
+  const installCmd = pkgManager === "yarn" || pkgManager === "pnpm" ? `${pkgManager} add` : "npm install";
+
   await runCommand(
-    `${inputs.packageManager} install @nestjs/mongoose mongoose`,
+    `${installCmd} @nestjs/mongoose@^10.0.6 mongoose@^8.3.1`,
     "Mongoose and its dependencies successfully installed!"
   );
 
+  const isDryRun = process.argv.includes("--dry-run");
+  if (isDryRun) {
+    console.log("[DRY-RUN] Simulated: write Mongoose configuration, app.module.ts config, and schemas");
+    logSuccess(
+      "Mongoose configuration complete. Schemas are generated in src/schemas!"
+    );
+    return;
+  }
+
   // --- Base Configuration (app.module.ts and .env) --- // Generating the .env file
   const envPath = ".env";
   const mongoUriLine = `MONGO_URI=${inputs.dbConfig.MONGO_URI}`;
@@ -78,14 +90,10 @@ async function setupMongoose(inputs) {
     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 {
+    if (!content.includes("MONGO_URI=")) {
       content += `\n${mongoUriLine}`;
     }
-    if (content.includes("MONGO_DB=")) {
-      content = content.replace(/MONGO_DB=.*/g, mongoDbLine);
-    } else {
+    if (!content.includes("MONGO_DB=")) {
       content += `\n${mongoDbLine}`;
     }
     fs.writeFileSync(envPath, content, "utf8");
@@ -98,21 +106,30 @@ async function setupMongoose(inputs) {
     dbName: process.env.MONGO_DB,
    }),`;
 
-  // 1. Adding MongooseModule import
-  await updateFile({
-    path: appModulePath,
-    pattern: /import {[\s\S]*?} from '@nestjs\/config';/,
-    replacement: (match) => `${match}\n${mongooseImport}`,
-  });
+  if (fs.existsSync(appModulePath)) {
+    let appModuleContent = fs.readFileSync(appModulePath, "utf8");
+
+    // 1. Adding MongooseModule import
+    if (!appModuleContent.includes("@nestjs/mongoose")) {
+      await updateFile({
+        path: appModulePath,
+        pattern: /import {[\s\S]*?} from '@nestjs\/config';/,
+        replacement: (match) => `${match}\n${mongooseImport}`,
+      });
+      appModuleContent = fs.readFileSync(appModulePath, "utf8");
+    }
 
-  // 2. Adding MongooseModule.forRoot() configuration
-  const importsPattern =
-    /imports:\s*\[[\s\S]*?ConfigModule\.forRoot\([\s\S]*?\),/;
-  await updateFile({
-    path: appModulePath,
-    pattern: importsPattern,
-    replacement: (match) => `${match}${mongooseForRoot}`,
-  });
+    // 2. Adding MongooseModule.forRoot() configuration
+    if (!appModuleContent.includes("MongooseModule.forRoot")) {
+      const importsPattern =
+        /imports:\s*\[[\s\S]*?ConfigModule\.forRoot\([\s\S]*?\),/;
+      await updateFile({
+        path: appModulePath,
+        pattern: importsPattern,
+        replacement: (match) => `${match}${mongooseForRoot}`,
+      });
+    }
+  }
 
   // --- Generating Mongoose Entities (Schemas) ---
   logInfo("📁 Generating Mongoose schemas (src/schemas)...");
@@ -161,10 +178,34 @@ role: Role;
       const mongooseType = mapTypeToMongoose(field.type);
       const tsType = field.type;
 
-      const isRequired =
-        field.name.toLowerCase() !== "isactive" &&
-        field.name.toLowerCase() !== "password";
-      const requiredOption = isRequired ? ", required: true" : "";
+      const isRequired = field.nullable !== undefined ? !field.nullable : (field.name.toLowerCase() !== "isactive" && field.name.toLowerCase() !== "password");
+      let propOpts = [`type: ${mongooseType}`];
+      if (isRequired) {
+        propOpts.push("required: true");
+      }
+      if (field.unique) {
+        propOpts.push("unique: true");
+      }
+      if (field.default !== undefined && field.default !== null && field.default !== "") {
+        let defaultVal = field.default;
+        if (typeof defaultVal === "string") {
+          if (defaultVal === "true") defaultVal = true;
+          else if (defaultVal === "false") defaultVal = false;
+          else if (defaultVal.toLowerCase() === "now" || defaultVal.toLowerCase() === "now()") {
+            defaultVal = "Date.now";
+          } else if (!isNaN(defaultVal) && defaultVal.trim() !== "") {
+            defaultVal = Number(defaultVal);
+          }
+        }
+        if (defaultVal === "Date.now") {
+          propOpts.push("default: Date.now");
+        } else if (typeof defaultVal === "boolean" || typeof defaultVal === "number") {
+          propOpts.push(`default: ${defaultVal}`);
+        } else {
+          propOpts.push(`default: '${defaultVal}'`);
+        }
+      }
+      const propOptionsStr = propOpts.join(", ");
 
       // Import des enums partagés si nécessaire
       if (
@@ -176,8 +217,8 @@ role: Role;
       }
 
       fieldsContent += `
-       @Prop({ type: ${mongooseType}${requiredOption} })
-       ${field.name}: ${tsType};
+       @Prop({ ${propOptionsStr} })
+       ${field.name}${field.nullable ? "?" : ""}: ${tsType};
       `;
     }
 
@@ -203,11 +244,22 @@ role: Role;
     ", "
   )}]),`;
 
-  await updateFile({
-    path: appModulePath,
-    pattern: new RegExp(mongooseForRoot.trim().replace(/[\n\r]/g, "\\s*"), "g"),
-    replacement: (match) => `${match}\n\t${forFeatureBlock}`,
-  });
+  if (fs.existsSync(appModulePath)) {
+    const appModuleContent = fs.readFileSync(appModulePath, "utf8");
+    if (appModuleContent.includes("MongooseModule.forFeature")) {
+      await updateFile({
+        path: appModulePath,
+        pattern: /MongooseModule\.forFeature\(\[[\s\S]*?\]\),/,
+        replacement: forFeatureBlock,
+      });
+    } else {
+      await updateFile({
+        path: appModulePath,
+        pattern: new RegExp(mongooseForRoot.trim().replace(/[\n\r]/g, "\\s*"), "g"),
+        replacement: (match) => `${match}\n\t${forFeatureBlock}`,
+      });
+    }
+  }
 
   if (inputs.isDemo) {
     // The generateSampleData function must be adapted for 'new Date()' usage and Mongoose types

package/utils/setups/setupPrisma.js

@@ -147,7 +147,7 @@ async function setupPrisma(inputs) {
         !fieldsToExclude.includes(fieldNameLower) &&
         !addedFields.has(fieldNameLower)
       ) {
-        schemaContent += `\n  ${field.name} ${mapTypeToPrisma(field.type)}`;
+        schemaContent += `\n  ${field.name} ${formatPrismaField(field)}`;
         addedFields.add(fieldNameLower);
       }
     }
@@ -281,6 +281,32 @@ async function setupPrisma(inputs) {
     }
   }
 
+  if (inputs.useAuth) {
+    schemaContent += `
+  /**
+  * PasswordReset Model
+  */
+  model PasswordReset {
+    id        String   @id @default(uuid())
+    email     String
+    token     String   @unique
+    expiresAt DateTime
+    createdAt DateTime @default(now())
+  }
+
+  /**
+  * Otp Model
+  */
+  model Otp {
+    id        String   @id @default(uuid())
+    email     String
+    otp       String
+    expiresAt DateTime
+    createdAt DateTime @default(now())
+  }
+  `;
+  }
+
   logInfo("Updating schema.prisma");
   const baseSchema = `
   generator client {
@@ -431,6 +457,44 @@ function mapTypeToPrisma(type) {
   }
 }
 
+/**
+ * Formats a field definition for the Prisma schema including constraints.
+ * @param {object} field
+ * @returns {string} Formatted field line content (e.g. "String? @unique")
+ */
+function formatPrismaField(field) {
+  let prismaType = mapTypeToPrisma(field.type);
+  if (field.nullable) {
+    if (!prismaType.endsWith("?") && !prismaType.endsWith("[]")) {
+      prismaType += "?";
+    }
+  }
+  let attributes = "";
+  if (field.unique) {
+    attributes += " @unique";
+  }
+  if (field.default !== undefined && field.default !== null && field.default !== "") {
+    let defaultVal = field.default;
+    if (typeof defaultVal === "string") {
+      if (defaultVal === "true") defaultVal = true;
+      else if (defaultVal === "false") defaultVal = false;
+      else if (defaultVal.toLowerCase() === "now" || defaultVal.toLowerCase() === "now()") {
+        defaultVal = "now()";
+      } else if (!isNaN(defaultVal) && defaultVal.trim() !== "") {
+        defaultVal = Number(defaultVal);
+      }
+    }
+    if (defaultVal === "now()") {
+      attributes += ` @default(now())`;
+    } else if (typeof defaultVal === "boolean" || typeof defaultVal === "number") {
+      attributes += ` @default(${defaultVal})`;
+    } else {
+      attributes += ` @default("${defaultVal}")`;
+    }
+  }
+  return `${prismaType}${attributes}`;
+}
+
 async function setupPrismaSeeding(inputs) {
   logInfo("⚙️ Configuring seeding for Prisma...");
 
@@ -681,7 +745,7 @@ model ${capitalizedName} {
   updatedAt DateTime @updatedAt${relationFields}`;
 
   fields.forEach((field) => {
-    modelBlock += `\n  ${field.name} ${mapTypeToPrisma(field.type)}`;
+    modelBlock += `\n  ${field.name} ${formatPrismaField(field)}`;
   });
 
   modelBlock += `\n}\n`;
@@ -738,11 +802,94 @@ model ${capitalizedName} {
   );
 
   await runCommand(
-    `npx prisma migrate dev --name add_module_${entityData.name} --force`,
+    `npx prisma migrate dev --name add_module_${entityData.name}`,
     `❌ Failed to run prisma migration — run 'npx prisma migrate dev --name add_module_${entityData.name}' manually`,
     { critical: false }
   );
 }
 
-module.exports = { setupPrisma, updatePrismaSchema };
+/**
+ * Ajoute une relation entre deux modèles Prisma EXISTANTS.
+ * Contrairement à updatePrismaSchema, ne crée PAS un nouveau modèle —
+ * patche uniquement les champs FK/inverse dans les deux modèles déjà présents.
+ *
+ * @param {string} source - Nom de l'entité source (ex: "post")
+ * @param {string} target - Nom de l'entité cible (ex: "user")
+ * @param {string} relationType - "n-1" | "1-n" | "1-1" | "n-n"
+ */
+async function addPrismaRelation(source, target, relationType) {
+  const schemaPath = "prisma/schema.prisma";
+  const sourceCap = capitalize(source);
+  const targetCap = capitalize(target);
+  const sourceLow = source.toLowerCase();
+  const targetLow = target.toLowerCase();
+
+  // 1️⃣ Champs à injecter dans le modèle SOURCE
+  let sourceFields = "";
+  switch (relationType) {
+    case "n-1":
+      sourceFields = `  ${targetLow}   ${targetCap} @relation(fields: [${targetLow}Id], references: [id])\n  ${targetLow}Id String`;
+      break;
+    case "1-n":
+      sourceFields = `  ${targetLow}s  ${targetCap}[]`;
+      break;
+    case "1-1":
+      sourceFields = `  ${targetLow}   ${targetCap}? @relation(fields: [${targetLow}Id], references: [id])\n  ${targetLow}Id String? @unique`;
+      break;
+    case "n-n":
+      sourceFields = `  ${targetLow}s  ${targetCap}[]`;
+      break;
+    default:
+      throw new Error(`❌ Type de relation inconnu : ${relationType}`);
+  }
+
+  // 2️⃣ Champs inverses à injecter dans le modèle TARGET
+  let targetFields = "";
+  switch (relationType) {
+    case "n-1":
+      targetFields = `  ${sourceLow}s ${sourceCap}[]`;
+      break;
+    case "1-n":
+      targetFields = `  ${sourceLow}   ${sourceCap} @relation(fields: [${sourceLow}Id], references: [id])\n  ${sourceLow}Id String`;
+      break;
+    case "1-1":
+      targetFields = `  ${sourceLow}   ${sourceCap}?`;
+      break;
+    case "n-n":
+      targetFields = `  ${sourceLow}s ${sourceCap}[]`;
+      break;
+  }
+
+  // 3️⃣ Patch du modèle SOURCE
+  await updateFile({
+    path: schemaPath,
+    pattern: new RegExp(`model ${sourceCap} \\{([\\s\\S]*?)\\}`, "g"),
+    replacement: `model ${sourceCap} {$1\n${sourceFields}\n}`,
+  });
+
+  // 4️⃣ Patch du modèle TARGET (inverse)
+  await updateFile({
+    path: schemaPath,
+    pattern: new RegExp(`model ${targetCap} \\{([\\s\\S]*?)\\}`, "g"),
+    replacement: `model ${targetCap} {$1\n${targetFields}\n}`,
+  });
+
+  // 5️⃣ Synchronisation Prisma
+  await runCommand(
+    "npx prisma format",
+    "❌ Failed to format prisma schema — run 'npx prisma format' manually",
+    { critical: false },
+  );
+  await runCommand(
+    "npx prisma generate",
+    "❌ Failed to generate prisma client — run 'npx prisma generate' manually",
+    { critical: false },
+  );
+  await runCommand(
+    `npx prisma migrate dev --name add_relation_${sourceLow}_${targetLow}`,
+    `❌ Failed to run prisma migration — run 'npx prisma migrate dev' manually`,
+    { critical: false },
+  );
+}
 
+module.exports = { setupPrisma, updatePrismaSchema, addPrismaRelation };

package/utils/setups/setupSwagger.js

@@ -1,19 +1,26 @@
 const fs = require("fs");
-const { execSync } = require("child_process");
+const { runCommand } = require("../shell");
 const { logInfo } = require("../loggers/logInfo");
 const { logSuccess } = require("../loggers/logSuccess");
 
 async function setupSwagger(inputs) {
   logInfo("Installation et Configuration de Swagger...");
 
+  const pkgManager = inputs.packageManager || "npm";
+  const installCmd = pkgManager === "yarn" || pkgManager === "pnpm" ? `${pkgManager} add` : "npm install";
+
   // installation de swagger
-  try {
-    execSync("npm install @nestjs/swagger swagger-ui-express", {
-      stdio: "inherit",
-    });
-  } catch (error) {
-    console.error("❌ Échec de l'installation de Swagger :", error);
-    process.exit(1);
+  await runCommand(
+    `${installCmd} @nestjs/swagger@^7.3.0 swagger-ui-express@^5.0.0`,
+    "Échec de l'installation de Swagger",
+    { spinner: "Installing Swagger..." }
+  );
+
+  const isDryRun = process.argv.includes("--dry-run");
+  if (isDryRun) {
+    console.log("[DRY-RUN] Simulated: write Swagger configuration to src/main.ts");
+    logSuccess(" Swagger configuré avec succès !");
+    return;
   }
 
   // Modification de main.ts pour intégrer Swagger

package/utils/setups/setupThrottler.js

@@ -0,0 +1,92 @@
+// utils/setups/setupThrottler.js
+//
+// Script d'installation et de configuration de @nestjs/throttler.
+// Injecte le module et le guard dans app.module.ts de manière idempotente.
+
+const fs = require("fs");
+const { logInfo } = require("../loggers/logInfo");
+const { logSuccess } = require("../loggers/logSuccess");
+const { runCommand } = require("../shell");
+const { updateFile } = require("../userInput");
+
+/**
+ * Configure le rate limiting global dans le projet.
+ *
+ * @param {object} inputs - Configuration du projet
+ */
+async function setupThrottler(inputs) {
+  logInfo("Installation et Configuration du Rate Limiting (Throttler)...");
+
+  const pkgManager = inputs.packageManager || "npm";
+  const installCmd = pkgManager === "yarn" || pkgManager === "pnpm" ? `${pkgManager} add` : "npm install";
+
+  // Installation de @nestjs/throttler
+  await runCommand(
+    `${installCmd} @nestjs/throttler@^6.0.0`,
+    "Échec de l'installation de @nestjs/throttler",
+    { spinner: "Installing @nestjs/throttler..." }
+  );
+
+  const isDryRun = process.argv.includes("--dry-run");
+  if (isDryRun) {
+    console.log("[DRY-RUN] Simulated: write Throttler configuration to src/app.module.ts");
+    logSuccess(" Throttler configuré avec succès !");
+    return;
+  }
+
+  const appModulePath = "src/app.module.ts";
+  if (!fs.existsSync(appModulePath)) {
+    console.warn(`⚠️ Fichier ${appModulePath} introuvable. Skip configuration.`);
+    return;
+  }
+
+  let content = fs.readFileSync(appModulePath, "utf8");
+
+  if (!content.includes("ThrottlerModule")) {
+    // 1. Ajouter les imports
+    content = content.replace(
+      "import { Module } from '@nestjs/common';",
+      "import { Module } from '@nestjs/common';\nimport { ThrottlerModule, ThrottlerGuard } from '@nestjs/throttler';\nimport { APP_GUARD } from '@nestjs/core';"
+    );
+
+    // 2. Ajouter ThrottlerModule.forRoot dans imports: [
+    content = content.replace(
+      "imports: [",
+      `imports: [
+    ThrottlerModule.forRoot([{
+      ttl: 60000,
+      limit: 10,
+    }]),`
+    );
+
+    // 3. Ajouter ThrottlerGuard dans providers: [
+    if (content.includes("providers: [")) {
+      content = content.replace(
+        "providers: [",
+        `providers: [
+    {
+      provide: APP_GUARD,
+      useClass: ThrottlerGuard,
+    },`
+      );
+    } else {
+      content = content.replace(
+        "@Module({",
+        `@Module({
+  providers: [
+    {
+      provide: APP_GUARD,
+      useClass: ThrottlerGuard,
+    },
+  ],`
+      );
+    }
+
+    fs.writeFileSync(appModulePath, content, "utf8");
+    logSuccess(" Throttler configuré avec succès dans app.module.ts !");
+  } else {
+    logInfo(" Throttler déjà présent dans app.module.ts. Skip.");
+  }
+}
+
+module.exports = { setupThrottler };

package/utils/shell.js

@@ -20,44 +20,96 @@ const _warnings = [];
  * @param {boolean} [options.critical=true] - If true (default), a failure calls process.exit(1).
  *   If false, the failure is logged as a warning and execution continues.
  * @param {string|null} [options.spinner] - Optional spinner label shown during execution.
+ * @param {number} [options.timeout] - Custom timeout in milliseconds.
  * @returns {Promise<boolean>} Resolves to true on success, false on non-critical failure.
  */
 async function runCommand(command, errorMessage, options = {}) {
-  // Support old call signature: runCommand(cmd, msg, spinnerText)
-  // New signature: runCommand(cmd, msg, { critical, spinner })
   let critical = true;
   let spinnerText = null;
+  let customTimeout = undefined;
 
   if (typeof options === "string") {
-    // Legacy: third arg was spinnerText string
     spinnerText = options;
   } else if (typeof options === "object" && options !== null) {
-    critical = options.critical !== false; // default true
+    critical = options.critical !== false;
     spinnerText = options.spinner || null;
+    customTimeout = options.timeout;
+  }
+
+  // Determine Timeout
+  let timeoutVal = 30000; // default 30 seconds
+  if (
+    command.includes("install") ||
+    command.includes("add") ||
+    command.includes(" new ") ||
+    command.includes("prisma migrate")
+  ) {
+    timeoutVal = 600000; // 10 minutes for heavy setup commands
+  }
+  if (customTimeout !== undefined) {
+    timeoutVal = customTimeout;
+  }
+
+  // Intercept npm installation commands and append --legacy-peer-deps, --no-audit, --no-fund if missing
+  let finalCommand = command;
+  if (
+    command.startsWith("npm ") &&
+    (command.includes("install") || command.includes("add") || command.includes(" i "))
+  ) {
+    if (!command.includes("--legacy-peer-deps")) {
+      finalCommand = `${finalCommand} --legacy-peer-deps`;
+    }
+    if (!command.includes("--no-audit")) {
+      finalCommand = `${finalCommand} --no-audit`;
+    }
+    if (!command.includes("--no-fund")) {
+      finalCommand = `${finalCommand} --no-fund`;
+    }
+  }
+
+  // Dry-Run Simulation Check
+  const isDryRun = process.argv.includes("--dry-run");
+  if (isDryRun) {
+    if (spinnerText) {
+      const spin = spinner(spinnerText);
+      spin.start();
+      spin.succeed(`[DRY-RUN] Simulated: ${finalCommand}`);
+    } else {
+      console.log(`[DRY-RUN] Simulated: ${finalCommand}`);
+    }
+    return true;
   }
 
   const spin = spinnerText ? spinner(spinnerText) : null;
 
   try {
     if (spin) spin.start();
-    execSync(command, { stdio: spinnerText ? "pipe" : "inherit" });
+    execSync(finalCommand, {
+      stdio: spinnerText ? "pipe" : "inherit",
+      timeout: timeoutVal,
+    });
     if (spin) spin.succeed(spinnerText);
     return true;
   } catch (error) {
     if (spin) spin.fail(errorMessage);
 
-    const logLine = `[${new Date().toISOString()}] ${errorMessage}: ${error.message}\n`;
+    let errorDetail = error.message;
+    if (error.code === "ETIMEDOUT" || error.signal === "SIGTERM") {
+      errorDetail = `Command timed out after ${timeoutVal / 1000}s`;
+    }
+
+    const logLine = `[${new Date().toISOString()}] ${errorMessage}: ${errorDetail}\n`;
     fs.appendFileSync("setup.log", logLine);
 
     if (critical) {
-      // Fatal — stop everything
       logError(`${errorMessage}`);
       logError(`Run: ${command}`);
+      logError(`Detail: ${errorDetail}`);
       process.exit(1);
     } else {
-      // Non-critical — warn and continue
       logWarning(`${errorMessage} (non-fatal, continuing...)`);
       logWarning(`  Command: ${command}`);
+      logWarning(`  Detail: ${errorDetail}`);
       logWarning(`  See setup.log for details`);
       _warnings.push({ command, errorMessage });
       return false;
@@ -72,7 +124,7 @@ async function runCommand(command, errorMessage, options = {}) {
  */
 async function runCommandSilent(command) {
   try {
-    return execSync(command, { stdio: "pipe" }).toString();
+    return execSync(command, { stdio: "pipe", timeout: 10000 }).toString();
   } catch (error) {
     return null;
   }