4bnode 4.1.0 → 4.1.2

package/README.md

@@ -9,7 +9,7 @@
        ╚═╝╚═════╝ ╚═╝  ╚═══╝ ╚═════╝ ╚═════╝ ╚══════╝
 ```
 
-A professional CLI tool and visual dashboard to generate, manage, and test Node.js/Express applications.
+A CLI to generate, manage, and test Node.js/Express applications.
 
 Built by [4Brains Technologies](https://4brains.in).
 
@@ -21,226 +21,45 @@ cd my-app
 npm run dev
 ```
 
-Your app runs at `http://localhost:3000` with a built-in visual dashboard at `http://localhost:3000/_dev`.
+Your app runs at `http://localhost:3000`.
 
-## CLI Commands
-
-### Create a Project
+## Commands
 
 ```sh
-npx 4bnode init <name>
+npx 4bnode add        # interactive menu
 ```
 
-Scaffolds a new Express project with:
-- ES Module syntax
-- Environment config (`.env.development`, `.env.production`)
-- CORS, JSON body parser (50MB limit)
-- Static file serving from `public/`
-- Built-in dev dashboard at `/_dev`
-
-### Add Features
-
-Use the interactive menu:
-
-```sh
-npx 4bnode add
-```
-
-Or add directly:
-
 | Command | Description |
 |---------|-------------|
-| `4bnode add api <name>` | Create a new API endpoint |
-| `4bnode add mongo` | Configure MongoDB connection |
+| `4bnode init <name>` | Scaffold a new Express project |
+| `4bnode add api <name>` | Create an API endpoint |
+| `4bnode add mongo` | Configure MongoDB |
 | `4bnode add crud` | Add CRUD operations to a route |
-| `4bnode add login` | Add JWT authentication & login |
-| `4bnode add socket` | Integrate Socket.IO |
-| `4bnode add websocket` | Add native WebSocket support |
+| `4bnode add login` | JWT authentication & login |
+| `4bnode add docs` | OpenAPI docs at `/docs` |
+| `4bnode add security` | Helmet, rate-limit, RBAC, API keys, validation |
+| `4bnode add email` | Transactional email |
+| `4bnode add socket` | Socket.IO |
+| `4bnode add websocket` | Native WebSocket |
 | `4bnode add serialport` | Serial port communication |
+| `4bnode schema [name]` | Create / edit Mongoose schemas |
+| `4bnode list` | Show models, routes & config |
 
