create-fullstack-setup 1.0.0

package/utils/injectFeatures.js

@@ -0,0 +1,171 @@
+import fs from "fs";
+import path from "path";
+import { FEATURES } from "./features.config.js";
+
+/* -------------------------------------------------------------------------- */
+/*                           Helpers (JS / TS aware)                           */
+/* -------------------------------------------------------------------------- */
+
+function isTypeScriptBackend(serverPath) {
+  return (
+    fs.existsSync(path.join(serverPath, "tsconfig.json")) ||
+    fs.existsSync(path.join(serverPath, "src"))
+  );
+}
+
+function findAppFile(serverPath) {
+  const possible = ["src/app.ts", "src/app.js", "app.ts", "app.js"];
+  for (const file of possible) {
+    const full = path.join(serverPath, file);
+    if (fs.existsSync(full)) return full;
+  }
+  return null;
+}
+
+function findServerFile(serverPath) {
+  const possible = ["src/server.ts", "src/server.js", "server.ts", "server.js"];
+  for (const file of possible) {
+    const full = path.join(serverPath, file);
+    if (fs.existsSync(full)) return full;
+  }
+  return null;
+}
+
+/* -------------------------------------------------------------------------- */
+/*                            Inject Features                                  */
+/* -------------------------------------------------------------------------- */
+
+export function injectFeatures(serverPath, selectedFeatures = []) {
+  if (!Array.isArray(selectedFeatures) || selectedFeatures.length === 0) return;
+
+  const appFile = findAppFile(serverPath);
+  const serverFile = findServerFile(serverPath);
+  const isTS = isTypeScriptBackend(serverPath);
+
+  if (!appFile) {
+    console.warn("⚠️ app file not found, skipping feature injection");
+    return;
+  }
+
+  let appContent = fs.readFileSync(appFile, "utf8");
+  let serverContent = serverFile
+    ? fs.readFileSync(serverFile, "utf8")
+    : "";
+
+  let middlewareCode = "";
+  let envVars = [];
+
+  /* ---------------------------------------------------------------------- */
+  /*                         Process each feature                            */
+  /* ---------------------------------------------------------------------- */
+
+  for (const feature of selectedFeatures) {
+    const config = FEATURES[feature];
+    if (!config) continue;
+
+    const featureKey = feature.toLowerCase(); // 🔥 normalize
+
+    /* --------------------------- Middlewares ---------------------------- */
+    if (config.middleware && !appContent.includes(config.middleware)) {
+      middlewareCode += `${config.middleware}\n`;
+    }
+
+    /* ------------------------------ Files -------------------------------- */
+    if (config.files) {
+      const files = isTS ? config.files.ts : config.files.js;
+
+      if (Array.isArray(files)) {
+        for (const file of files) {
+          const filePath = path.join(serverPath, file.path);
+          fs.mkdirSync(path.dirname(filePath), { recursive: true });
+
+          if (fs.existsSync(filePath)) continue;
+
+          // ✅ FIX: support fromTemplate
+          if (file.fromTemplate) {
+            const templatePath = path.join(
+              process.cwd(),
+              "templates",
+              "backend",
+              isTS ? "express-ts" : "express-js",
+              file.path
+            );
+
+            if (!fs.existsSync(templatePath)) {
+              console.warn(`⚠️ Missing template: ${templatePath}`);
+              continue;
+            }
+
+            fs.copyFileSync(templatePath, filePath);
+          } else if (file.content) {
+            fs.writeFileSync(filePath, file.content.trim());
+          }
+        }
+      }
+    }
+
+    /* ------------------------------ Env ---------------------------------- */
+    if (Array.isArray(config.env)) {
+      envVars.push(...config.env);
+    }
+
+    /* --------------------------- Cloudinary ------------------------------ */
+    if (featureKey === "Cloudinary" && serverFile) {
+      if (!serverContent.includes("connectCloudinary")) {
+        const importPath = isTS
+          ? "./utils/Cloudinary"
+          : "./Utils/Cloudinary.js";
+
+        serverContent = serverContent.replace(
+          /app\.listen|server\.listen/,
+          `
+import { connectCloudinary } from "${importPath}";
+connectCloudinary();
+
+$&`
+        );
+      }
+    }
+  }
+
+  /* ---------------------------------------------------------------------- */
+  /*                        Inject middlewares                               */
+  /* ---------------------------------------------------------------------- */
+
+  if (middlewareCode && appContent.includes("__INJECT_MIDDLEWARES__")) {
+    appContent = appContent.replace(
+      "// __INJECT_MIDDLEWARES__",
+      middlewareCode + "\n// __INJECT_MIDDLEWARES__"
+    );
+  }
+
+  fs.writeFileSync(appFile, appContent, "utf8");
+
+  /* ---------------------------------------------------------------------- */
+  /*                         Write server file                               */
+  /* ---------------------------------------------------------------------- */
+
+  if (serverFile && serverContent) {
+    fs.writeFileSync(serverFile, serverContent, "utf8");
+  }
+
+  /* ---------------------------------------------------------------------- */
+  /*                        Append env variables                              */
+  /* ---------------------------------------------------------------------- */
+
+  const envExamplePath = path.join(serverPath, ".env.example");
+
+  if (envVars.length && fs.existsSync(envExamplePath)) {
+    const existingEnv = fs.readFileSync(envExamplePath, "utf8");
+
+    const newVars = envVars.filter(
+      (v) => !existingEnv.includes(v.split("=")[0])
+    );
+
+    if (newVars.length) {
+      fs.appendFileSync(envExamplePath, "\n" + newVars.join("\n"));
+    }
+  }
+
+  console.log("🔧 Backend features injected successfully");
+}

