4bnode 3.5.3 → 4.0.2

package/lib/indexFile.js

@@ -0,0 +1,134 @@
+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"
+      );
+    } else if (content.match(/^startServer\(/m)) {
+      content = content.replace(
+        /^startServer\(/m,
+        useLine.trim() + "\n" + "startServer("
+      );
+    }
+  }
+
+  writeIndex(content);
+}
+
+export function insertBeforeListen(codeBlock) {
+  let content = readIndex();
+  const listenMatch = content.match(/(app|server)\.listen\(port/) || content.match(/^startServer\(/m);
+  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();
+
+  // If using startServer() pattern, just swap app.listen → server.listen inside it
+  if (content.includes("startServer(")) {
+    content = content.replace(
+      /const listener = app\.listen\(tryPort\)/,
+      "const listener = server.listen(tryPort)"
+    );
+    // Also swap standalone app.listen(tryPort) if no 'const listener' pattern
+    if (!content.includes("server.listen(tryPort)")) {
+      content = content.replace(
+        /app\.listen\(tryPort\)/,
+        "server.listen(tryPort)"
+      );
+    }
+  } else {
+    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();
+
+  // Insert before startServer() or the start server section
+  const markers = [
+    "// ── Start Server",
+    "// ── Helpers",
+    "startServer(",
+  ];
+  let inserted = false;
+  for (const marker of markers) {
+    const idx = content.indexOf(marker);
+    if (idx !== -1) {
+      content =
+        content.slice(0, idx) +
+        codeBlock.trim() +
+        "\n\n" +
+        content.slice(idx);
+      inserted = true;
+      break;
+    }
+  }
+
+  if (!inserted) {
+    // Fallback: before first app.use that isn't middleware
+    const routeUseMatch = content.match(/app\.use\(['"]\/(?!_dev)/);
+    if (routeUseMatch) {
+      const idx = content.indexOf(routeUseMatch[0]);
+      content =
+        content.slice(0, idx) +
+        codeBlock.trim() +
+        "\n\n" +
+        content.slice(idx);
+    } 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;
+}

package/lib/project.js

@@ -0,0 +1,122 @@
+import fs from "fs";
+import path from "path";
+
+export function getProjectRoot() {
+  return process.cwd();
+}
+
+export function listRoutes() {
+  const routesDir = path.join(getProjectRoot(), "src", "routes");
+  if (!fs.existsSync(routesDir)) {
+    return [];
+  }
+  return fs.readdirSync(routesDir).filter((f) => f.endsWith(".js"));
+}
+
+export function listModels() {
+  const modelsDir = path.join(getProjectRoot(), "src", "models");
+  if (!fs.existsSync(modelsDir)) {
+    return [];
+  }
+  return fs.readdirSync(modelsDir).filter((f) => f.endsWith(".js"));
+}
+
+function extractSchemaBlock(content) {
+  const marker = "new mongoose.Schema(";
+  const idx = content.indexOf(marker);
+  if (idx === -1) return null;
+  // Find the opening { after the marker
+  const braceStart = content.indexOf("{", idx + marker.length);
+  if (braceStart === -1) return null;
+  // Match balanced braces to find the outer schema object
+  let depth = 0;
+  for (let i = braceStart; i < content.length; i++) {
+    if (content[i] === "{") depth++;
+    else if (content[i] === "}") {
+      depth--;
+      if (depth === 0) return content.slice(braceStart + 1, i);
+    }
+  }
+  return null;
+}
+
+export function getModelSchema(modelName, { includeId = false } = {}) {
+  const modelFilePath = path.join(
+    getProjectRoot(),
+    "src",
+    "models",
+    modelName + ".js"
+  );
+  if (!fs.existsSync(modelFilePath)) {
+    return [];
+  }
+
+  const content = fs.readFileSync(modelFilePath, "utf8");
+  const schemaContent = extractSchemaBlock(content);
+
+  if (!schemaContent) {
+    return [];
+  }
+
+  const fieldRegex = /(\w+)\s*:\s*\{/g;
+  const fields = includeId ? ["_id"] : [];
+  let fieldMatch;
+  while ((fieldMatch = fieldRegex.exec(schemaContent)) !== null) {
+    fields.push(fieldMatch[1]);
+  }
+  return fields;
+}
+
+export function getModelSchemaDetailed(modelName) {
+  const modelFilePath = path.join(
+    getProjectRoot(),
+    "src",
+    "models",
+    modelName + ".js"
+  );
+  if (!fs.existsSync(modelFilePath)) {
+    return [];
+  }
+
+  const content = fs.readFileSync(modelFilePath, "utf8");
+  const schemaContent = extractSchemaBlock(content);
+  if (!schemaContent) return [];
+  const fields = [];
+  // Match each field block: fieldName: { type: ..., required: ..., unique: ..., default: ... }
+  const fieldRegex = /(\w+)\s*:\s*\{([^}]*)\}/g;
+  let fm;
+  while ((fm = fieldRegex.exec(schemaContent)) !== null) {
+    const name = fm[1];
+    const props = fm[2];
+    const typeMatch = props.match(/type:\s*([\w.]+)/);
+    const type = typeMatch
+      ? typeMatch[1].replace("mongoose.Schema.Types.", "")
+      : "String";
+    const required = /required:\s*true/.test(props);
+    const unique = /unique:\s*true/.test(props);
+    const defaultMatch = props.match(/default:\s*(.+?)(?:,\s*\w+:|$)/);
+    const field = { name, type, required, unique };
+    if (defaultMatch) {
+      field.default = defaultMatch[1].trim();
+    }
+    fields.push(field);
+  }
+  return fields;
+}
+
+export function checkMongoConfig() {
+  const envPath = path.join(getProjectRoot(), ".env.development");
+  return (
+    fs.existsSync(envPath) &&
+    fs.readFileSync(envPath, "utf8").includes("MONGO_URI")
+  );
+}
+
+export function checkRoutesDir() {
+  return fs.existsSync(path.join(getProjectRoot(), "src", "routes"));
+}
+
+export function checkModelsExist() {
+  const modelsDir = path.join(getProjectRoot(), "src", "models");
+  return fs.existsSync(modelsDir) && fs.readdirSync(modelsDir).length > 0;
+}

package/lib/routeFile.js

@@ -0,0 +1,56 @@
+import fs from "fs";
+import path from "path";
+import { getProjectRoot } from "./project.js";
+
+export function getRouteFilePath(routeFile) {
+  return path.join(getProjectRoot(), "src", "routes", routeFile);
+}
+
+export function addImportToRoute(routeFilePath, importStatement) {
+  let content = fs.readFileSync(routeFilePath, "utf8");
+  if (!content.includes(importStatement.trim())) {
+    content = importStatement.trim() + "\n" + content;
+    fs.writeFileSync(routeFilePath, content, "utf8");
+  }
+  return content;
+}
+
+export function insertCodeIntoRoute(routeFilePath, codeBlock) {
+  let content = fs.readFileSync(routeFilePath, "utf8");
+
+  // Prefer inserting before "export default router;" as it's more reliable
+  const exportIndex = content.lastIndexOf("export default router;");
+  if (exportIndex !== -1) {
+    content =
+      content.slice(0, exportIndex) +
+      codeBlock.trim() +
+      "\n\n" +
+      content.slice(exportIndex);
+  } else {
+    // Fallback to inserting before last "});"
+    const lastClose = content.lastIndexOf("});");
+    if (lastClose !== -1) {
+      content =
+        content.slice(0, lastClose) +
+        codeBlock.trim() +
+        "\n" +
+        content.slice(lastClose);
+    } else {
+      content += "\n" + codeBlock.trim() + "\n";
+    }
+  }
+
+  fs.writeFileSync(routeFilePath, content, "utf8");
+}
+
+export function detectHttpMethod(routeFilePath) {
+  const content = fs.readFileSync(routeFilePath, "utf8");
+  const methodRegex =
+    /router\.(get|post|put|patch|delete)\((['"`])\/.*?\2,\s*async\s*\(req,\s*res/;
+  const match = content.match(methodRegex);
+  return match ? match[1].toLowerCase() : "post";
+}
+
+export function getRequestDataSource(method) {
+  return method === "get" || method === "delete" ? "req.query" : "req.body";
+}

package/lib/ui.js

@@ -0,0 +1,161 @@
+import chalk from "chalk";
+import gradient from "gradient-string";
+import ora from "ora";
+
+// Brand gradients
+const brand = gradient(["#00c6ff", "#0072ff", "#7b2ff7"]);
+const warm = gradient(["#f7971e", "#ffd200"]);
+const cool = gradient(["#00f260", "#0575e6"]);
+const fire = gradient(["#ff416c", "#ff4b2b"]);
+
+// Colors
+const dim = chalk.gray;
+const accent = chalk.hex("#00c6ff");
+const highlight = chalk.hex("#ffd200").bold;
+const success = chalk.hex("#00f260").bold;
+const warn = chalk.hex("#ffd200");
+const err = chalk.hex("#ff416c").bold;
+const info = chalk.hex("#0575e6");
+const muted = chalk.hex("#888888");
+const white = chalk.white;
+const bold = chalk.white.bold;
+
+const line = dim("  ─────────────────────────────────────────────────────");
+
+const banner = `
+  ██╗  ██╗██████╗ ███╗   ██╗ ██████╗ ██████╗ ███████╗
+  ██║  ██║██╔══██╗████╗  ██║██╔═══██╗██╔══██╗██╔════╝
+  ███████║██████╔╝██╔██╗ ██║██║   ██║██║  ██║█████╗
+  ╚════██║██╔══██╗██║╚██╗██║██║   ██║██║  ██║██╔══╝
+       ██║██████╔╝██║ ╚████║╚██████╔╝██████╔╝███████╗
+       ╚═╝╚═════╝ ╚═╝  ╚═══╝ ╚═════╝ ╚═════╝ ╚══════╝`;
+
+// ── Banner ──────────────────────────────────────────
+
+export function showBanner() {
+  console.log(brand(banner));
+  console.log(line);
+  console.log(
+    dim("  ") + bold("4Brains Technologies") + dim(" | Node.js Project Generator")
+  );
+  console.log(line + "\n");
+}
+
+// ── Section Header ──────────────────────────────────
+
+export function showHeader(command, description) {
+  console.log();
+  console.log(dim("  ┌─────────────────────────────────────────────────┐"));
+  console.log(
+    dim("  │ ") + accent("◆ ") + highlight(command) + dim("  ") + white(description) + dim("  │")
+  );
+  console.log(dim("  └─────────────────────────────────────────────────┘"));
+  console.log();
+}
+
+// ── Spinners ────────────────────────────────────────
+
+export function createSpinner(text) {
+  return ora({
+    text: muted(text),
+    spinner: "dots12",
+    color: "cyan",
+    indent: 2,
+  });
+}
+
+// ── Step indicators ─────────────────────────────────
+
+export function showStep(step, total, text) {
+  const progress = accent(`[${step}/${total}]`);
+  console.log(`  ${progress} ${white(text)}`);
+}
+
+// ── Success ─────────────────────────────────────────
+
+export function showSuccess(lines) {
+  console.log();
+  console.log(dim("  ┌─────────────────────────────────────────────────┐"));
+  console.log(dim("  │") + success("  ✔ Done!") + dim(new Array(42).join(" ") + "│"));
+  console.log(dim("  └─────────────────────────────────────────────────┘"));
+  console.log();
+  for (const l of lines) {
+    console.log(dim("  │ ") + white(l));
+  }
+  console.log();
+}
+
+// ── Task complete (for add-* commands) ──────────────
+
+export function showTaskDone(title, details = []) {
+  console.log();
+  console.log(`  ${success("✔")} ${cool(title)}`);
+  for (const d of details) {
+    console.log(`    ${dim("→")} ${muted(d)}`);
+  }
+  console.log();
+}
+
+// ── Warning ─────────────────────────────────────────
+
+export function showWarning(message) {
+  console.log(`\n  ${warn("⚠")} ${warn(message)}\n`);
+}
+
+// ── Error ───────────────────────────────────────────
+
+export function showError(message) {
+  console.log(`\n  ${err("✖")} ${err(message)}\n`);
+}
+
+// ── Info ────────────────────────────────────────────
+
+export function showInfo(message) {
+  console.log(`  ${info("ℹ")} ${muted(message)}`);
+}
+
+// ── Next Steps ──────────────────────────────────────
+
+export function showNextSteps(steps) {
+  console.log(accent.bold("  Next steps:\n"));
+  for (let i = 0; i < steps.length; i++) {
+    const num = highlight(` ${i + 1} `);
+    console.log(`  ${num} ${white(steps[i])}`);
+  }
+  console.log();
+  console.log(line);
+  console.log(dim("  Happy coding! ") + brand("★ 4Brains"));
+  console.log(line + "\n");
+}
+
+// ── Installing deps (with spinner) ──────────────────
+
+export async function installDeps(packages, opts = {}) {
+  const { execSync } = await import("child_process");
+  const names = Array.isArray(packages) ? packages : [packages];
+  const label = names.join(", ");
+  const spinner = createSpinner(`Installing ${label}...`);
+  spinner.start();
+  try {
+    execSync(`npm install ${names.join(" ")}`, {
+      stdio: "pipe",
+      ...opts,
+    });
+    spinner.succeed(success(`Installed ${label}`));
+  } catch (e) {
+    spinner.fail(err(`Failed to install ${label}`));
+    throw e;
+  }
+}
+
+// ── File action log ─────────────────────────────────
+
+export function showFileAction(action, filePath) {
+  const icons = {
+    created: chalk.hex("#00f260")("+ "),
+    updated: chalk.hex("#0575e6")("~ "),
+    deleted: chalk.hex("#ff416c")("- "),
+  };
+  const icon = icons[action] || dim("  ");
+  console.log(`  ${icon}${muted(filePath)}`);
+}

package/package.json

@@ -1,28 +1,18 @@
 {
   "name": "4bnode",
-  "version": "3.5.3",
-  "description": "A CLI tool to generate a Node.js app by 4Brains Technologies",
+  "version": "4.0.2",
+  "description": "A professional tool to generate a Node.js app by 4Brains Technologies",
   "main": "index.js",
   "type": "module",
   "bin": {
-    "4bnode": "index.js",
-    "add-api": "add-api.js",
-    "add-mongo": "add-mongo.js",
-    "add-socket": "add-socket.js",
-    "add-websocket": "add-websocket.js",
-    "add-mongo-schema": "add-mongo-schema.js",
-    "add-login": "add-login.js",
-    "add-mongo-insert": "add-mongo-insert.js",
-    "add-mongo-update": "add-mongo-update.js",
-    "add-mongo-read": "add-mongo-read.js",
-    "add-mongo-delete": "add-mongo-delete.js"
+    "4bnode": "index.js"
   },
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1"
   },
   "repository": {
     "type": "git",
-    "url": "https://github.com/pawan-4brains/4brains-node-generator"
+    "url": "https://github.com/pawan-4brains/4bnode"
   },
   "keywords": [
     "node",
@@ -33,8 +23,11 @@
     "Node.js skeleton"
   ],
   "author": "4Brains",
-  "license": "ISC",
+  "license": "Proprietary",
   "dependencies": {
-    "chalk": "^5.3.0"
+    "@inquirer/prompts": "^8.3.0",
+    "chalk": "^5.4.1",
+    "gradient-string": "^3.0.0",
+    "ora": "^9.3.0"
   }
 }

package/skeleton/.4bnode/assets/js/App.js

@@ -0,0 +1,115 @@
+import React, { useState, useEffect, useCallback } from "react";
+import { motion, AnimatePresence } from "framer-motion";
+import { html, api, PAGE_TITLES } from "./lib.js";
+import { AppContext } from "./context.js";
+import { Sidebar } from "./components/Sidebar.js";
+import { ToastContainer } from "./components/ToastContainer.js";
+import { ConfirmDialog } from "./components/Modal.js";
+import { DashboardPage } from "./pages/DashboardPage.js";
+import { DatabasePage } from "./pages/DatabasePage.js";
+import { SchemasPage } from "./pages/SchemasPage.js";
+import { RoutesPage } from "./pages/RoutesPage.js";
+import { ApiTesterPage } from "./pages/ApiTesterPage.js";
+import { RealtimePage } from "./pages/RealtimePage.js";
+import { SerialPortPage } from "./pages/SerialPortPage.js";
+import { EnvironmentPage } from "./pages/EnvironmentPage.js";
+
+function getHashPage() {
+  const hash = window.location.hash.replace("#/", "").replace("#", "");
+  return hash && PAGE_TITLES[hash] ? hash : "dashboard";
+}
+
+export function App() {
+  const [page, setPageState] = useState(getHashPage);
+  const [data, setData] = useState({
+    models: [],
+    routes: [],
+    mongoConfigured: false,
+    routesDirExists: false,
+  });
+  const [status, setStatus] = useState({});
+  const [toasts, setToasts] = useState([]);
+  const [confirmState, setConfirmState] = useState(null);
+
+  const showConfirm = useCallback((message, opts = {}) => {
+    return new Promise((resolve) => {
+      setConfirmState({ message, ...opts, resolve });
+    });
+  }, []);
+
+  const setPage = useCallback((p) => {
+    window.location.hash = "#/" + p;
+  }, []);
+
+  useEffect(() => {
+    function onHash() {
+      setPageState(getHashPage());
+    }
+    window.addEventListener("hashchange", onHash);
+    return () => window.removeEventListener("hashchange", onHash);
+  }, []);
+
+  const toast = useCallback((message, type = "info") => {
+    const id = Date.now();
+    setToasts((prev) => [...prev, { id, message, type }]);
+    setTimeout(
+      () => setToasts((prev) => prev.filter((t) => t.id !== id)),
+      3500,
+    );
+  }, []);
+
+  const refresh = useCallback(async () => {
+    const [dashData, statusData] = await Promise.all([
+      api("/dashboard"),
+      api("/status"),
+    ]);
+    setData(dashData);
+    setStatus(statusData);
+  }, []);
+
+  useEffect(() => {
+    refresh().catch(() => {});
+  }, []);
+
+  const pages = {
+    dashboard: html`<${DashboardPage} />`,
+    database: html`<${DatabasePage} />`,
+    schemas: html`<${SchemasPage} />`,
+    routes: html`<${RoutesPage} />`,
+    "api-tester": html`<${ApiTesterPage} />`,
+    realtime: html`<${RealtimePage} />`,
+    serialport: html`<${SerialPortPage} />`,
+    env: html`<${EnvironmentPage} />`,
+  };
+
+  return html`<${AppContext.Provider}
+    value=${{ page, setPage, data, status, toasts, toast, refresh, showConfirm }}
+  >
+    <${Sidebar} />
+    <div className="main">
+      <div className="topbar">
+        <h2>${PAGE_TITLES[page] || "Dashboard"}</h2>
+        <span className="topbar-badge">Development</span>
+      </div>
+      <div className="content">
+        <${AnimatePresence} mode="wait">
+          <${motion.div} key=${page}
+            initial=${{ opacity: 0, y: 8 }}
+            animate=${{ opacity: 1, y: 0 }}
+            exit=${{ opacity: 0, y: -8 }}
+            transition=${{ duration: 0.15 }}>
+            ${pages[page] || pages.dashboard}
+          <//>
+        <//>
+      </div>
+    </div>
+    <${ToastContainer} />
+    ${confirmState && html`<${ConfirmDialog}
+      message=${confirmState.message}
+      confirmLabel=${confirmState.confirmLabel}
+      danger=${confirmState.danger}
+      onConfirm=${() => { confirmState.resolve(true); setConfirmState(null); }}
+      onCancel=${() => { confirmState.resolve(false); setConfirmState(null); }}
+    />`}
+  <//>`;
+}