nestcraftx 0.4.0 → 1.0.0

package/commands/generate.js

@@ -3,10 +3,13 @@ const path = require("path");
 const { logError } = require("../utils/loggers/logError");
 const { logInfo } = require("../utils/loggers/logInfo");
 const { logWarning } = require("../utils/loggers/logWarning");
+const { logSuccess } = require("../utils/loggers/logSuccess");
 const generateCleanModule = require("../utils/generators/cleanModuleGenerator");
 const { askEntityInputs } = require("../utils/interactive/askEntityInputs");
+const { askRelationCommand } = require("../utils/interactive/askRelationCommand");
 const lightModuleGenerator = require("../utils/generators/lightModuleGenerator");
-const { printSetupWarnings, clearSetupWarnings } = require("../utils/shell");
+const { printSetupWarnings, clearSetupWarnings, runCommand } = require("../utils/shell");
+const { generateSecret } = require("../utils/envGenerator");
 
 async function generate(subCommand, targetName, flags) {
   clearSetupWarnings();
@@ -60,11 +63,17 @@ async function generate(subCommand, targetName, flags) {
       await handleAuthGeneration(projectConfig);
       break;
 
+    case "relation":
+    case "r":
+      await handleRelationGeneration(projectConfig);
+      break;
+
     default:
       logError(`Sous-commande inconnue : ${subCommand}`);
       console.log("\nUtilisations possibles :");
       console.log("  nestcraftx g module <name>");
       console.log("  nestcraftx g auth");
+      console.log("  nestcraftx g relation");
       break;
   }
 }
@@ -84,11 +93,551 @@ async function handleModuleGeneration(name, config) {
     await lightModuleGenerator(entityData, config);
   }
 
+  // 2. Mettre à jour .nestcraftxrc avec la nouvelle entité
+  if (!config.entities) config.entities = [];
+  if (!config.relations) config.relations = [];
+
+  // Éviter les doublons
+  config.entities = config.entities.filter(e => e.name.toLowerCase() !== name.toLowerCase());
+  config.entities.push({
+    name: entityData.name,
+    fields: entityData.fields
+  });
+
+  if (entityData.relation) {
+    config.relations = config.relations.filter(
+      r => !(r.from.toLowerCase() === entityData.name.toLowerCase() && r.to.toLowerCase() === entityData.relation.target.toLowerCase())
+    );
+    config.relations.push({
+      from: entityData.name,
+      to: entityData.relation.target,
+      type: entityData.relation.type
+    });
+  }
+
+  const configPath = path.join(process.cwd(), ".nestcraftx", ".nestcraftxrc");
+  const isDryRun = process.argv.includes("--dry-run");
+  if (!isDryRun) {
+    fs.writeFileSync(configPath, JSON.stringify(config, null, 2), "utf8");
+  }
+
+  printModuleGenerationReport(name, config, entityData);
+
   printSetupWarnings();
 }
 