package/utils/installer.js

@@ -0,0 +1,157 @@
+import fs from "fs-extra";
+import path from "path";
+import { execSync } from "child_process";
+import { fileURLToPath } from "url";
+import ora from "ora";
+
+import { injectFeatures } from "./injectFeatures.js";
+import { replacePlaceholders } from "./replacePlaceholders.js";
+
+/* -------------------------------------------------------------------------- */
+/*                              ESM __dirname                                 */
+/* -------------------------------------------------------------------------- */
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+/* -------------------------------------------------------------------------- */
+/*                              Template Root                                 */
+/* -------------------------------------------------------------------------- */
+
+const TEMPLATES_DIR = path.join(__dirname, "..", "templates");
+
+/* -------------------------------------------------------------------------- */
+/*                         Template Registries                                 */
+/* -------------------------------------------------------------------------- */
+
+const FRONTEND_TEMPLATES = {
+  "react-js": path.join(TEMPLATES_DIR, "frontend", "react-js"),
+  "react-ts": path.join(TEMPLATES_DIR, "frontend", "react-ts"),
+  "next-js": path.join(TEMPLATES_DIR, "frontend", "next-js"),
+  "next-ts": path.join(TEMPLATES_DIR, "frontend", "next-ts")
+};
+
+const BACKEND_TEMPLATES = {
+  "express-js": path.join(TEMPLATES_DIR, "backend", "express-js"),
+  "express-ts": path.join(TEMPLATES_DIR, "backend", "express-ts")
+};
+
+/* -------------------------------------------------------------------------- */
+/*                           Main Project Creator                              */
+/* -------------------------------------------------------------------------- */
+
+export async function createProject(config) {
+  const root =
+    config.projectName === "."
+      ? process.cwd()
+      : path.join(process.cwd(), config.projectName);
+
+  const clientPath = path.join(root, "client");
+  const serverPath = path.join(root, "server");
+
+  console.log(`\n🚀 Creating project: ${config.projectName}\n`);
+
+  await fs.ensureDir(root);
+
+  /* ----------------------------- Frontend -------------------------------- */
+
+  if (config.frontend && config.frontend !== "None") {
+    const frontendTemplatePath = FRONTEND_TEMPLATES[config.frontend];
+
+    if (!frontendTemplatePath || !fs.existsSync(frontendTemplatePath)) {
+      throw new Error(`❌ Frontend template "${config.frontend}" not found`);
+    }
+
+    const frontendSpinner = ora(
+      `Setting up frontend (${config.frontend})...`
+    ).start();
+
+    await fs.copy(frontendTemplatePath, clientPath);
+
+    frontendSpinner.succeed("Frontend ready");
+
+    await replacePlaceholders(clientPath, {
+      PROJECT_NAME: config.projectName
+    });
+  }
+
+  /* ----------------------------- Backend --------------------------------- */
+
+  const backendTemplatePath = BACKEND_TEMPLATES[config.backend];
+
+  if (!backendTemplatePath || !fs.existsSync(backendTemplatePath)) {
+    throw new Error(`❌ Backend template "${config.backend}" not found`);
+  }
+
+  const backendSpinner = ora(
+    `Setting up backend (${config.backend})...`
+  ).start();
+
+  await fs.copy(backendTemplatePath, serverPath);
+
+  backendSpinner.succeed("Backend ready");
+
+  /* --------------------------- .env handling ------------------------------ */
+
+  const envExamplePath = path.join(serverPath, ".env.example");
+  const envPath = path.join(serverPath, ".env");
+
+  if (fs.existsSync(envExamplePath)) {
+    await fs.copy(envExamplePath, envPath);
+  }
+
+  /* ----------------------- Replace placeholders --------------------------- */
+
+  await replacePlaceholders(serverPath, {
+    PROJECT_NAME: `${config.projectName}-server`
+  });
+
+  /* ----------------------- Install Dependencies --------------------------- */
+
+  if (Array.isArray(config.backendFeatures)) {
+    installDependencies(serverPath, config.backendFeatures);
+  }
+
+  console.log("\n✅ Project setup complete!");
+  console.log(`👉 cd ${config.projectName}`);
+}
+
+/* -------------------------------------------------------------------------- */
+/*                        Dependency Installation                              */
+/* -------------------------------------------------------------------------- */
+
+const BACKEND_DEPENDENCY_MAP = {
+  JWT: "jsonwebtoken",
+  CORS: "cors",
+  "Cookie-Parser": "cookie-parser",
+  Cloudinary: "cloudinary",
+  Mongoose: "mongoose",
+  Zod: "zod",
+  Dotenv: "dotenv",
+  Bcrypt: "bcrypt",
+  Multer: "multer"
+};
+
+function installDependencies(serverPath, backendFeatures) {
+  const deps = new Set();
+
+  for (const feature of backendFeatures) {
+    const pkg = BACKEND_DEPENDENCY_MAP[feature];
+    if (pkg) deps.add(pkg);
+  }
+
+  if (!deps.size) return;
+
+  const installSpinner = ora(
+    "Installing backend dependencies..."
+  ).start();
+
+  execSync(`npm install ${[...deps].join(" ")}`, {
+    cwd: serverPath,
+    stdio: "ignore"
+  });
+
+  installSpinner.succeed("Dependencies installed");
+
+  injectFeatures(serverPath, backendFeatures);
+}