-### API Endpoint Creation
-
-```sh
-4bnode add api users
-```
-
-When creating an API endpoint:
-- Select HTTP method (GET, POST, PUT, DELETE, PATCH)
-- Choose fields from existing model (if available)
-- Add custom fields received from client
-- File fields auto-configure `multer` for multipart uploads
-- All routes use `/api/` prefix
-
-### Schema Management
-
-```sh
-4bnode schema              # Interactive create/view/edit
-4bnode schema user         # Create or edit 'user' schema
-```
-
-Supported field types: `String`, `Number`, `Boolean`, `Date`, `Array`, `ObjectId`, `Mixed`, `Buffer`
-
-Field constraints: `required`, `unique`, `default`
-
-Presets available: `user`, `product`, `post`
-
-### List Project Info
-
-```sh
-4bnode list                # Show all models, routes & config
-4bnode list models         # List models only
-4bnode list routes         # List routes only
-```
-
-### Dashboard Passkey
-
-During `npx 4bnode init`, you'll be prompted to set a 6-digit passkey to protect the dev dashboard.
-
-To change the passkey later, run inside your project:
-
-```sh
-4bnode passkey
-```
-
-### Start Dev Dashboard
-
-```sh
-4bnode ui
-```
-
-Runs `npm run dev` and opens the visual dashboard. Must be run inside a 4bnode project.
-
-## Visual Dashboard
-
-Access at `http://localhost:3000/_dev` when running `npm run dev`.
-
-### Dashboard Features
-
-**Overview** - Project status, configured features, quick stats
-
-**Database** - MongoDB connection setup, URI management
-
-**Schemas** - Create, view, edit MongoDB schemas with field management. Add/remove fields, toggle required/unique, set defaults.
-
-**API Routes** - Full route management:
-- Create new routes (Methods, CRUD, Login, Register)
-- Add methods to existing routes with field selection
-- Select fields from models or add custom fields
-- File upload fields auto-configure multer
-- View route source code, edit inline
-- Share endpoint docs with frontend team (Markdown format)
-- Delete routes (removes file + index.js registration)
-
-**API Tester** - Built-in Postman-like API testing tool:
-- REST API, Socket.IO, and WebSocket testing
-- **Body types**: JSON, Form Data, URL Encoded, Raw, Binary
-- **File uploads**: Choose file, send as File or Base64
-- **Auto-detect fields**: Matches URL to route and pre-fills body/form fields from route code
-- **Path variables**: Auto-detects `:id` params, shows editable fields
-- **Query params**: Key-value editor, auto-fills from `req.query`
-- **Headers**: Key-value editor with quick presets (Bearer Auth, JSON, Form Data, URL Encoded, Accept)
-- **Response viewer**: Body + Headers tabs, copy response, save responses
-- **Collection management**: Save requests, organize with responses, delete with confirmation
-- **Share collection**: Generate shareable API documentation page with:
-  - Endpoint details, headers, body fields
-  - Code examples (cURL, Fetch, Axios) with copy button
-  - Form data / file upload code generation
-  - Saved response examples
-  - Search/filter endpoints
-  - Persistent URL (updates on re-share)
-- **Import from routes**: One-click import endpoints from your project routes
-- All data persisted in `.4bnode/` JSON files (not localStorage)
-
-**Real-time** - Socket.IO and WebSocket configuration
-
-**SerialPort** - Serial port setup with path and baud rate config
-
-**Reports** - Export MongoDB data as Excel (.xlsx) reports:
-- Select models and fields to include
-- Include system fields (_id, createdAt, updatedAt)
-- Populate referenced ObjectId fields with sub-field selection
-- Custom column headers and field prefixes
-- Drag-and-drop column reordering
-- Configurable date format and timezone
-- Set row limit for large collections
-- Preview data before downloading
-- Download as `.xlsx` file
-
-**Logs** - Real-time server log monitoring:
-- Live log streaming via SSE (Server-Sent Events)
-- Filter by log type (LOG, INFO, WARN, ERROR)
-- Search through log entries
-- Auto-scroll with toggle
-- Keeps last 500 log entries
-
-**Environment** - View and edit `.env.development` and `.env.production`
-
-## Generated Project Structure
+## Project Structure
 
 ```
 my-app/
-├── index.js                    # Express app entry point
-├── package.json
-├── .env.development            # Dev environment variables
-├── .env.production             # Production environment variables
-├── .4bnode/                    # Dashboard engine & data (managed by 4bnode)
-├── public/                     # Static files
-│   └── index.html              # App status landing page
+├── index.js            # Express entry point
+├── .env.development
+├── .env.production
+├── public/             # static files
 └── src/
-    ├── db.js                   # MongoDB connection (after `add mongo`)
-    ├── models/                 # Mongoose schemas
-    └── routes/                 # API route files
-```
-
-## Real-time Communication
-
-### Socket.IO
-
-```sh
-4bnode add socket
-```
-
-Access in routes via `req.io`:
-
-```js
-router.get('/notify', (req, res) => {
-  req.io.emit('message', 'Hello from server');
-  res.json({ sent: true });
-});
-```
-
-### WebSocket
-
-```sh
-4bnode add websocket
-```
-
-Access in routes via `req.wss`:
-
-```js
-router.get('/broadcast', (req, res) => {
-  req.wss.clients.forEach(client => {
-    if (client.readyState === WebSocket.OPEN) {
-      client.send('Hello from server');
-    }
-  });
-  res.json({ sent: true });
-});
-```
-
-## Help
-
-```sh
-4bnode -h
-4bnode --help
+    ├── db.js           # MongoDB connection
+    ├── models/         # Mongoose schemas
+    └── routes/         # API routes
 ```
 
 ## License
 
-Proprietary License
-
-(c) 2025 4Brains Technologies. All rights reserved.
-
-Unauthorized copying, distribution, modification, or use of this code is strictly prohibited.
-
-For licensing or commercial use: contact@4brains.in
+Proprietary. © 2025 4Brains Technologies. All rights reserved.
+Unauthorized copying, distribution, or use is prohibited. contact@4brains.in

