create-charcole 2.0.4 → 2.1.0

package/bin/index.js

@@ -1,26 +1,104 @@
-#!/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 = []) {
+  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);
+
+    if (excludeFiles.includes(entry.name)) {
+      console.log(`Skipping excluded file: ${entry.name}`);
+      continue;
+    }
+
+    if (entry.isDirectory()) {
+      copyDirRecursive(srcPath, destPath, excludeFiles);
+    } else {
+      fs.copyFileSync(srcPath, destPath);
+    }
+  }
+}
+
 (async function main() {
   try {
-    console.log("🔥 Welcome to Charcole v2 CLI");
+    console.log("🔥 Welcome to Charcole v2.1 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 +107,26 @@ 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,
+      },
+    );
+
+    const responses = await prompts(questions);
+
+    // Use command line project name if provided, otherwise use prompt response
+    const projectName = projectNameFromArgs || responses.projectName;
+    const { language, auth } = 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,41 +135,140 @@ 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...");
+
+    copyDirRecursive(templateDir, targetDir, ["basePackage.json"]);
+
+    const templateModulesDir = path.join(templateDir, "src", "modules");
+    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 {
+            const moduleDestPath = path.join(targetModulesDir, moduleName);
+            console.log(`📦 Copying ${moduleName} module...`);
+            copyDirRecursive(moduleSrcPath, moduleDestPath);
+          }
+        }
+      }
+    }
+
+    // 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 });
+      }
+    }
 
     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}...`);
@@ -98,10 +276,13 @@ const {
 
     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.1.0",
+  "description": "CLI to create production-ready Node.js Express APIs with TypeScript/JavaScript, JWT auth, and repository pattern",
   "license": "MIT",
   "author": {
     "name": "Sheraz Manzoor",

package/plans/V2_1_PLAN.md

@@ -0,0 +1,20 @@
+# Charcole v2.1 Plan
+
+## Features
+
+- [DONE] Auth module (JWT)
+- [DONE] CLI feature flag for auth
+- [DONE] JS template support
+- [DONE] TS template support
+
+## Non-Goals
+
+- No OAuth
+- No DB choice
+- No breaking changes
+
+## Release
+
+- [ ] Changelog
+- [ ] Docs update
+- [ ] npm publish

package/template/js/.env.example

@@ -1,8 +1,16 @@
+# Server Configuration
 NODE_ENV=development
 PORT=3000
 
+# Logging
 LOG_LEVEL=info
 
+# CORS
 CORS_ORIGIN=*
 
+# Request
 REQUEST_TIMEOUT=30000
+
+
+# Authentication
+JWT_SECRET=your-secret-key-here

package/template/js/basePackage.json

@@ -1,28 +1,26 @@
 {
   "name": "charcole",
-  "version": "2.0.4",
+  "version": "2.1.0",
   "description": "Production-grade Node.js Express API",
   "main": "src/server.js",
+  "type": "module",
+  "engines": {
+    "node": ">=18.0.0"
+  },
   "scripts": {
     "start": "node src/server.js",
     "dev": "nodemon src/server.js",
-    "lint": "echo 'Add linting here'",
-    "test": "echo 'Add tests here'"
+    "lint": "echo \"Add linting here\"",
+    "test": "echo \"Add tests here\""
   },
-  "engines": {
-    "node": ">=18.0.0"
-  },
-  "keywords": [],
-  "author": "",
-  "license": "ISC",
-  "type": "module",
   "dependencies": {
+    "express": "^4.18.2",
     "cors": "^2.8.5",
     "dotenv": "^16.3.1",
-    "express": "^4.18.2",
-    "zod": "^3.22.4"
+    "zod": "^3.25.76"
   },
   "devDependencies": {
     "nodemon": "^3.0.2"
-  }
+  },
+  "license": "ISC"
 }

package/template/js/src/app.js

@@ -1,4 +1,5 @@
 import express from "express";
+import { userRepo } from "./repositories/user.repo.js";
 import cors from "cors";
 import { env } from "./config/env.js";
 import { HTTP_STATUS, ERROR_MESSAGES } from "./config/constants.js";
@@ -10,7 +11,7 @@ import {
 } from "./middlewares/errorHandler.js";
 import { sendSuccess } from "./utils/response.js";
 import { logger } from "./utils/logger.js";
-import routes from "./routes.js";
+import routes from "./routes/index.js";
 
 export const app = express();
 
@@ -73,3 +74,5 @@ app.use((req, res, next) => {
 app.use(errorHandler);
 
 logger.info("Express app configured successfully");
+
+app.locals.userRepo = userRepo;

package/template/js/src/modules/auth/auth.constants.js

@@ -0,0 +1,3 @@
+export const USER_ROLES = ["user", "admin"];
+
+export const AUTH_PROVIDERS = ["credentials"];

package/template/js/src/modules/auth/auth.controller.js

@@ -0,0 +1,29 @@
+import { AuthService } from "./auth.service.js";
+
+export const AuthController = {
+  async register(req, res) {
+    try {
+      const user = await AuthService.register(
+        req.body,
+        req.app.locals.userRepo,
+      );
+
+      res.status(201).json({
+        message: "User registered successfully",
+        user,
+      });
+    } catch (err) {
+      res.status(400).json({ message: err.message });
+    }
+  },
+
+  async login(req, res) {
+    try {
+      const result = await AuthService.login(req.body, req.app.locals.userRepo);
+
+      res.json(result);
+    } catch (err) {
+      res.status(401).json({ message: err.message });
+    }
+  },
+};

package/template/js/src/modules/auth/auth.middlewares.js

@@ -0,0 +1,19 @@
+import jwt from "jsonwebtoken";
+
+export const requireAuth = (req, res, next) => {
+  const authHeader = req.headers.authorization;
+
+  if (!authHeader?.startsWith("Bearer ")) {
+    return res.status(401).json({ message: "Unauthorized" });
+  }
+
+  const token = authHeader.split(" ")[1];
+
+  try {
+    const payload = jwt.verify(token, process.env.JWT_SECRET);
+    req.user = payload;
+    next();
+  } catch {
+    res.status(401).json({ message: "Invalid token" });
+  }
+};

package/template/js/src/modules/auth/auth.routes.js

@@ -0,0 +1,9 @@
+import { Router } from "express";
+import { AuthController } from "./auth.controller.js";
+
+const router = Router();
+
+router.post("/register", AuthController.register);
+router.post("/login", AuthController.login);
+
+export default router;