4bnode 3.5.2 → 4.0.0

package/index.js

@@ -2,27 +2,40 @@
 
 import fs from "fs";
 import path from "path";
-import { execSync } from "child_process";
+import { execFileSync } from "child_process";
 import { fileURLToPath } from "url";
 import chalk from "chalk";
+import { input, select } from "@inquirer/prompts";
+import { sanitizeName } from "./lib/names.js";
+import {
+  checkMongoConfig,
+  checkRoutesDir,
+  checkModelsExist,
+  listModels,
+  listRoutes,
+  getModelSchemaDetailed,
+} from "./lib/project.js";
+import {
+  showBanner,
+  createSpinner,
+  showSuccess,
+  showNextSteps,
+  showError,
+  showHeader,
+} from "./lib/ui.js";
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 const skeletonPath = path.join(__dirname, "skeleton");
 
 function copyRecursiveSync(src, dest) {
-  const exists = fs.existsSync(src);
-  const stats = exists && fs.statSync(src);
-  const isDirectory = exists && stats.isDirectory();
-  if (isDirectory) {
+  const stats = fs.statSync(src);
+  if (stats.isDirectory()) {
     if (!fs.existsSync(dest)) {
       fs.mkdirSync(dest);
     }
-    fs.readdirSync(src).forEach((childItemName) => {
-      copyRecursiveSync(
-        path.join(src, childItemName),
-        path.join(dest, childItemName)
-      );
+    fs.readdirSync(src).forEach((child) => {
+      copyRecursiveSync(path.join(src, child), path.join(dest, child));
     });
   } else {
     fs.copyFileSync(src, dest);
@@ -41,74 +54,179 @@ function updatePackageName(destinationPath, projectName) {
 }
 
 function createSkeletonApp(projectName) {
+  showBanner();
+
   const targetPath = path.resolve(projectName);
+
+  const scaffoldSpinner = createSpinner("Scaffolding project structure...");
+  scaffoldSpinner.start();
   if (!fs.existsSync(targetPath)) {
     fs.mkdirSync(targetPath, { recursive: true });
   }
   copyRecursiveSync(skeletonPath, targetPath);
   updatePackageName(targetPath, projectName);
-  console.log(`Node.js skeleton app created successfully in ${projectName}.`);
+  scaffoldSpinner.succeed(chalk.hex("#00f260").bold("Project scaffolded"));
 
-  // Install dependencies
-  execSync("npm install", { stdio: "inherit", cwd: targetPath });
-  console.log("Dependencies installed successfully.");
-}
+  const installSpinner = createSpinner("Installing dependencies...");
+  installSpinner.start();
+  execFileSync("npm", ["install"], { stdio: "pipe", cwd: targetPath });
+  installSpinner.succeed(chalk.hex("#00f260").bold("Dependencies installed"));
 
-function checkModelsExist() {
-  const projectRoot = process.cwd();
-  const modelsDir = path.join(projectRoot, "src", "models");
-  return fs.existsSync(modelsDir) && fs.readdirSync(modelsDir).length > 0;
+  showSuccess([
+    `Project ${chalk.hex("#00c6ff").bold(projectName)} created at ${chalk.gray(targetPath)}`,
+    `Express 5.x + Dotenv 17.x + CORS ready to go`,
+  ]);
+
+  showNextSteps([
+    `cd ${projectName}`,
+    "npm run dev",
+    "Open http://localhost:3000",
+  ]);
 }
 
-function checkRoutesDir() {
-  const projectRoot = process.cwd();
-  const routesDir = path.join(projectRoot, "src", "routes");
-  return fs.existsSync(routesDir);
+function runCommand(script, args = []) {
+  execFileSync("node", [path.join(__dirname, script), ...args], {
+    stdio: "inherit",
+  });
 }
 
-function checkMongoConfig() {
-  const projectRoot = process.cwd();
-  const envPath = path.join(projectRoot, ".env.development");
-  return (
-    fs.existsSync(envPath) &&
-    fs.readFileSync(envPath, "utf8").includes("MONGO_URI")
-  );
+// ── Add menu options ────────────────────────────────
+
+const addOptions = [
+  {
+    name: "API Endpoint         Create a new route",
+    value: "api",
+    script: "add-api.js",
+  },
+  {
+    name: "MongoDB              Setup database connection",
+    value: "mongo",
+    script: "add-mongo.js",
+  },
+  {
+    name: "CRUD                 Add create/read/update/delete routes",
+    value: "crud",
+    script: "add-crud.js",
+    requiresRoutes: true,
+    requiresModels: true,
+  },
+  {
+    name: "Login & Auth         Add JWT authentication",
+    value: "login",
+    script: "add-login.js",
+    requiresRoutes: true,
+    requiresModels: true,
+  },
+  {
+    name: "Socket.IO            Real-time with Socket.IO",
+    value: "socket",
+    script: "add-socket.js",
+  },
+  {
+    name: "WebSocket            Native WebSocket support",
+    value: "websocket",
+    script: "add-websocket.js",
+  },
+  {
+    name: "SerialPort           Serial port communication",
+    value: "serialport",
+    script: "add-serialport.js",
+  },
+];
+
+// ── List ────────────────────────────────────────────
+
+function showList(filter) {
+  showHeader("list", "Project overview");
+
+  const c = chalk.hex("#00c6ff");
+  const g = chalk.hex("#22c55e");
+  const y = chalk.hex("#ffd200");
+  const d = chalk.gray;
+
+  const showModels = !filter || filter === "models";
+  const showRoutes = !filter || filter === "routes";
+
+  if (showModels) {
+    const models = listModels();
+    console.log(y.bold("  Models"));
+    console.log(d("  ─────────────────────────────────"));
+    if (models.length === 0) {
+      console.log(d("  No models found.\n"));
+    } else {
+      models.forEach((file) => {
+        const name = path.basename(file, ".js");
+        const fields = getModelSchemaDetailed(name);
+        const fieldNames = fields.map((f) => {
+          let label = f.name;
+          if (f.required) label = g(label);
+          if (f.unique) label = `${label}${y("*")}`;
+          return label;
+        });
+        console.log(`  ${c(name)}  ${d("→")}  ${fieldNames.join(d(", "))}`);
+      });
+      console.log();
+      console.log(d(`  ${g("green")} = required  ${y("*")} = unique`));
+      console.log();
+    }
+  }
+
+  if (showRoutes) {
+    const routes = listRoutes();
+    console.log(y.bold("  Routes"));
+    console.log(d("  ─────────────────────────────────"));
+    if (routes.length === 0) {
+      console.log(d("  No routes found.\n"));
+    } else {
+      routes.forEach((file) => {
+        const name = path.basename(file, ".js");
+        console.log(`  ${c(name)}  ${d(`→  src/routes/${file}`)}`);
+      });
+      console.log();
+    }
+  }
+
+  // Show config status
+  if (!filter) {
+    console.log(y.bold("  Config"));
+    console.log(d("  ─────────────────────────────────"));
+    console.log(`  MongoDB     ${checkMongoConfig() ? g("✔ configured") : d("✖ not configured")}`);
+    console.log(`  Routes dir  ${checkRoutesDir() ? g("✔ exists") : d("✖ not found")}`);
+    console.log();
+  }
 }
 
+// ── Help ────────────────────────────────────────────
+
 function showHelp() {
-  console.log(
-    chalk.green(`
-Usage: ${chalk.bold("node-app <command> [options]")}
-
-Commands:
-  ${chalk.blue(
-    "init <projectName>"
-  )}        Create a new Node.js project with the given name.
-  ${chalk.blue(
-    "add-api <endpointName>"
-  )}    Add a new API endpoint with the given name.
-  ${chalk.blue("add-mongo")}               Configure MongoDB for the project.
-  ${chalk.blue(
-    "add-socket"
-  )}                Add Socket.IO support to the project.
-  ${chalk.blue(
-    "add-websocket"
-  )}             Add WebSocket support to the project.
-  ${chalk.blue(
-    "add-mongo-schema <schemaName>"
-  )}  Add a new MongoDB schema with the given name.
-  ${chalk.blue("add-login")}                 Add a login route to the project.
-  ${chalk.blue("add-mongo-insert")}        Add an insert route for MongoDB.
-  ${chalk.blue("add-mongo-update")}        Add an update route for MongoDB.
-  ${chalk.blue("add-mongo-read")}          Add a read route for MongoDB.
-  ${chalk.blue("add-mongo-delete")}        Add a delete route for MongoDB.
-  
-Options:
-  ${chalk.blue("-h, --help")}                Show this help message.
-`)
-  );
+  showBanner();
+  const c = chalk.hex("#00c6ff");
+  const d = chalk.gray;
+  const h = chalk.hex("#ffd200").bold;
+
+  console.log(h("  COMMANDS\n"));
+  console.log(`  ${c("init")} ${d("[name]")}      Create a new Node.js project`);
+  console.log(`  ${c("add")} ${d("[feature]")}    Add a feature (interactive menu)`);
+  console.log(`  ${c("schema")} ${d("[name]")}    Manage schemas (create/view/edit)`);
+  console.log(`  ${c("list")} ${d("[filter]")}    List models, routes & config status`);
+  console.log(`  ${c("ui")}                 Start dev server with visual dashboard`);
+  console.log();
+  console.log(h("  ADD FEATURES\n"));
+  console.log(`  ${c("add api")} ${d("[name]")}     API endpoint`);
+  console.log(`  ${c("add mongo")}           MongoDB connection`);
+  console.log(`  ${c("add crud")}            CRUD routes (create/read/update/delete)`);
+  console.log(`  ${c("add login")}           JWT authentication & login`);
+  console.log(`  ${c("add socket")}          Socket.IO integration`);
+  console.log(`  ${c("add websocket")}       Native WebSocket support`);
+  console.log(`  ${c("add serialport")}      Serial port communication`);
+  console.log();
+  console.log(h("  OPTIONS\n"));
+  console.log(`  ${c("-h, --help")}          Show this help message`);
+  console.log();
 }
 
+// ── Main ────────────────────────────────────────────
+
 const args = process.argv.slice(2);
 if (args.length < 1 || args.includes("-h") || args.includes("--help")) {
   showHelp();
@@ -116,111 +234,126 @@ if (args.length < 1 || args.includes("-h") || args.includes("--help")) {
 }
 
 const command = args[0];
-const param = args[1];
+const subCommand = args[1];
+const extraParam = args[2];
 
-if (command === "init") {
-  if (!param) {
-    console.error(chalk.red("Usage: node-app init <projectName>"));
-    process.exit(1);
-  }
-  createSkeletonApp(param);
-} else if (command === "add-api") {
-  if (!param) {
-    console.error(chalk.red("Usage: node-app add-api <endpointName>"));
-    process.exit(1);
-  }
-  execSync(`node ${path.join(__dirname, "add-api.js")} ${param}`, {
-    stdio: "inherit",
-  });
-} else if (command === "add-mongo") {
-  execSync(`node ${path.join(__dirname, "add-mongo.js")}`, {
-    stdio: "inherit",
-  });
-} else if (command === "add-socket") {
-  execSync(`node ${path.join(__dirname, "add-socket.js")}`, {
-    stdio: "inherit",
-  });
-} else if (command === "add-websocket") {
-  execSync(`node ${path.join(__dirname, "add-websocket.js")}`, {
-    stdio: "inherit",
+async function promptName(label) {
+  return input({
+    message: `Enter ${label}:`,
+    validate: (v) => {
+      try { sanitizeName(v); return true; } catch (e) { return e.message; }
+    },
   });
-} else if (command === "add-mongo-schema") {
-  if (!param) {
-    console.error(chalk.red("Usage: node-app add-mongo-schema <schemaName>"));
-    process.exit(1);
-  }
-  if (!checkMongoConfig()) {
-    console.error(
-      chalk.red(
-        "MongoDB is not configured. Please run 'node-app add-mongo' first."
-      )
-    );
-    process.exit(1);
-  }
-  execSync(`node ${path.join(__dirname, "add-mongo-schema.js")} ${param}`, {
-    stdio: "inherit",
-  });
-} else if (command === "add-login") {
-  if (!checkRoutesDir()) {
-    console.error(chalk.red("No routes directory found in src/routes"));
-    process.exit(1);
+}
+
+async function handleAdd(featureOverride, paramOverride) {
+  let feature = featureOverride || subCommand;
+  const param = paramOverride || extraParam;
+
+  if (!feature) {
+    showHeader("add", "What would you like to add?");
+    const choice = await select({
+      message: "Select a feature:",
+      choices: addOptions.map((o) => ({ name: o.name, value: o.value })),
+    });
+    feature = choice;
   }
-  execSync(`node ${path.join(__dirname, "add-login.js")}`, {
-    stdio: "inherit",
-  });
-} else if (command === "add-mongo-insert") {
-  if (!checkRoutesDir()) {
-    console.error(chalk.red("No routes directory found in src/routes"));
+
+  // Map feature to option
+  const option = addOptions.find((o) => o.value === feature);
+  if (!option) {
+    showError(`Unknown feature "${feature}". Run 4bnode add to see options.`);
     process.exit(1);
   }
-  if (!checkModelsExist()) {
-    console.error(chalk.red("No model files found in src/models"));
-    process.exit(1);
+
+  // Pre-flight checks with helpful guidance
+  const missing = [];
+  if (option.requiresMongo && !checkMongoConfig()) {
+    missing.push("  1. 4bnode add mongo          Setup database first");
   }
-  execSync(`node ${path.join(__dirname, "add-mongo-insert.js")}`, {
-    stdio: "inherit",
-  });
-} else if (command === "add-mongo-update") {
-  if (!checkRoutesDir()) {
-    console.error(chalk.red("No routes directory found in src/routes"));
-    process.exit(1);
+  if (option.requiresRoutes && !checkRoutesDir()) {
+    missing.push(`  ${missing.length + 1}. 4bnode add api <name>      Create a route first`);
   }
-  if (!checkModelsExist()) {
-    console.error(chalk.red("No model files found in src/models"));
-    process.exit(1);
+  if (option.requiresModels && !checkModelsExist()) {
+    missing.push(`  ${missing.length + 1}. 4bnode schema              Create a model first`);
   }
-  execSync(`node ${path.join(__dirname, "add-mongo-update.js")}`, {
-    stdio: "inherit",
-  });
-} else if (command === "add-mongo-read") {
-  if (!checkRoutesDir()) {
-    console.error(chalk.red("No routes directory found in src/routes"));
+  if (missing.length > 0) {
+    showError(`Cannot run "${feature}" yet. Run these first:\n\n${missing.join("\n")}`);
     process.exit(1);
   }
-  if (!checkModelsExist()) {
-    console.error(chalk.red("No model files found in src/models"));
-    process.exit(1);
+
+  // Handle features that need a name param
+  if (feature === "api") {
+    const name = param || await promptName("endpoint name");
+    runCommand(option.script, [sanitizeName(name)]);
+  } else {
+    runCommand(option.script);
   }
-  execSync(`node ${path.join(__dirname, "add-mongo-read.js")}`, {
-    stdio: "inherit",
-  });
-} else if (command === "add-mongo-delete") {
-  if (!checkRoutesDir()) {
-    console.error(chalk.red("No routes directory found in src/routes"));
-    process.exit(1);
+}
+
+async function main() {
+  if (command === "init") {
+    const name = subCommand || await promptName("project name");
+    createSkeletonApp(sanitizeName(name));
+  } else if (command === "add") {
+    await handleAdd();
+  } else if (command === "schema") {
+    // Top-level schema manager: create / view / edit
+    if (subCommand) {
+      runCommand("add-mongo-schema.js", [subCommand]);
+    } else {
+      runCommand("add-mongo-schema.js");
+    }
+  } else if (command === "list") {
+    showList(subCommand);
+  } else if (command === "ui") {
+    // Must be inside a 4bnode project (has package.json + dev-api.js)
+    const projectRoot = process.cwd();
+    const hasPackageJson = fs.existsSync(path.join(projectRoot, "package.json"));
+    const hasDevApi = fs.existsSync(path.join(projectRoot, "dev-api.js"));
+    if (!hasPackageJson || !hasDevApi) {
+      showError("Not inside a 4bnode project. Run 'npx 4bnode init <name>' first, then cd into the project folder.");
+      process.exit(1);
+    }
+    console.log(chalk.hex("#00f260").bold("\n  Starting dev server...\n"));
+    execFileSync("npm", ["run", "dev"], {
+      stdio: "inherit",
+      cwd: projectRoot,
+    });
   }
-  if (!checkModelsExist()) {
-    console.error(chalk.red("No model files found in src/models"));
-    process.exit(1);
+  // Legacy commands → route through handleAdd
+  else {
+    // Legacy: "add-mongo-schema" or "edit" → schema manager
+    if (command === "add-mongo-schema" || command === "edit") {
+      runCommand("add-mongo-schema.js", subCommand ? [command === "edit" ? "--edit" : "", subCommand].filter(Boolean) : (command === "edit" ? ["--edit"] : []));
+      return;
+    }
+
+    const legacyMap = {
+      "add-api": "api",
+      "add-mongo": "mongo",
+      "add-crud": "crud",
+      "add-login": "login",
+      "add-mongo-insert": "crud",
+      "add-mongo-update": "crud",
+      "add-mongo-read": "crud",
+      "add-mongo-delete": "crud",
+      "add-socket": "socket",
+      "add-websocket": "websocket",
+      "add-serialport": "serialport",
+    };
+    const mapped = legacyMap[command];
+    if (mapped) {
+      await handleAdd(mapped, subCommand);
+    } else {
+      showError(`Unknown command "${command}". Run 4bnode --help for usage.`);
+      process.exit(1);
+    }
   }
-  execSync(`node ${path.join(__dirname, "add-mongo-delete.js")}`, {
-    stdio: "inherit",
-  });
-} else if (command === "add-serialport") {
-  execSync(`node ${path.join(__dirname, "add-serialport.js")}`, {
-    stdio: "inherit",
-  });
-} else {
-  console.error(chalk.red("Unknown command. Use -h or --help for help."));
-  process.exit(1);
 }
+
+main().catch((err) => {
+  if (err.name === "ExitPromptError") process.exit(0);
+  showError(err.message);
+  process.exit(1);
+});

package/lib/env.js

@@ -0,0 +1,18 @@
+import fs from "fs";
+
+export function updateEnvFile(filePath, key, value) {
+  const line = `${key}=${value}`;
+
+  if (fs.existsSync(filePath)) {
+    let content = fs.readFileSync(filePath, "utf8");
+    const regex = new RegExp(`^${key}=.*`, "m");
+    if (regex.test(content)) {
+      content = content.replace(regex, line);
+    } else {
+      content = content.trimEnd() + "\n" + line + "\n";
+    }
+    fs.writeFileSync(filePath, content, "utf8");
+  } else {
+    fs.writeFileSync(filePath, line + "\n", "utf8");
+  }
+}

package/lib/indexFile.js

@@ -0,0 +1,87 @@
+import fs from "fs";
+import path from "path";
+import { getProjectRoot } from "./project.js";
+
+function getIndexPath() {
+  return path.join(getProjectRoot(), "index.js");
+}
+
+function readIndex() {
+  return fs.readFileSync(getIndexPath(), "utf8");
+}
+
+function writeIndex(content) {
+  fs.writeFileSync(getIndexPath(), content, "utf8");
+}
+
+export function addImport(importStatement) {
+  let content = readIndex();
+  if (!content.includes(importStatement.trim())) {
+    content = importStatement.trim() + "\n" + content;
+    writeIndex(content);
+  }
+}
+
+export function addRouteRegistration(importLine, useLine) {
+  let content = readIndex();
+
+  if (!content.includes(importLine.trim())) {
+    content = importLine.trim() + "\n" + content;
+  }
+
+  if (!content.includes(useLine.trim())) {
+    if (content.includes("app.listen(port")) {
+      content = content.replace(
+        "app.listen(port",
+        useLine.trim() + "\n" + "app.listen(port"
+      );
+    } else if (content.includes("server.listen(port")) {
+      content = content.replace(
+        "server.listen(port",
+        useLine.trim() + "\n" + "server.listen(port"
+      );
+    }
+  }
+
+  writeIndex(content);
+}
+
+export function insertBeforeListen(codeBlock) {
+  let content = readIndex();
+  const listenMatch = content.match(/(app|server)\.listen\(port/);
+  if (listenMatch) {
+    content = content.replace(
+      listenMatch[0],
+      codeBlock.trim() + "\n\n" + listenMatch[0]
+    );
+  } else {
+    content += "\n" + codeBlock.trim() + "\n";
+  }
+  writeIndex(content);
+}
+
+export function replaceAppListen(newListenBlock) {
+  let content = readIndex();
+  content = content.replace(/app\.listen\(port[\s\S]*?\}\);?\n?/m, "");
+  if (!content.includes("server.listen(port")) {
+    content += "\n" + newListenBlock.trim() + "\n";
+  }
+  writeIndex(content);
+}
+
+export function insertBeforeRoutes(codeBlock) {
+  let content = readIndex();
+  const routesStart = content.indexOf("app.use(");
+  if (routesStart !== -1) {
+    content =
+      content.slice(0, routesStart) +
+      codeBlock.trim() +
+      "\n\n" +
+      content.slice(routesStart);
+  } else {
+    content += "\n" + codeBlock.trim() + "\n";
+  }
+  writeIndex(content);
+}
+
+export { readIndex, writeIndex, getIndexPath };

package/lib/names.js

@@ -0,0 +1,21 @@
+export function toCamelCase(str) {
+  return str.replace(/-([a-z])/g, (g) => g[1].toUpperCase());
+}
+
+export function toPascalCase(str) {
+  const camel = toCamelCase(str);
+  return camel.charAt(0).toUpperCase() + camel.slice(1);
+}
+
+export function sanitizeName(input) {
+  if (!input || typeof input !== "string") {
+    throw new Error("Name is required.");
+  }
+  const trimmed = input.trim();
+  if (!/^[a-zA-Z][a-zA-Z0-9_-]*$/.test(trimmed)) {
+    throw new Error(
+      `Invalid name "${trimmed}". Use only letters, numbers, hyphens, and underscores. Must start with a letter.`
+    );
+  }
+  return trimmed;
+}