package/utils/prompts.js

@@ -0,0 +1,59 @@
+import { type } from "os";
+
+const answers = await inquirer.prompt([
+    {
+        type:"confirm",
+        name:"express",
+        message:"install express ?",
+        default:true
+    },
+  
+    {
+    type: "confirm",
+    name: "JWT",
+    message: "Use JWT authentication?",
+    default: true
+  },
+  {
+    type: "confirm",
+    name: "CORS",
+    message: "Enable CORS?",
+    default: true
+  },
+  {
+    type: "confirm",
+    name: "CookieParser",
+    message: "Use Cookie Parser?",
+    default: true
+  },
+  {
+    type: "confirm",
+    name: "dotenv",
+    message: "Use environment variable ?",
+    default: true
+  },
+  {
+    type: "confirm",
+    name: "Zod",
+    message: "Use Zod validator?",
+    default: true
+  },
+  {
+    type: "confirm",
+    name: "multer",
+    message: "Use multer ?",
+    default: true
+  },
+  {
+    type: "confirm",
+    name: "Mongoose",
+    message: "Use MongoDB (Mongoose)?",
+    default: false
+  },
+  {
+    type: "confirm",
+    name: "Bcrypt",
+    message: "Use Bcrypt for password hashing?",
+    default: true
+  }
+]);

package/utils/replacePlaceholders.js

@@ -0,0 +1,54 @@
+import fs from "fs-extra";
+import path from "path";
+
+const IGNORE_DIRS = [
+  "node_modules",
+  ".git",
+  "dist",
+  "build"
+];
+
+const IGNORE_EXTENSIONS = [
+  ".png",
+  ".jpg",
+  ".jpeg",
+  ".gif",
+  ".ico",
+  ".zip"
+];
+
+/**
+ * Recursively replace placeholders in text files
+ */
+export async function replacePlaceholders(dir, replacements) {
+  if (!fs.existsSync(dir)) return;
+
+  const files = await fs.readdir(dir);
+
+  for (const file of files) {
+    if (IGNORE_DIRS.includes(file)) continue;
+
+    const fullPath = path.join(dir, file);
+    const stat = await fs.stat(fullPath);
+
+    if (stat.isDirectory()) {
+      await replacePlaceholders(fullPath, replacements);
+    } else {
+      if (IGNORE_EXTENSIONS.some(ext => file.endsWith(ext))) continue;
+
+      let content;
+      try {
+        content = await fs.readFile(fullPath, "utf8");
+      } catch {
+        continue; // skip non-text files safely
+      }
+
+      for (const [key, value] of Object.entries(replacements)) {
+        const regex = new RegExp(`__${key}__`, "g");
+        content = content.replace(regex, value);
+      }
+
+      await fs.writeFile(fullPath, content);
+    }
+  }
+}