package/add-crud.js

@@ -18,112 +18,12 @@ import {
   showFileAction,
   installDeps,
 } from "./lib/ui.js";
-
-function buildInsertCode(pascalName, fields, dataSource) {
-  const assignments = fields
-    .map((f) => `    ${f}: ${dataSource}.${f}`)
-    .join(",\n");
-
-  let passwordLogic = "";
-  if (fields.includes("password")) {
-    passwordLogic = `
-  if (newData.password) {
-    const salt = await bcrypt.genSalt(10);
-    newData.password = await bcrypt.hash(newData.password, salt);
-  }`;
-  }
-
-  return `
-router.post('/create', async (req, res) => {
-  const newData = {
-${assignments}
-  };
-${passwordLogic}
-  try {
-    const newDocument = new ${pascalName}(newData);
-    await newDocument.save();
-    res.json({ message: 'Data inserted successfully', data: newDocument });
-  } catch (err) {
-    console.error(err);
-    res.status(500).json({ message: 'Server error' });
-  }
-});`;
-}
-
-function buildReadCode(pascalName) {
-  return `
-router.get('/', async (req, res) => {
-  try {
-    const documents = await ${pascalName}.find();
-    res.json({ data: documents });
-  } catch (err) {
-    console.error(err);
-    res.status(500).json({ message: 'Server error' });
-  }
-});
-
-router.get('/:id', async (req, res) => {
-  try {
-    const document = await ${pascalName}.findById(req.params.id);
-    if (!document) {
-      return res.status(404).json({ message: 'Document not found' });
-    }
-    res.json({ data: document });
-  } catch (err) {
-    console.error(err);
-    res.status(500).json({ message: 'Server error' });
-  }
-});`;
-}
-
-function buildUpdateCode(pascalName, fields, dataSource) {
-  const assignments = fields
-    .map((f) => `    ${f}: ${dataSource}.${f}`)
-    .join(",\n");
-
-  let passwordLogic = "";
-  if (fields.includes("password")) {
-    passwordLogic = `
-  if (updatedData.password) {
-    const salt = await bcrypt.genSalt(10);
-    updatedData.password = await bcrypt.hash(updatedData.password, salt);
-  }`;
-  }
-
-  return `
-router.put('/:id', async (req, res) => {
-  const updatedData = {
-${assignments}
-  };
-${passwordLogic}
-  try {
-    const updatedDocument = await ${pascalName}.findByIdAndUpdate(req.params.id, updatedData, { returnDocument: 'after' });
-    if (!updatedDocument) {
-      return res.status(404).json({ message: 'Document not found' });
-    }
-    res.json({ message: 'Data updated successfully', data: updatedDocument });
-  } catch (err) {
-    console.error(err);
-    res.status(500).json({ message: 'Server error' });
-  }
-});`;
-}
-
-function buildDeleteCode(pascalName) {
-  return `
-router.delete('/:id', async (req, res) => {
-  try {
-    const deletedDocument = await ${pascalName}.findByIdAndDelete(req.params.id);
-    if (!deletedDocument) {
-      return res.status(404).json({ message: 'Document not found' });
-    }
-    res.json({ message: 'Data deleted successfully', data: deletedDocument });
-  } catch (err) {
-    console.error(err);
-    res.status(500).json({ message: 'Server error' });
-  }
-});`;
-}
+import {
+  buildInsertCode,
+  buildReadCode,
+  buildUpdateCode,
+  buildDeleteCode,
+} from "./lib/codegen.js";
 
 async function main() {
   showHeader("add-crud", "Add CRUD operations to a route");

package/add-docs.js

@@ -0,0 +1,91 @@
+#!/usr/bin/env node
+
+import fs from "fs";
+import path from "path";
+import { getProjectRoot, listRoutes, listModels, getModelSchemaDetailed } from "./lib/project.js";
+import { addRouteRegistration, readIndex } from "./lib/indexFile.js";
+import { showHeader, showTaskDone, showError, showFileAction, showInfo } from "./lib/ui.js";
+import { extractRequestFields, buildOpenApiSpec, buildDocsRouter } from "./lib/codegen.js";
+
+function collectEndpoints() {
+  const root = getProjectRoot();
+  const routesDir = path.join(root, "src", "routes");
+  if (!fs.existsSync(routesDir)) return [];
+  const indexContent = readIndex();
+  const out = [];
+  for (const file of listRoutes()) {
+    const name = path.basename(file, ".js");
+    const content = fs.readFileSync(path.join(routesDir, file), "utf8");
+    let prefix = "/api/" + name;
+    const reg = indexContent.match(new RegExp(`app\\.use\\(['"]([^'"]+)['"]\\s*,\\s*${name}Router`));
+    if (reg) prefix = reg[1];
+    const modelImport = content.match(/import\s+(\w+)\s+from\s+['"]\.\.\/models\/(\w+)(?:\.js)?['"]/);
+    const modelFields = modelImport ? getModelSchemaDetailed(modelImport[2]) : [];
+    const epRegex = /router\.(get|post|put|patch|delete)\(\s*['"`](\/[^'"`]*?)['"`]\s*,([\s\S]*?)(?=\nrouter\.|$)/gi;
+    let m;
+    while ((m = epRegex.exec(content)) !== null) {
+      const method = m[1].toUpperCase();
+      const epath = m[2];
+      const handler = m[3] || "";
+      const bodyFields = extractRequestFields(handler, "body").map((fn) => {
+        const meta = modelFields.find((x) => x.name === fn);
+        return { name: fn, type: meta?.type || "String", required: meta?.required || false };
+      });
+      const queryFields = extractRequestFields(handler, "query").map((fn) => ({ name: fn, type: "String" }));
+      const params = (epath.match(/:(\w+)/g) || []).map((p) => p.slice(1));
+      const fileFields = [];
+      const us = handler.match(/upload\.single\(\s*['"](\w+)['"]/);
+      if (us) fileFields.push({ name: us[1] });
+      const fullPath = (prefix + (epath === "/" ? "" : epath)).replace(/\/+/g, "/");
+      out.push({ method, path: epath, fullPath, bodyFields, queryFields, params, fileFields, hasAuth: /\bauth\b\s*,/.test(m[0]) });
+    }
+  }
+  return out;
+}
+
+function projectTitle() {
+  try {
+    const pkg = JSON.parse(fs.readFileSync(path.join(getProjectRoot(), "package.json"), "utf8"));
+    return (pkg.name || "API") + " API";
+  } catch { return "API"; }
+}
+
+async function main() {
+  showHeader("add-docs", "Generate OpenAPI docs + Swagger UI");
+
+  const root = getProjectRoot();
+  const srcDir = path.join(root, "src");
+  fs.mkdirSync(srcDir, { recursive: true });
+
+  const docsPath = path.join(srcDir, "docs.js");
+  if (!fs.existsSync(docsPath)) {
+    fs.writeFileSync(docsPath, buildDocsRouter(), "utf8");
+    showFileAction("created", "src/docs.js");
+  } else {
+    showInfo("src/docs.js already exists — keeping it.");
+  }
+
+  const endpoints = collectEndpoints();
+  const models = listModels().map((f) => {
+    const name = path.basename(f, ".js");
+    return { name, fields: getModelSchemaDetailed(name) };
+  });
+  const spec = buildOpenApiSpec({ title: projectTitle(), endpoints, models });
+  fs.writeFileSync(path.join(srcDir, "openapi.json"), JSON.stringify(spec, null, 2), "utf8");
+  showFileAction("created", "src/openapi.json");
+
+  addRouteRegistration("import docsRouter from './src/docs.js';", "app.use('/docs', docsRouter);");
+  showFileAction("updated", "index.js");
+
+  showTaskDone("API docs configured", [
+    `${endpoints.length} endpoint${endpoints.length === 1 ? "" : "s"} documented`,
+    "Swagger UI at /docs",
+    "Re-run after changing routes to refresh the spec",
+  ]);
+}
+
+main().catch((err) => {
+  if (err.name === "ExitPromptError") process.exit(0);
+  showError(err.message);
+  process.exit(1);
+});

package/add-email.js

@@ -0,0 +1,63 @@
+#!/usr/bin/env node
+
+import fs from "fs";
+import path from "path";
+import { input, select, confirm, password } from "@inquirer/prompts";
+import { getProjectRoot } from "./lib/project.js";
+import { updateEnvFile } from "./lib/env.js";
+import { showHeader, showTaskDone, showError, showInfo, showFileAction, installDeps } from "./lib/ui.js";
+import { MAIL_PROVIDERS, buildMailerService } from "./lib/codegen.js";
+
+async function main() {
+  showHeader("add-email", "Set up transactional email (nodemailer)");
+
+  const providerId = await select({
+    message: "Email provider:",
+    choices: Object.entries(MAIL_PROVIDERS).map(([id, p]) => ({ name: p.label, value: id })),
+  });
+  const preset = MAIL_PROVIDERS[providerId];
+  if (preset.hint) showInfo(preset.hint);
+
+  const host = (await input({ message: "SMTP host:", default: preset.host || "" })).trim();
+  const port = (await input({ message: "SMTP port:", default: String(preset.port || 587) })).trim();
+  const secure = await confirm({ message: "Use TLS/secure (port 465)?", default: !!preset.secure });
+  const user = (await input({ message: "SMTP user:", default: preset.user || "" })).trim();
+  const pass = (await password({ message: "SMTP password / API key:", mask: "*" })).trim();
+  const from = (await input({ message: "From address:", default: user })).trim();
+
+  console.log();
+
+  const root = getProjectRoot();
+  const dir = path.join(root, "src", "services");
+  fs.mkdirSync(dir, { recursive: true });
+  const mailerPath = path.join(dir, "mailer.js");
+  if (!fs.existsSync(mailerPath)) {
+    fs.writeFileSync(mailerPath, buildMailerService(), "utf8");
+    showFileAction("created", "src/services/mailer.js");
+  } else {
+    showInfo("src/services/mailer.js already exists — keeping it.");
+  }
+
+  const envPath = path.join(root, ".env");
+  updateEnvFile(envPath, "SMTP_HOST", host);
+  updateEnvFile(envPath, "SMTP_PORT", port || "587");
+  updateEnvFile(envPath, "SMTP_SECURE", secure ? "true" : "false");
+  updateEnvFile(envPath, "SMTP_USER", user);
+  if (pass) updateEnvFile(envPath, "SMTP_PASS", pass);
+  updateEnvFile(envPath, "SMTP_FROM", from || user);
+  showFileAction("updated", ".env");
+
+  await installDeps("nodemailer");
+
+  showTaskDone("Email configured", [
+    `Provider: ${preset.label}`,
+    `Host: ${host}:${port || 587}`,
+    "Use sendMail({ to, subject, html }) from src/services/mailer.js",
+  ]);
+}
+
+main().catch((err) => {
+  if (err.name === "ExitPromptError") process.exit(0);
+  showError(err.message);
+  process.exit(1);
+});

package/add-security.js

@@ -0,0 +1,143 @@
+#!/usr/bin/env node
+
+import fs from "fs";
+import path from "path";
+import crypto from "crypto";
+import { checkbox, confirm } from "@inquirer/prompts";
+import { getProjectRoot, listModels, getModelSchemaDetailed } from "./lib/project.js";
+import { updateEnvFile } from "./lib/env.js";
+import { addImport, insertBeforeRoutes, insertBeforeListen } from "./lib/indexFile.js";
+import {
+  showHeader,
+  showTaskDone,
+  showError,
+  showInfo,
+  showFileAction,
+  installDeps,
+} from "./lib/ui.js";
+import {
+  buildErrorHandlerFile,
+  buildRolesGuardFile,
+  buildApiKeyFile,
+  buildValidateFile,
+  buildZodSchemaFile,
+  securityWiring,
+} from "./lib/codegen.js";
+
+function writeFileSafe(relPath, content) {
+  const full = path.join(getProjectRoot(), relPath);
+  fs.mkdirSync(path.dirname(full), { recursive: true });
+  if (fs.existsSync(full)) {
+    showInfo(`${relPath} already exists — skipped.`);
+    return false;
+  }
+  fs.writeFileSync(full, content, "utf8");
+  showFileAction("created", relPath);
+  return true;
+}
+
+async function main() {
+  showHeader("add-security", "Harden your app with security middleware");
+
+  const features = await checkbox({
+    message: "Select protections to add:",
+    choices: [
+      { name: "Helmet            Secure HTTP response headers", value: "helmet", checked: true },
+      { name: "Rate limiting     Throttle requests per IP (express-rate-limit)", value: "rateLimit", checked: true },
+      { name: "Error handler     Central 404 + error JSON responses", value: "errorHandler", checked: true },
+      { name: "RBAC roles        roles('admin') route guard", value: "roles" },
+      { name: "API keys          x-api-key header auth", value: "apiKey" },
+      { name: "Validation        Zod request validation middleware", value: "validation" },
+    ],
+    validate: (v) => (v.length > 0 ? true : "Select at least one protection."),
+  });
+
+  console.log();
+
+  const projectRoot = getProjectRoot();
+  const deps = new Set();
+  const summary = [];
+
+  // ── App-level wiring (helmet / rate limit / error handler) ──
+  const appLevel = features.filter((f) => ["helmet", "rateLimit", "errorHandler"].includes(f));
+  if (appLevel.length) {
+    const wiring = securityWiring(appLevel);
+    wiring.imports.forEach((imp) => addImport(imp));
+    if (wiring.beforeRoutes) insertBeforeRoutes(wiring.beforeRoutes);
+    if (wiring.beforeListen) insertBeforeListen(wiring.beforeListen);
+    showFileAction("updated", "index.js");
+  }
+  if (features.includes("helmet")) { deps.add("helmet"); summary.push("Helmet security headers"); }
+  if (features.includes("rateLimit")) { deps.add("express-rate-limit"); summary.push("Rate limiting (100 req / 15 min per IP)"); }
+
+  // ── Middleware files ──
+  if (features.includes("errorHandler")) {
+    writeFileSafe("src/middleware/errorHandler.js", buildErrorHandlerFile());
+    summary.push("Central error handler");
+  }
+  if (features.includes("roles")) {
+    writeFileSafe("src/middleware/roles.js", buildRolesGuardFile());
+    summary.push("RBAC roles() guard");
+  }
+  if (features.includes("apiKey")) {
+    writeFileSafe("src/middleware/apiKey.js", buildApiKeyFile());
+    const envPath = path.join(projectRoot, ".env");
+    const existing = fs.existsSync(envPath) ? fs.readFileSync(envPath, "utf8") : "";
+    if (!/^API_KEYS=/m.test(existing)) {
+      const key = crypto.randomBytes(24).toString("hex");
+      updateEnvFile(envPath, "API_KEYS", key);
+      showFileAction("updated", ".env");
+      showInfo(`Generated API key: ${key}`);
+    }
+    summary.push("API key auth (x-api-key)");
+  }
+
+  // ── Validation (Zod) ──
+  if (features.includes("validation")) {
+    deps.add("zod");
+    writeFileSafe("src/middleware/validate.js", buildValidateFile());
+
+    const models = listModels().map((f) => path.basename(f, ".js"));
+    let generatedValidators = 0;
+    if (models.length) {
+      const wantValidators = await confirm({
+        message: "Generate Zod validators from existing models?",
+        default: true,
+      });
+      if (wantValidators) {
+        const chosen = await checkbox({
+          message: "Select models to generate validators for:",
+          choices: models.map((m) => ({ name: m, value: m, checked: true })),
+        });
+        for (const m of chosen) {
+          const fields = getModelSchemaDetailed(m);
+          if (!fields.length) {
+            showInfo(`${m}: no fields found — skipped.`);
+            continue;
+          }
+          if (writeFileSafe(`src/validators/${m}.js`, buildZodSchemaFile(m, fields))) {
+            generatedValidators++;
+          }
+        }
+      }
+    }
+    summary.push(
+      generatedValidators > 0
+        ? `Zod validation (+ ${generatedValidators} model validator${generatedValidators > 1 ? "s" : ""})`
+        : "Zod validation middleware"
+    );
+  }
+
+  if (deps.size) {
+    console.log();
+    await installDeps([...deps]);
+  }
+
+  showTaskDone("Security & middleware configured", summary);
+}
+
+main().catch((err) => {
+  if (err.name === "ExitPromptError") process.exit(0);
+  showError(err.message);
+  process.exit(1);
+});