+/**
+ * Crée une relation entre deux modules EXISTANTS.
+ * Patche : entité cible, DTO source, Mapper source, schema DB (Prisma/Mongoose/TypeORM).
+ * Enregistre la relation dans .nestcraftxrc.
+ */
+async function handleRelationGeneration(config) {
+  const isDryRun = process.argv.includes("--dry-run");
+
+  // 1. Prompt interactif — source, cible, type
+  const relationData = await askRelationCommand(config);
+  if (!relationData) return; // Annulé ou déjà existant
+
+  const { source, target, type } = relationData;
+  const { capitalize } = require("../utils/userInput");
+
+  logInfo(`🔗 Création de la relation ${capitalize(source)} →(${type})→ ${capitalize(target)}...`);
+
+  // 2. Patcher l'entité CIBLE (ajoute FK dans la couche domaine)
+  const { updateExistingEntityRelation } = require("../utils/generators/domain/entityUpdater");
+  if (!isDryRun) {
+    await updateExistingEntityRelation(target, source, type, config.mode);
+    logInfo("   ✔ Entité cible patchée (domain layer)");
+  } else {
+    console.log(`[DRY-RUN] Simulated: patch entity ${target} with relation to ${source}`);
+  }
+
+  // 3. Patcher le DTO SOURCE + Mapper SOURCE via relation.engine
+  const { applyRelationPatches } = require("../utils/generators/relation/relation.engine");
+  if (!isDryRun) {
+    await applyRelationPatches(source, target, type, config.swagger, config.mode);
+    logInfo("   ✔ DTO + Mapper source patchés (application & infrastructure layers)");
+  } else {
+    console.log(`[DRY-RUN] Simulated: patch DTO and mapper for ${source} with relation to ${target}`);
+  }
+
+  // 4. Mise à jour du schema de base de données selon l'ORM
+  if (config.orm === "prisma") {
+    const { addPrismaRelation } = require("../utils/setups/setupPrisma");
+    if (!isDryRun) {
+      await addPrismaRelation(source, target, type);
+      logInfo("   ✔ schema.prisma mis à jour + migration lancée");
+    } else {
+      console.log(`[DRY-RUN] Simulated: addPrismaRelation(${source}, ${target}, ${type})`);
+    }
+  } else if (config.orm === "mongoose") {
+    const { addMongooseRelation } = require("../utils/generators/infrastructure/mongooseSchemaGenerator");
+    if (!isDryRun) {
+      await addMongooseRelation(source, target, type, config.mode);
+      logInfo("   ✔ Schémas Mongoose mis à jour");
+    } else {
+      console.log(`[DRY-RUN] Simulated: addMongooseRelation(${source}, ${target}, ${type})`);
+    }
+  } else if (config.orm === "typeorm") {
+    // TypeORM : patch FK @Column dans les entités src/entities/
+    // Note : les annotations @ManyToOne/@OneToMany doivent être ajoutées manuellement
+    // pour un typage ORM complet — le champ FK est injecté automatiquement.
+    logWarning(
+      "⚠️  TypeORM détecté : le champ FK est injecté dans l'entité source.\n" +
+      "   Pour des annotations ORM complètes (@ManyToOne/@OneToMany), éditez manuellement les entités.",
+    );
+  }
+
+  // 5. Mise à jour de .nestcraftxrc
+  if (!config.relations) config.relations = [];
+  config.relations = config.relations.filter(
+    (r) => !(
+      r.from.toLowerCase() === source &&
+      r.to.toLowerCase() === target &&
+      r.type === type
+    ),
+  );
+  config.relations.push({ from: source, to: target, type });
+
+  const configPath = path.join(process.cwd(), ".nestcraftx", ".nestcraftxrc");
+  if (!isDryRun) {
+    fs.writeFileSync(configPath, JSON.stringify(config, null, 2), "utf8");
+    logInfo("   ✔ .nestcraftxrc mis à jour");
+  }
+
+  // 6. Résumé final
+  logSuccess(
+    `\n✅ Relation ${capitalize(source)} →(${type})→ ${capitalize(target)} créée avec succès !\n` +
+    `\n📋 Résumé :\n` +
+    `  ✔ Entité ${capitalize(target)} : champ FK ajouté\n` +
+    `  ✔ DTO ${capitalize(source)} : ${target}Id ajouté dans CreateDto\n` +
+    `  ✔ Mapper ${capitalize(source)} : toDomain/toPersistence mis à jour\n` +
+    (config.orm === "prisma" ? `  ✔ schema.prisma : champs @relation des deux côtés ajoutés\n` : "") +
+    (config.orm === "mongoose" ? `  ✔ Schémas Mongoose : champs de référence ajoutés\n` : "") +
+    `  ✔ .nestcraftxrc : relation enregistrée`,
+  );
+}
+
+/**
+ * Affiche un rapport de génération complet à la fin du scaffolding d'un module.
+ */
+function printModuleGenerationReport(name, config, entityData) {
+  const { capitalize, decapitalize } = require("../utils/userInput");
+  const entityCap = capitalize(name);
+  const entityLow = decapitalize(name);
+  const isFull = config.mode === "full";
+
+  console.log("\n╔" + "═".repeat(60) + "╗");
+  console.log("║" + " ".repeat(15) + "🏗️  NESTCRAFTX GENERATION REPORT  🏗️" + " ".repeat(11) + "║");
+  console.log("╠" + "═".repeat(60) + "╣");
+
+  console.log(`║  Module generated : ${entityCap}`);
+  console.log(`║  Mode             : ${config.mode.toUpperCase()}`);
+  console.log(`║  ORM / Database   : ${config.orm} / ${config.database}`);
+  console.log("╠" + "═".repeat(60) + "╣");
+
+  console.log("║  📁 Generated Files :");
+  if (isFull) {
+    console.log(`║    • Domain layer :`);
+    console.log(`║       - src/${entityLow}/domain/entities/${entityLow}.entity.ts`);
+    console.log(`║       - src/${entityLow}/domain/interfaces/${entityLow}.repository.interface.ts`);
+    console.log(`║    • Application layer :`);
+    console.log(`║       - src/${entityLow}/application/dtos/${entityLow}.dto.ts`);
+    console.log(`║       - src/${entityLow}/application/services/${entityLow}.service.ts`);
+    console.log(`║       - src/${entityLow}/application/use-cases/create-${entityLow}.use-case.ts`);
+    console.log(`║       - src/${entityLow}/application/use-cases/getById-${entityLow}.use-case.ts`);
+    console.log(`║       - src/${entityLow}/application/use-cases/getAll-${entityLow}.use-case.ts`);
+    console.log(`║       - src/${entityLow}/application/use-cases/update-${entityLow}.use-case.ts`);
+    console.log(`║       - src/${entityLow}/application/use-cases/delete-${entityLow}.use-case.ts`);
+    console.log(`║    • Infrastructure layer :`);
+    console.log(`║       - src/${entityLow}/infrastructure/mappers/${entityLow}.mapper.ts`);
+    console.log(`║       - src/${entityLow}/infrastructure/repositories/${entityLow}.repository.ts`);
+    console.log(`║    • Presentation layer :`);
+    console.log(`║       - src/${entityLow}/presentation/controllers/${entityLow}.controller.ts`);
+    console.log(`║    • Nest Module :`);
+    console.log(`║       - src/${entityLow}/${entityLow}.module.ts`);
+  } else {
+    console.log(`║    • Entities : src/${entityLow}/entities/${entityLow}.entity.ts`);
+    console.log(`║    • DTOs     : src/${entityLow}/dtos/${entityLow}.dto.ts`);
+    console.log(`║    • Services : src/${entityLow}/services/${entityLow}.service.ts`);
+    console.log(`║    • Repos    : src/${entityLow}/repositories/${entityLow}.repository.ts`);
+    console.log(`║    • Control. : src/${entityLow}/controllers/${entityLow}.controller.ts`);
+    console.log(`║    • Module   : src/${entityLow}/${entityLow}.module.ts`);
+  }
+
+  console.log("╠" + "═".repeat(60) + "╣");
+  console.log("║  ⚙️ Integration :");
+  console.log("║    ✔ Registered in src/app.module.ts");
+  console.log(`║    ✔ Database schema updated (${config.orm})`);
+
+  if (entityData.relation) {
+    const { target, type } = entityData.relation;
+    console.log("╠" + "═".repeat(60) + "╣");
+    console.log(`║  🔗 Relation established :`);
+    console.log(`║    • ${entityCap} →(${type})→ ${capitalize(target)}`);
+  }
+
+  console.log("╠" + "═".repeat(60) + "╣");
+  console.log("║  🚀 Next Steps :");
+  console.log(`║    1. Inspect the entity validation rules in the DTO.`);
+  if (config.orm === "prisma") {
+    console.log(`║    2. Run Prisma sync command to update client :`);
+    console.log(`║       - npx prisma format && npx prisma generate`);
+  } else {
+    console.log(`║    2. Review your DB configuration in .env`);
+  }
+  console.log("║    3. Start your dev server :");
+  console.log(`║       - ${config.packageManager || "npm"} run start:dev`);
+
+  console.log("╚" + "═".repeat(60) + "╝\n");
+}
+
 async function handleAuthGeneration(config) {
-  logWarning("nestcraftx g auth n'est pas encore disponible en v0.3 — prévu en v0.7");
+  const isDryRun = process.argv.includes("--dry-run");
+  logInfo("🚀 Initialisation de la configuration de l'Authentification...");
+
+  const isFull = config.mode === "full";
+  const orm = config.orm;
+
+  // Vérifier la présence de l'entité User — si absente, auto-scaffold
+  let userExists = false;
+
+  if (orm === "prisma") {
+    const schemaPath = path.join(process.cwd(), "prisma", "schema.prisma");
+    if (!fs.existsSync(schemaPath)) {
+      logError("Le fichier 'prisma/schema.prisma' est introuvable.");
+      return;
+    }
+    const schemaContent = fs.readFileSync(schemaPath, "utf8");
+    userExists = schemaContent.includes("model User");
+  } else if (orm === "typeorm") {
+    const userEntityPath = path.join(process.cwd(), "src", "entities", "User.entity.ts");
+    userExists = fs.existsSync(userEntityPath);
+  } else if (orm === "mongoose") {
+    const userSchemaPath = isFull
+      ? path.join(process.cwd(), "src", "user", "infrastructure", "persistence", "mongoose", "user.schema.ts")
+      : path.join(process.cwd(), "src", "user", "persistence", "user.schema.ts");
+    userExists = fs.existsSync(userSchemaPath);
+  }
+
+  if (!userExists) {
+    logInfo("⚙️  Entité 'User' absente — création automatique d'un module User minimal...");
+
+    // Construire un entityData minimal pour User (sans champs customs — les champs
+    // auth (email, password, role, isActive) seront ajoutés juste après par le bloc
+    // de mise à jour du schéma, exactement comme pour Session/Otp/PasswordReset)
+    const minimalUserEntity = {
+      name: "User",
+      fields: [
+        {
+          name: "email",
+          type: "string",
+          unique: true,
+          nullable: false,
+          default: null,
+          description: "User email address for login"
+        },
+        {
+          name: "password",
+          type: "string",
+          unique: false,
+          nullable: false,
+          default: null,
+          description: "User password"
+        },
+        {
+          name: "role",
+          type: "string",
+          unique: false,
+          nullable: false,
+          default: "USER",
+          description: "User role in the application"
+        },
+        {
+          name: "isActive",
+          type: "boolean",
+          unique: false,
+          nullable: false,
+          default: "true",
+          description: "Flag indicating whether user is active"
+        }
+      ],
+      relation: null,
+    };
+
+    // Générer le module User via les générateurs existants
+    if (config.mode === "full") {
+      await generateCleanModule("User", config, minimalUserEntity);
+    } else {
+      await lightModuleGenerator(minimalUserEntity, config);
+    }
+
+    // Enregistrer l'entité User dans .nestcraftxrc
+    if (!config.entities) config.entities = [];
+    if (!config.entities.find(e => e.name.toLowerCase() === "user")) {
+      config.entities.push({ name: "User", fields: minimalUserEntity.fields });
+    }
+
+    const configPath = path.join(process.cwd(), ".nestcraftx", ".nestcraftxrc");
+    if (!isDryRun) {
+      fs.writeFileSync(configPath, JSON.stringify(config, null, 2), "utf8");
+    }
+
+    logSuccess("✅ Module User minimal créé avec succès !");
+  }
+  
+  // 1. Mise à jour de .env et .env.example
+  const jwtSecret = generateSecret(64);
+  const jwtRefreshSecret = generateSecret(64);
+  const envPath = path.join(process.cwd(), ".env");
+  const examplePath = path.join(process.cwd(), ".env.example");
+
+  const authEnvBlock = `
+# ------------------------------------------------------------------------------
+# AUTHENTICATION (JWT)
+# ------------------------------------------------------------------------------
+JWT_SECRET=${jwtSecret}
+JWT_REFRESH_SECRET=${jwtRefreshSecret}
+JWT_EXPIRES_IN=15m
+JWT_REFRESH_EXPIRES_IN=7d
+`;
+
+  const authExampleBlock = `
+# ------------------------------------------------------------------------------
+# AUTHENTICATION (JWT)
+# ------------------------------------------------------------------------------
+JWT_SECRET=votre_cle_secrete_ici
+JWT_REFRESH_SECRET=votre_cle_secrete_ici
+JWT_EXPIRES_IN=15m
+JWT_REFRESH_EXPIRES_IN=7d
+`;
+
+  if (fs.existsSync(envPath)) {
+    const envContent = fs.readFileSync(envPath, "utf8");
+    if (!envContent.includes("JWT_SECRET")) {
+      if (isDryRun) {
+        console.log(`[DRY-RUN] Simulated: append JWT secrets to ${envPath}`);
+      } else {
+        fs.appendFileSync(envPath, authEnvBlock, "utf8");
+      }
+    }
+  }
+
+  if (fs.existsSync(examplePath)) {
+    const exampleContent = fs.readFileSync(examplePath, "utf8");
+    if (!exampleContent.includes("JWT_SECRET")) {
+      if (isDryRun) {
+        console.log(`[DRY-RUN] Simulated: append JWT secrets template to ${examplePath}`);
+      } else {
+        fs.appendFileSync(examplePath, authExampleBlock, "utf8");
+      }
+    }
+  }
+
+  // 2. Mise à jour du schéma User et des tables d'Auth selon l'ORM
+  if (orm === "prisma") {
+    const schemaPath = path.join(process.cwd(), "prisma", "schema.prisma");
+    if (fs.existsSync(schemaPath)) {
+      let schemaContent = fs.readFileSync(schemaPath, "utf8");
+      let updated = false;
+
+      // Ajouter l'enum Role si absente
+      if (!schemaContent.includes("enum Role")) {
+        schemaContent += `
+enum Role {
+  USER
+  ADMIN
+  SUPER_ADMIN
+}
+`;
+        updated = true;
+      }
+
+      // Ajouter PasswordReset, Otp, Session si absents
+      if (!schemaContent.includes("model PasswordReset")) {
+        schemaContent += `
+model PasswordReset {
+  id        String   @id @default(uuid())
+  email     String
+  token     String   @unique
+  expiresAt DateTime
+  createdAt DateTime @default(now())
+}
+`;
+        updated = true;
+      }
+
+      if (!schemaContent.includes("model Otp")) {
+        schemaContent += `
+model Otp {
+  id        String   @id @default(uuid())
+  email     String
+  otp       String
+  expiresAt DateTime
+  createdAt DateTime @default(now())
+}
+`;
+        updated = true;
+      }
+
+      if (!schemaContent.includes("model Session")) {
+        schemaContent += `
+model Session {
+  id           String   @id @default(uuid())
+  refreshToken String   @unique
+  userId       String
+  expiresAt    DateTime
+  createdAt    DateTime @default(now())
+  user         User     @relation(fields: [userId], references: [id])
+}
+`;
+        updated = true;
+      }
+
+      // Mettre à jour User
+      const userModelMatch = schemaContent.match(/model User \{([\s\S]*?)\}/);
+      if (userModelMatch) {
+        let userFields = userModelMatch[1];
+        let userUpdated = false;
+
+        if (!userFields.includes("email")) {
+          userFields = `\n  email     String   @unique` + userFields;
+          userUpdated = true;
+        }
+        if (!userFields.includes("password")) {
+          userFields = `\n  password  String` + userFields;
+          userUpdated = true;
+        }
+        if (!userFields.includes("role")) {
+          userFields = `\n  role      Role     @default(USER)` + userFields;
+          userUpdated = true;
+        }
+        if (!userFields.includes("isActive")) {
+          userFields = `\n  isActive  Boolean  @default(true)` + userFields;
+          userUpdated = true;
+        }
+        if (!userFields.includes("sessions")) {
+          userFields = `\n  sessions  Session[]` + userFields;
+          userUpdated = true;
+        }
+
+        if (userUpdated) {
+          schemaContent = schemaContent.replace(/model User \{([\s\S]*?)\}/, `model User {${userFields}}`);
+          updated = true;
+        }
+      }
+
+      if (updated) {
+        if (isDryRun) {
+          console.log(`[DRY-RUN] Simulated: update prisma/schema.prisma with Auth models`);
+        } else {
+          fs.writeFileSync(schemaPath, schemaContent, "utf8");
+          await runCommand("npx prisma format", "Prisma format failed", { critical: false });
+          await runCommand("npx prisma generate", "Prisma generate failed", { critical: false });
+          await runCommand("npx prisma migrate dev --name add_auth", "Prisma migration failed", { critical: false });
+        }
+      }
+    }
+  } else if (orm === "typeorm") {
+    // S'assurer que src/entities/User.entity.ts a les champs requis
+    const userEntityPath = path.join(process.cwd(), "src", "entities", "User.entity.ts");
+    if (fs.existsSync(userEntityPath)) {
+      let content = fs.readFileSync(userEntityPath, "utf8");
+      let updated = false;
+
+      if (!content.includes("email")) {
+        content = content.replace("export class User {", `export class User {\n  @Column({ type: 'varchar', unique: true })\n  email: string;\n`);
+        updated = true;
+      }
+      if (!content.includes("password")) {
+        content = content.replace("export class User {", `export class User {\n  @Column({ type: 'varchar' })\n  password: string;\n`);
+        updated = true;
+      }
+      if (!content.includes("role")) {
+        content = content.replace("export class User {", `export class User {\n  @Column({ type: 'varchar', default: 'USER' })\n  role: string;\n`);
+        updated = true;
+      }
+      if (!content.includes("isActive")) {
+        content = content.replace("export class User {", `export class User {\n  @Column({ type: 'boolean', default: true })\n  isActive: boolean;\n`);
+        updated = true;
+      }
+
+      if (updated) {
+        if (isDryRun) {
+          console.log(`[DRY-RUN] Simulated: update ${userEntityPath} with Auth columns`);
+        } else {
+          fs.writeFileSync(userEntityPath, content, "utf8");
+        }
+      }
+    }
+  } else if (orm === "mongoose") {
+    // S'assurer que le schéma User Mongoose a les champs
+    const userSchemaPath = isFull
+      ? path.join(process.cwd(), "src", "user", "infrastructure", "persistence", "mongoose", "user.schema.ts")
+      : path.join(process.cwd(), "src", "user", "persistence", "user.schema.ts");
+    if (fs.existsSync(userSchemaPath)) {
+      let content = fs.readFileSync(userSchemaPath, "utf8");
+      let updated = false;
+
+      if (!content.includes("email")) {
+        content = content.replace("export class User {", `export class User {\n  @Prop({ required: true, unique: true })\n  email: string;\n`);
+        updated = true;
+      }
+      if (!content.includes("password")) {
+        content = content.replace("export class User {", `export class User {\n  @Prop({ required: true })\n  password: string;\n`);
+        updated = true;
+      }
+      if (!content.includes("role")) {
+        content = content.replace("export class User {", `export class User {\n  @Prop({ required: true, default: 'USER' })\n  role: string;\n`);
+        updated = true;
+      }
+      if (!content.includes("isActive")) {
+        content = content.replace("export class User {", `export class User {\n  @Prop({ required: true, default: true })\n  isActive: boolean;\n`);
+        updated = true;
+      }
+
+      if (updated) {
+        if (isDryRun) {
+          console.log(`[DRY-RUN] Simulated: update ${userSchemaPath} with Auth properties`);
+        } else {
+          fs.writeFileSync(userSchemaPath, content, "utf8");
+        }
+      }
+    }
+  }
+
+  // 3. Appel à setupAuth
+  const { setupAuth } = require("../utils/setups/setupAuth");
+  
+  // Reconstituer l'objet inputs attendu par setupAuth
+  const authInputs = {
+    projectName: config.name,
+    mode: config.mode,
+    selectedDB: config.database,
+    dbConfig: {
+      orm: config.orm
+    },
+    useSwagger: config.swagger,
+    useAuth: true,
+    packageManager: config.packageManager
+  };
+
+  await setupAuth(authInputs);
+
+  // 4. Enregistrer dans AppModule
+  const { safeUpdateAppModule } = require("../utils/app-module.updater");
+  await safeUpdateAppModule("auth");
+
+  // 5. Mettre à jour .nestcraftxrc
+  config.auth = true;
+  const configPath = path.join(process.cwd(), ".nestcraftx", ".nestcraftxrc");
+  if (isDryRun) {
+    console.log(`[DRY-RUN] Simulated: update .nestcraftxrc with auth: true`);
+  } else {
+    fs.writeFileSync(configPath, JSON.stringify(config, null, 2), "utf8");
+  }
+
+  logSuccess("✅ Authentification configurée et déployée avec succès dans le projet !");
 }
 
 module.exports = generate;

