create-charcole 2.0.4 → 2.2.0

package/bin/index.js

@@ -1,26 +1,116 @@
-#!/usr/bin/env node
+#!/usr/bin/env node
 
 const path = require("path");
 const fs = require("fs");
-const { execSync } = require("child_process");
 const prompts = require("prompts");
-const { copyTemplateModules } = require("./lib/templateHandler");
+
 const {
   detectPackageManager,
   installDependencies,
 } = require("./lib/pkgManager");
 
+/**
+ * Merge base package.json with a feature package.json
+ */
+function mergePackageJson(base, fragment) {
+  const merged = { ...base };
+
+  // Merge dependencies
+  if (fragment.dependencies) {
+    merged.dependencies = {
+      ...merged.dependencies,
+      ...fragment.dependencies,
+    };
+  }
+
+  // Merge devDependencies
+  if (fragment.devDependencies) {
+    merged.devDependencies = {
+      ...merged.devDependencies,
+      ...fragment.devDependencies,
+    };
+  }
+
+  // Merge scripts
+  if (fragment.scripts) {
+    merged.scripts = {
+      ...merged.scripts,
+      ...fragment.scripts,
+    };
+  }
+
+  return merged;
+}
+
+function copyDirRecursive(src, dest, excludeFiles = [], excludeDirs = []) {
+  if (!fs.existsSync(src)) return;
+
+  if (!fs.existsSync(dest)) {
+    fs.mkdirSync(dest, { recursive: true });
+  }
+
+  const entries = fs.readdirSync(src, { withFileTypes: true });
+
+  for (const entry of entries) {
+    const srcPath = path.join(src, entry.name);
+    const destPath = path.join(dest, entry.name);
+
+    // Skip excluded files
+    if (excludeFiles.includes(entry.name)) {
+      console.log(`Skipping excluded file: ${entry.name}`);
+      continue;
+    }
+
+    // Skip .tgz files (tarball packages)
+    if (entry.name.endsWith(".tgz")) {
+      console.log(`Skipping tarball: ${entry.name}`);
+      continue;
+    }
+
+    if (entry.isDirectory()) {
+      // Skip excluded directories
+      if (excludeDirs.includes(entry.name)) {
+        console.log(`Skipping excluded directory: ${entry.name}`);
+        continue;
+      }
+      copyDirRecursive(srcPath, destPath, excludeFiles, excludeDirs);
+    } else {
+      fs.copyFileSync(srcPath, destPath);
+    }
+  }
+}
+
 (async function main() {
   try {
-    console.log("🔥 Welcome to Charcole v2 CLI");
+    console.log("🔥 Welcome to Charcole v2.2 CLI");
 
-    const responses = await prompts([
-      {
+    // Check if project name is provided as command line argument
+    const args = process.argv.slice(2);
+    let projectNameFromArgs = null;
+
+    if (args.length > 0) {
+      // The first argument that doesn't start with '-' is likely the project name
+      for (const arg of args) {
+        if (!arg.startsWith("-")) {
+          projectNameFromArgs = arg;
+          break;
+        }
+      }
+    }
+
+    const questions = [];
+
+    // Only ask for project name if not provided in command line
+    if (!projectNameFromArgs) {
+      questions.push({
         type: "text",
         name: "projectName",
         message: "Project name:",
         validate: (name) => (name ? true : "Project name is required"),
-      },
+      });
+    }
+
+    questions.push(
       {
         type: "select",
         name: "language",
@@ -29,25 +119,32 @@ const {
           { title: "TypeScript", value: "ts" },
           { title: "JavaScript", value: "js" },
         ],
-        initial: 0,
       },
-      // TODO: Uncomment when features are implemented
-      // {
-      //   type: "multiselect",
-      //   name: "features",
-      //   message: "Select features to include:",
-      //   choices: [
-      //     { title: "JWT Authentication", value: "auth" },
-      //     { title: "Swagger Docs", value: "swagger", selected: true },
-      //     { title: "Docker Support", value: "docker" },
-      //     { title: "ESLint + Prettier", value: "lint", selected: true },
-      //   ],
-      //   min: 0,
-      // },
-    ]);
-
-    const { projectName, language } = responses;
-    const features = []; // Empty for now, will be responses.features later
+      {
+        type: "confirm",
+        name: "auth",
+        message: "Include JWT authentication module?",
+        initial: true,
+      },
+      {
+        type: "confirm",
+        name: "swagger",
+        message: "Include auto-generated Swagger documentation?",
+        initial: true,
+      },
+    );
+
+    const responses = await prompts(questions);
+
+    // Use command line project name if provided, otherwise use prompt response
+    const projectName = projectNameFromArgs || responses.projectName;
+    const { language, auth, swagger } = responses;
+
+    if (!projectName || projectName.trim() === "") {
+      console.error("❌ Project name is required");
+      process.exit(1);
+    }
+
     const targetDir = path.join(process.cwd(), projectName);
 
     if (fs.existsSync(targetDir)) {
@@ -56,52 +153,292 @@ const {
     }
 
     const pkgManager = detectPackageManager();
+    const templateDir = path.join(__dirname, "..", "template", language);
 
-    console.log(`\n📁 Creating project in ${language.toUpperCase()}...`);
+    console.log(
+      `\n📁 Creating project "${projectName}" in ${language.toUpperCase()}...`,
+    );
 
-    // Template directory is template/js or template/ts
-    const templateDir = path.join(__dirname, "..", "template", language);
+    fs.mkdirSync(targetDir, { recursive: true });
+
+    const basePkgPath = path.join(templateDir, "basePackage.json");
+    if (!fs.existsSync(basePkgPath)) {
+      throw new Error(`basePackage.json not found at ${basePkgPath}`);
+    }
 
-    copyTemplateModules(templateDir, targetDir, features);
+    let mergedPkg = JSON.parse(fs.readFileSync(basePkgPath, "utf-8"));
+    console.log("✓ Loaded base package configuration");
 
-    // basePackage.json is directly in template/js or template/ts
-    const basePkg = JSON.parse(
-      fs.readFileSync(path.join(templateDir, "basePackage.json")),
-    );
-    let mergedPkg = { ...basePkg };
-
-    // TODO: Uncomment when features are implemented
-    // features.forEach((f) => {
-    //   const fragPath = path.join(templateDir, "modules", f, "package.json");
-    //   if (fs.existsSync(fragPath)) {
-    //     const frag = JSON.parse(fs.readFileSync(fragPath));
-    //     mergedPkg.dependencies = {
-    //       ...mergedPkg.dependencies,
-    //       ...frag.dependencies,
-    //     };
-    //     mergedPkg.devDependencies = {
-    //       ...mergedPkg.devDependencies,
-    //       ...frag.devDependencies,
-    //     };
-    //     mergedPkg.scripts = { ...mergedPkg.scripts, ...frag.scripts };
-    //   }
-    // });
+    console.log("\n📁 Copying base template structure...");
+
+    // Exclude basePackage.json and swagger module directory from initial copy
+    // We'll handle modules separately based on user selection
+    const srcModulesDir = path.join(templateDir, "src", "modules");
+
+    // Copy everything except basePackage.json and the modules directory
+    copyDirRecursive(templateDir, targetDir, ["basePackage.json"], ["modules"]);
+
+    // Now handle modules directory manually
+    const templateModulesDir = srcModulesDir;
+    const targetModulesDir = path.join(targetDir, "src", "modules");
+
+    if (fs.existsSync(templateModulesDir)) {
+      if (!fs.existsSync(targetModulesDir)) {
+        fs.mkdirSync(targetModulesDir, { recursive: true });
+      }
+
+      const moduleEntries = fs.readdirSync(templateModulesDir, {
+        withFileTypes: true,
+      });
+
+      for (const entry of moduleEntries) {
+        if (entry.isDirectory()) {
+          const moduleName = entry.name;
+          const moduleSrcPath = path.join(templateModulesDir, moduleName);
+
+          if (moduleName === "auth") {
+            if (!auth) {
+              console.log(`⏭️  Skipping auth module (not selected)`);
+              continue;
+            }
+          } else if (moduleName === "swagger") {
+            if (!swagger) {
+              console.log(`⏭️  Skipping swagger module (not selected)`);
+              continue;
+            } else {
+              // Do not copy swagger module folder, just merge package.json below
+              console.log(
+                `⏭️  Not copying swagger module folder (merging dependencies only)`,
+              );
+              continue;
+            }
+          } else {
+            const moduleDestPath = path.join(targetModulesDir, moduleName);
+            console.log(`📦 Copying ${moduleName} module...`);
+            // Exclude package.json files from module folders
+            copyDirRecursive(moduleSrcPath, moduleDestPath, ["package.json"]);
+          }
+        }
+      }
+    }
+    // Handle Swagger module if selected
+    if (swagger) {
+      console.log("\n📦 Adding Swagger module dependencies...");
+      const swaggerModuleDir = path.join(
+        templateDir,
+        "src",
+        "modules",
+        "swagger",
+      );
+      const swaggerPkgPath = path.join(swaggerModuleDir, "package.json");
+      const swaggerTgzPath = path.join(
+        swaggerModuleDir,
+        "charcole-swagger-1.0.0.tgz",
+      );
+
+      // Copy tarball temporarily for npm install (will be cleaned up after)
+      if (fs.existsSync(swaggerTgzPath)) {
+        fs.copyFileSync(
+          swaggerTgzPath,
+          path.join(targetDir, "charcole-swagger-1.0.0.tgz"),
+        );
+        console.log("✓ Copied Swagger tarball temporarily for installation");
+      } else {
+        console.error("❌ Swagger tarball not found at:", swaggerTgzPath);
+      }
+
+      if (fs.existsSync(swaggerPkgPath)) {
+        try {
+          const swaggerPkg = JSON.parse(
+            fs.readFileSync(swaggerPkgPath, "utf-8"),
+          );
+          mergedPkg = mergePackageJson(mergedPkg, swaggerPkg);
+          console.log("✓ Merged Swagger module dependencies");
+          console.log(
+            "  Added dependencies:",
+            Object.keys(swaggerPkg.dependencies || {}).join(", "),
+          );
+          if (swaggerPkg.devDependencies) {
+            console.log(
+              "  Added devDependencies:",
+              Object.keys(swaggerPkg.devDependencies).join(", "),
+            );
+          }
+        } catch (error) {
+          console.error(
+            `❌ Failed to parse Swagger module package.json:`,
+            error.message,
+          );
+        }
+      } else {
+        console.error(
+          "❌ Swagger module package.json not found at:",
+          swaggerPkgPath,
+        );
+      }
+    }
+
+    // Handle JWT authentication module if selected
+    if (auth) {
+      console.log("\n📦 Adding JWT authentication module...");
+
+      // The auth module is in src/modules/auth in the template
+      const authModulePath = path.join(templateDir, "src", "modules", "auth");
+
+      if (!fs.existsSync(authModulePath)) {
+        console.error(`❌ Auth module not found at ${authModulePath}`);
+      } else {
+        // 1. Merge auth module's package.json
+        const authPkgPath = path.join(authModulePath, "package.json");
+
+        if (fs.existsSync(authPkgPath)) {
+          try {
+            const authPkg = JSON.parse(fs.readFileSync(authPkgPath, "utf-8"));
+            console.log("✓ Found auth module package.json");
+
+            mergedPkg = mergePackageJson(mergedPkg, authPkg);
+            console.log("✓ Merged auth module dependencies");
+            console.log(
+              "  Added dependencies:",
+              Object.keys(authPkg.dependencies || {}).join(", "),
+            );
+            if (authPkg.devDependencies) {
+              console.log(
+                "  Added devDependencies:",
+                Object.keys(authPkg.devDependencies).join(", "),
+              );
+            }
+          } catch (error) {
+            console.error(
+              `❌ Failed to parse auth module package.json:`,
+              error.message,
+            );
+          }
+        } else {
+          console.error(
+            "❌ Auth module package.json not found at:",
+            authPkgPath,
+          );
+        }
+
+        const targetAuthPath = path.join(targetModulesDir, "auth");
+        console.log(
+          `Copying auth module to: ${targetAuthPath} (excluding package.json)`,
+        );
+
+        copyDirRecursive(authModulePath, targetAuthPath, ["package.json"], []);
+        console.log("✓ Copied auth module files (package.json was excluded)");
+
+        const copiedPkgPath = path.join(targetAuthPath, "package.json");
+        if (fs.existsSync(copiedPkgPath)) {
+          console.warn(
+            "⚠️ package.json was accidentally copied, removing it...",
+          );
+          fs.unlinkSync(copiedPkgPath);
+        }
+      }
+    } else {
+      console.log("\n⏭️  Skipping JWT authentication module");
+
+      const targetAuthPath = path.join(targetDir, "src", "modules", "auth");
+      if (fs.existsSync(targetAuthPath)) {
+        console.log("Cleaning up auth directory (not selected)...");
+        fs.rmSync(targetAuthPath, { recursive: true, force: true });
+      }
+    }
+
+    // Remove Swagger imports and setup from app file if not selected
+    if (!swagger) {
+      console.log("\n🧹 Removing Swagger references from app file...");
+      const appFileName = language === "ts" ? "app.ts" : "app.js";
+      const appFilePath = path.join(targetDir, "src", appFileName);
+
+      if (fs.existsSync(appFilePath)) {
+        let appContent = fs.readFileSync(appFilePath, "utf-8");
+
+        // Remove swagger-related imports
+        const swaggerConfigImport =
+          language === "ts"
+            ? 'import swaggerOptions from "./config/swagger.config";'
+            : 'import swaggerOptions from "./config/swagger.config.js";';
+        const setupSwaggerImport =
+          'import { setupSwagger } from "@charcoles/swagger";';
+
+        appContent = appContent
+          .split("\n")
+          .filter((line) => {
+            const trimmedLine = line.trim();
+            return (
+              !trimmedLine.includes(swaggerConfigImport.trim()) &&
+              !trimmedLine.includes(setupSwaggerImport.trim()) &&
+              !trimmedLine.includes("setupSwagger(app, swaggerOptions);")
+            );
+          })
+          .join("\n");
+
+        fs.writeFileSync(appFilePath, appContent, "utf-8");
+        console.log(`✓ Removed Swagger references from ${appFileName}`);
+      }
+
+      // Remove swagger config file
+      const swaggerConfigFile =
+        language === "ts" ? "swagger.config.ts" : "swagger.config.js";
+      const swaggerConfigPath = path.join(
+        targetDir,
+        "src",
+        "config",
+        swaggerConfigFile,
+      );
+      if (fs.existsSync(swaggerConfigPath)) {
+        fs.unlinkSync(swaggerConfigPath);
+        console.log(`✓ Removed ${swaggerConfigFile}`);
+      }
+
+      // Remove lib/swagger directory
+      const swaggerLibPath = path.join(targetDir, "src", "lib", "swagger");
+      if (fs.existsSync(swaggerLibPath)) {
+        fs.rmSync(swaggerLibPath, { recursive: true, force: true });
+        console.log("✓ Removed lib/swagger directory");
+      }
+    }
 
     mergedPkg.name = projectName;
-    fs.writeFileSync(
-      path.join(targetDir, "package.json"),
-      JSON.stringify(mergedPkg, null, 2),
+
+    const finalPkgPath = path.join(targetDir, "package.json");
+    fs.writeFileSync(finalPkgPath, JSON.stringify(mergedPkg, null, 2));
+    console.log(`\n📝 Created package.json at ${finalPkgPath}`);
+
+    console.log("\n📦 Final package.json dependencies:");
+    console.log(
+      "  dependencies:",
+      Object.keys(mergedPkg.dependencies || {}).join(", "),
+    );
+    console.log(
+      "  devDependencies:",
+      Object.keys(mergedPkg.devDependencies || {}).join(", "),
     );
 
     console.log(`\n📦 Installing dependencies using ${pkgManager}...`);
     installDependencies(targetDir, pkgManager);
 
+    // Clean up the swagger tarball after installation
+    if (swagger) {
+      const tgzPath = path.join(targetDir, "charcole-swagger-1.0.0.tgz");
+      if (fs.existsSync(tgzPath)) {
+        fs.unlinkSync(tgzPath);
+        console.log("✓ Cleaned up temporary Swagger tarball");
+      }
+    }
+
     console.log("\n✅ Charcole project created successfully!");
     console.log(
-      `\n🚀 Next steps:\n  cd ${projectName}\n  ${pkgManager === "npm" ? "npm run dev" : `${pkgManager} dev`}`,
+      `\n🚀 Next steps:\n  cd ${projectName}\n  ${
+        pkgManager === "npm" ? "npm run dev" : `${pkgManager} run dev`
+      }`,
     );
   } catch (err) {
     console.error("❌ Failed to create Charcole project:", err.message);
+    console.error(err.stack);
     process.exit(1);
   }
 })();

package/bin/lib/pkgManager.js

@@ -5,7 +5,6 @@ const path = require("path");
 /**
  * Detect which package manager the user is using
  * Priority: pnpm > yarn > npm
- * @returns {string} - Package manager name ('pnpm', 'yarn', or 'npm')
  */
 function detectPackageManager() {
   const userAgent = process.env.npm_config_user_agent;
@@ -28,36 +27,20 @@ function detectPackageManager() {
     }
   }
 
-  const installedManagers = ["pnpm", "yarn", "npm"].filter((manager) => {
-    try {
-      execSync(`${manager} --version`, { stdio: "ignore" });
-      return true;
-    } catch {
-      return false;
-    }
-  });
-
-  return installedManagers[0] || "npm";
+  return "npm";
 }
 
 /**
- * Install dependencies using the detected package manager
- * @param {string} targetDir - Project directory where package.json exists
- * @param {string} pkgManager - Package manager to use ('pnpm', 'yarn', or 'npm')
+ * Install dependencies
  */
 function installDependencies(targetDir, pkgManager) {
-  try {
-    const installCmd =
-      pkgManager === "yarn" ? "yarn install" : `${pkgManager} install`;
+  const installCmd =
+    pkgManager === "yarn" ? "yarn install" : `${pkgManager} install`;
 
-    execSync(installCmd, {
-      cwd: targetDir,
-      stdio: "inherit",
-    });
-  } catch (error) {
-    console.error(`\n❌ Failed to install dependencies with ${pkgManager}`);
-    throw error;
-  }
+  execSync(installCmd, {
+    cwd: targetDir,
+    stdio: "inherit",
+  });
 }
 
 module.exports = {

package/bin/lib/templateHandler.js

@@ -2,11 +2,9 @@ const fs = require("fs");
 const path = require("path");
 
 /**
- * Recursively copy directory contents
- * @param {string} src - Source directory
- * @param {string} dest - Destination directory
+ * Recursively copy directory contents, excluding specific files
  */
-function copyDir(src, dest) {
+function copyDir(src, dest, excludeFiles = []) {
   if (!fs.existsSync(dest)) {
     fs.mkdirSync(dest, { recursive: true });
   }
@@ -17,54 +15,19 @@ function copyDir(src, dest) {
     const srcPath = path.join(src, entry.name);
     const destPath = path.join(dest, entry.name);
 
-    if (entry.isDirectory()) {
-      copyDir(srcPath, destPath);
-    } else {
-      fs.copyFileSync(srcPath, destPath);
-    }
-  }
-}
-
-/**
- * Copy template files based on selected language and features
- * @param {string} templateDir - Path to template directory (e.g., template/js or template/ts)
- * @param {string} targetDir - Destination project directory
- * @param {string[]} features - Array of selected features
- */
-function copyTemplateModules(templateDir, targetDir, features) {
-  if (!fs.existsSync(targetDir)) {
-    fs.mkdirSync(targetDir, { recursive: true });
-  }
-
-  const entries = fs.readdirSync(templateDir, { withFileTypes: true });
-
-  for (const entry of entries) {
-    const srcPath = path.join(templateDir, entry.name);
-    const destPath = path.join(targetDir, entry.name);
-
-    if (entry.name === "modules" || entry.name.includes("package.json")) {
+    // Skip excluded files
+    if (excludeFiles.includes(entry.name)) {
       continue;
     }
 
     if (entry.isDirectory()) {
-      copyDir(srcPath, destPath);
+      copyDir(srcPath, destPath, excludeFiles);
     } else {
       fs.copyFileSync(srcPath, destPath);
     }
   }
-
-  const modulesDir = path.join(templateDir, "modules");
-  if (fs.existsSync(modulesDir)) {
-    features.forEach((feature) => {
-      const featurePath = path.join(modulesDir, feature);
-      if (fs.existsSync(featurePath)) {
-        copyDir(featurePath, targetDir);
-      }
-    });
-  }
 }
 
 module.exports = {
-  copyTemplateModules,
   copyDir,
 };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "create-charcole",
-  "version": "2.0.4",
-  "description": "Production-ready Express backend starter with engineering guardrails.",
+  "version": "2.2.0",
+  "description": "CLI to create production-ready Node.js Express APIs with TypeScript/JavaScript, JWT auth, auto-generated Swagger docs, and repository pattern",
   "license": "MIT",
   "author": {
     "name": "Sheraz Manzoor",