@tndhuy/create-app 1.0.0 → 1.1.4

package/dist/cli.js

@@ -26,6 +26,8 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 // src/cli.ts
 var import_prompts = require("@clack/prompts");
 var import_path3 = require("path");
+var import_promises3 = require("fs/promises");
+var import_execa = require("execa");
 
 // src/scaffold.ts
 var import_promises2 = require("fs/promises");
@@ -185,8 +187,8 @@ async function replaceFileContents(dir, replacements) {
 async function renamePathsWithPlaceholders(dir, replacements) {
   const allPaths = await collectPaths(dir);
   allPaths.sort((a, b) => {
-    const depthA = a.split("/").length;
-    const depthB = b.split("/").length;
+    const depthA = a.split(import_path2.sep).length;
+    const depthB = b.split(import_path2.sep).length;
     return depthB - depthA;
   });
   for (const oldPath of allPaths) {
@@ -214,17 +216,39 @@ async function patchPackageJson(destDir, options) {
     const raw = await (0, import_promises2.readFile)(pkgPath, "utf-8");
     const pkg = JSON.parse(raw);
     pkg.name = options.serviceName;
+    const PRISMA_LATEST = "^7.5.0";
+    const PRISMA_MONGO_COMPAT = "^6.0.0";
     if (options.db === "mongo") {
+      if (options.orm === "prisma") {
+        if (pkg.dependencies) {
+          delete pkg.dependencies["@prisma/adapter-pg"];
+          delete pkg.dependencies["pg"];
+          delete pkg.dependencies["@types/pg"];
+          pkg.dependencies["@prisma/client"] = PRISMA_MONGO_COMPAT;
+        }
+        if (pkg.devDependencies) {
+          pkg.devDependencies["prisma"] = PRISMA_MONGO_COMPAT;
+        }
+      } else {
+        if (pkg.dependencies) {
+          delete pkg.dependencies["@prisma/client"];
+          delete pkg.dependencies["@prisma/adapter-pg"];
+          delete pkg.dependencies["pg"];
+          delete pkg.dependencies["@types/pg"];
+          pkg.dependencies["mongoose"] = "^8.0.0";
+          pkg.dependencies["@nestjs/mongoose"] = "^11.0.0";
+        }
+        if (pkg.devDependencies) {
+          delete pkg.devDependencies["prisma"];
+        }
+      }
+    } else {
       if (pkg.dependencies) {
-        delete pkg.dependencies["@prisma/client"];
-        delete pkg.dependencies["@prisma/adapter-pg"];
-        delete pkg.dependencies["pg"];
-        delete pkg.dependencies["@types/pg"];
-        pkg.dependencies["mongoose"] = "^8.0.0";
-        pkg.dependencies["@nestjs/mongoose"] = "^11.0.0";
+        pkg.dependencies["@prisma/client"] = PRISMA_LATEST;
+        pkg.dependencies["@prisma/adapter-pg"] = PRISMA_LATEST;
       }
       if (pkg.devDependencies) {
-        delete pkg.devDependencies["prisma"];
+        pkg.devDependencies["prisma"] = PRISMA_LATEST;
       }
     }
     if (options.modules.includes("kafka")) {
@@ -263,7 +287,8 @@ async function pathExists(p) {
 async function safeDeleteFile(destDir, filePath) {
   const resolved = (0, import_path2.resolve)(filePath);
   const resolvedDestDir = (0, import_path2.resolve)(destDir);
-  if (!resolved.startsWith(resolvedDestDir + "/") && resolved !== resolvedDestDir) {
+  const prefix = resolvedDestDir.endsWith(import_path2.sep) ? resolvedDestDir : resolvedDestDir + import_path2.sep;
+  if (!resolved.startsWith(prefix) && resolved !== resolvedDestDir) {
     throw new Error(`Security: path '${filePath}' is outside destDir '${destDir}'`);
   }
   try {
@@ -274,7 +299,8 @@ async function safeDeleteFile(destDir, filePath) {
 async function safeDeleteDir(destDir, dirPath) {
   const resolved = (0, import_path2.resolve)(dirPath);
   const resolvedDestDir = (0, import_path2.resolve)(destDir);
-  if (!resolved.startsWith(resolvedDestDir + "/") && resolved !== resolvedDestDir) {
+  const prefix = resolvedDestDir.endsWith(import_path2.sep) ? resolvedDestDir : resolvedDestDir + import_path2.sep;
+  if (!resolved.startsWith(prefix) && resolved !== resolvedDestDir) {
     throw new Error(`Security: path '${dirPath}' is outside destDir '${destDir}'`);
   }
   try {
@@ -402,8 +428,8 @@ $1`
           /(imports:\s*\[[^\]]*?)(\s*\])/s,
           (match, arrayContent, closing) => {
             const trimmed = arrayContent.trimEnd();
-            const sep = trimmed.endsWith(",") ? "" : ",";
-            return `${trimmed}${sep}
+            const sep2 = trimmed.endsWith(",") ? "" : ",";
+            return `${trimmed}${sep2}
     KafkaModule,${closing}`;
           }
         );
@@ -425,13 +451,50 @@ $1`
   }
 }
 async function scaffold(options) {
-  const templateDir = (0, import_path2.join)(__dirname, "..", "templates", options.db);
-  const { destDir, serviceName, modules } = options;
+  const templateName = options.orm === "prisma" ? "postgres" : options.db;
+  const templateDir = (0, import_path2.join)(__dirname, "..", "templates", templateName);
+  const { destDir, serviceName, modules, dryRun } = options;
+  if (dryRun) {
+    console.log(`
+  [Dry Run] Would copy template from ${templateName} to ${destDir}`);
+    console.log(`  [Dry Run] Would replace placeholders for: ${serviceName}`);
+    console.log(`  [Dry Run] Would apply modules: ${modules.join(", ") || "none"}
+`);
+    return;
+  }
   await (0, import_promises2.cp)(templateDir, destDir, { recursive: true });
   const replacements = buildReplacements(serviceName);
   await replaceFileContents(destDir, replacements);
   await renamePathsWithPlaceholders(destDir, replacements);
   await patchPackageJson(destDir, options);
+  if (options.db === "mongo" && options.orm === "prisma") {
+    const schemaPath = (0, import_path2.join)(destDir, "prisma", "schema.prisma");
+    if (await pathExists(schemaPath)) {
+      try {
+        let content = await (0, import_promises2.readFile)(schemaPath, "utf-8");
+        content = content.replace(/provider\s*=\s*["']postgresql["']/g, 'provider = "mongodb"');
+        content = content.replace(
+          /id\s+String\s+@id/g,
+          'id String @id @default(auto()) @map("_id") @db.ObjectId'
+        );
+        await (0, import_promises2.writeFile)(schemaPath, content, "utf-8");
+      } catch (err) {
+        console.warn("Warning: Could not update schema.prisma for MongoDB:", err);
+      }
+    }
+    const envPath = (0, import_path2.join)(destDir, ".env.example");
+    if (await pathExists(envPath)) {
+      try {
+        let content = await (0, import_promises2.readFile)(envPath, "utf-8");
+        content = content.replace(
+          /DATABASE_URL=postgresql:\/\/.*/g,
+          'DATABASE_URL="mongodb+srv://user:password@cluster.mongodb.net/myDatabase?retryWrites=true&w=majority"'
+        );
+        await (0, import_promises2.writeFile)(envPath, content, "utf-8");
+      } catch {
+      }
+    }
+  }
   if (!modules.includes("redis")) {
     await removeRedis(destDir);
   }
@@ -451,81 +514,213 @@ function guardCancel(value) {
   }
   return value;
 }
+async function directoryExists(p) {
+  try {
+    await (0, import_promises3.stat)(p);
+    return true;
+  } catch {
+    return false;
+  }
+}
 async function main() {
-  (0, import_prompts.intro)("create-app -- NestJS DDD scaffolder");
-  const argName = process.argv[2];
-  let serviceName;
-  if (argName && !validateServiceName(argName)) {
-    serviceName = argName;
-    console.log(`  Service name : ${serviceName} (from arguments)`);
-  } else {
-    serviceName = guardCancel(
-      await (0, import_prompts.text)({
-        message: "Service name (kebab-case)",
-        placeholder: "my-service",
-        validate: (v) => validateServiceName(v)
-      })
-    );
-  }
-  const db = guardCancel(
-    await (0, import_prompts.select)({
-      message: "Select database",
-      options: [
-        { value: "postgres", label: "PostgreSQL", hint: "default" },
-        { value: "mongo", label: "MongoDB" }
-      ]
-    })
-  );
-  const modules = guardCancel(
-    await (0, import_prompts.multiselect)({
-      message: "Optional modules (space to toggle, enter to confirm)",
-      options: [
-        { value: "redis", label: "Redis", hint: "caching + circuit breaker" },
-        { value: "otel", label: "OpenTelemetry", hint: "traces + metrics" },
-        { value: "kafka", label: "Kafka", hint: "message broker boilerplate" }
-      ],
-      required: false
-    })
-  );
-  const selectedModules = modules.length > 0 ? modules.join(", ") : "none";
-  console.log("");
-  console.log(`  Service name : ${serviceName}`);
-  console.log(`  Database     : ${db}`);
-  console.log(`  Modules      : ${selectedModules}`);
-  console.log("");
-  const proceed = guardCancel(
-    await (0, import_prompts.confirm)({
-      message: "Scaffold project with these settings?",
-      initialValue: true
-    })
-  );
-  if (!proceed) {
-    (0, import_prompts.cancel)("Scaffolding cancelled.");
-    process.exit(0);
+  const args = process.argv.slice(2);
+  const dryRun = args.includes("--dry-run");
+  const positionalName = args.find((a) => !a.startsWith("--"));
+  (0, import_prompts.intro)("create-app -- NestJS DDD scaffolder" + (dryRun ? " [DRY RUN]" : ""));
+  const config = {
+    serviceName: "",
+    db: "postgres",
+    orm: "mongoose",
+    modules: []
+  };
+  if (positionalName && !validateServiceName(positionalName)) {
+    config.serviceName = positionalName;
+  }
+  let step = config.serviceName ? 1 : 0;
+  const totalSteps = 4;
+  while (step < totalSteps) {
+    switch (step) {
+      case 0: {
+        const res = guardCancel(
+          await (0, import_prompts.text)({
+            message: "Service name (kebab-case)",
+            placeholder: "my-service",
+            validate: (v) => validateServiceName(v)
+          })
+        );
+        config.serviceName = res;
+        step++;
+        break;
+      }
+      case 1: {
+        const res = guardCancel(
+          await (0, import_prompts.select)({
+            message: "Select database",
+            options: [
+              { value: "postgres", label: "PostgreSQL", hint: "using Prisma" },
+              { value: "mongo", label: "MongoDB", hint: "choice of Mongoose or Prisma" },
+              { value: "_back", label: "Go Back", hint: "return to service name" }
+            ]
+          })
+        );
+        if (res === "_back") {
+          step--;
+        } else {
+          config.db = res;
+          if (res === "mongo") {
+            config.orm = guardCancel(
+              await (0, import_prompts.select)({
+                message: "Select MongoDB ORM",
+                options: [
+                  { value: "mongoose", label: "Mongoose", hint: "default for NestJS" },
+                  { value: "prisma", label: "Prisma", hint: "v6 compatible mode" }
+                ]
+              })
+            );
+          } else {
+            config.orm = "prisma";
+          }
+          step++;
+        }
+        break;
+      }
+      case 2: {
+        const res = guardCancel(
+          await (0, import_prompts.multiselect)({
+            message: "Optional modules (space to toggle, enter to confirm)",
+            options: [
+              { value: "redis", label: "Redis", hint: "caching + circuit breaker" },
+              { value: "otel", label: "OpenTelemetry", hint: "traces + metrics" },
+              { value: "kafka", label: "Kafka", hint: "message broker boilerplate" },
+              { value: "_back", label: "Go Back", hint: "return to database selection" }
+            ],
+            required: false
+          })
+        );
+        if (res.includes("_back")) {
+          step--;
+        } else {
+          config.modules = res;
+          step++;
+        }
+        break;
+      }
+      case 3: {
+        const selectedModules = config.modules.length > 0 ? config.modules.join(", ") : "none";
+        (0, import_prompts.note)(
+          `Service name : ${config.serviceName}
+Database     : ${config.db}
+ORM          : ${config.orm}
+Modules      : ${selectedModules}`,
+          "Confirm Project Summary"
+        );
+        const res = guardCancel(
+          await (0, import_prompts.select)({
+            message: "Scaffold project with these settings?",
+            options: [
+              { value: "confirm", label: "Yes, scaffold project" },
+              { value: "back", label: "No, let me change something", hint: "go back" },
+              { value: "cancel", label: "Cancel", hint: "exit" }
+            ]
+          })
+        );
+        if (res === "confirm") {
+          const destDir2 = (0, import_path3.join)(process.cwd(), config.serviceName);
+          if (await directoryExists(destDir2) && !dryRun) {
+            const overwrite = guardCancel(
+              await (0, import_prompts.select)({
+                message: `Directory "${config.serviceName}" already exists.`,
+                options: [
+                  { value: "overwrite", label: "Overwrite", hint: "danger: deletes existing directory" },
+                  { value: "back", label: "Change service name", hint: "go back to step 1" },
+                  { value: "cancel", label: "Exit", hint: "cancel" }
+                ]
+              })
+            );
+            if (overwrite === "overwrite") {
+              const confirmDelete = guardCancel(await (0, import_prompts.confirm)({ message: "Are you absolutely sure?", initialValue: false }));
+              if (confirmDelete) {
+                const s2 = (0, import_prompts.spinner)();
+                s2.start("Cleaning up existing directory...");
+                await (0, import_promises3.rm)(destDir2, { recursive: true, force: true });
+                s2.stop("Directory cleaned.");
+                step++;
+              }
+            } else if (overwrite === "back") {
+              step = 0;
+            } else {
+              (0, import_prompts.cancel)("Operation cancelled.");
+              process.exit(0);
+            }
+          } else {
+            step++;
+          }
+        } else if (res === "back") {
+          step--;
+        } else {
+          (0, import_prompts.cancel)("Scaffolding cancelled.");
+          process.exit(0);
+        }
+        break;
+      }
+    }
   }
-  const destDir = (0, import_path3.join)(process.cwd(), serviceName);
+  const destDir = (0, import_path3.join)(process.cwd(), config.serviceName);
   const s = (0, import_prompts.spinner)();
   s.start("Scaffolding project...");
   try {
     await scaffold({
-      serviceName,
-      db,
-      modules,
-      destDir
+      serviceName: config.serviceName,
+      db: config.db,
+      orm: config.orm,
+      modules: config.modules,
+      destDir,
+      dryRun
     });
     s.stop("Project scaffolded!");
   } catch (err) {
     s.stop("Scaffolding failed.");
     throw err;
   }
+  if (!dryRun) {
+    const initGit = guardCancel(await (0, import_prompts.confirm)({ message: "Initialize git repository?", initialValue: true }));
+    if (initGit) {
+      const gs = (0, import_prompts.spinner)();
+      gs.start("Initializing git...");
+      try {
+        await (0, import_execa.execa)("git", ["init"], { cwd: destDir });
+        await (0, import_execa.execa)("git", ["add", "."], { cwd: destDir });
+        await (0, import_execa.execa)("git", ["commit", "-m", "chore: initial commit from template"], { cwd: destDir });
+        gs.stop("Git initialized with initial commit.");
+      } catch (err) {
+        gs.stop("Git initialization failed (check if git is installed).");
+      }
+    }
+    const installDeps = guardCancel(await (0, import_prompts.confirm)({ message: "Install dependencies now?", initialValue: true }));
+    if (installDeps) {
+      const pkgManager = guardCancel(await (0, import_prompts.select)({
+        message: "Select package manager",
+        options: [
+          { value: "pnpm", label: "pnpm", hint: "recommended" },
+          { value: "npm", label: "npm" },
+          { value: "yarn", label: "yarn" }
+        ]
+      }));
+      const is = (0, import_prompts.spinner)();
+      is.start(`Installing dependencies using ${pkgManager}...`);
+      try {
+        await (0, import_execa.execa)(pkgManager, ["install"], { cwd: destDir, stdio: "inherit" });
+        is.stop("Dependencies installed successfully.");
+      } catch (err) {
+        is.stop("Dependency installation failed.");
+      }
+    }
+  }
   (0, import_prompts.outro)(
     `Next steps:
 
-  cd ${serviceName}
-  npm install
-  cp .env.example .env
-  npm run start:dev
-`
+  cd ${config.serviceName}
+${dryRun ? "" : "  npm run start:dev\n"}`
   );
 }
 main().catch((err) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tndhuy/create-app",
-  "version": "1.0.0",
+  "version": "1.1.4",
   "private": false,
   "bin": {
     "create-app": "dist/cli.js"

package/templates/postgres/prisma/schema.prisma

@@ -4,6 +4,7 @@ generator client {
 
 datasource db {
   provider = "postgresql"
+  url      = env("DATABASE_URL")
 }
 
 model Item {