package/commands/generateConf.js

@@ -27,14 +27,14 @@ async function generateConf() {
     fs.existsSync(path.join(root, "src", "common", "domain"));
   const mode = isFull ? "full" : "light";
 
-  // 2. Détecter l'ORM
+  // 2. Détecter l'ORM (vérifier les fichiers physiques d'abord, puis les dépendances)
   let orm = "prisma"; // par défaut
-  if (deps["@nestjs/mongoose"] || deps["mongoose"]) {
+  if (fs.existsSync(path.join(root, "prisma"))) {
+    orm = "prisma";
+  } else if (deps["@nestjs/mongoose"] || deps["mongoose"]) {
     orm = "mongoose";
   } else if (deps["@nestjs/typeorm"] || deps["typeorm"]) {
     orm = "typeorm";
-  } else if (fs.existsSync(path.join(root, "prisma"))) {
-    orm = "prisma";
   }
 
   // 3. Détecter les options

package/commands/help.js

@@ -59,6 +59,17 @@ async function helpCommand() {
           --auth           Adds JWT Auth
           --swagger        Adds Swagger UI
 
+      nestcraftx generate, g <subcommand> [target]
+        Generates modules or auth post-scaffolding
+        Subcommands:
+          module <name>   Generates a new module (MVP or Clean Architecture)
+          auth            Enables JWT Auth on an existing project
+          relation, r     Creates a relation between two existing modules
+                          (interactive: select source, target, and relation type)
+
+      nestcraftx list, l
+        Lists all scaffolded entities and their relationships
+
       nestcraftx test
         Checks system environment (Node, npm, Nest CLI, Docker, etc.)
 

package/commands/info.js

@@ -27,11 +27,10 @@ async function infoCommand() {
   console.log("   " + packageJson.repository.url);
 
   console.log("\n📅 Upcoming:");
-  console.log("   • Custom Middlewares");
+  console.log("   • MySQL & SQLite support");
+  console.log("   • Custom templates from GitHub");
   console.log("   • Microservices support");
-  console.log("   • CI/CD Templates");
   console.log("   • GraphQL integration");
-  console.log("   • Automated Tests");
 
   console.log("\n💡 Available Commands:");
   console.log("   nestcraftx new <name> [options]  Create a project");