create-node-prodkit 1.0.0

package/bin/create.js

@@ -0,0 +1,108 @@
+#!/usr/bin/env node
+
+import { existsSync, mkdirSync, readdirSync, statSync, readFileSync, writeFileSync } from "fs";
+import { join, dirname } from "path";
+import { fileURLToPath } from "url";
+import { execSync } from "child_process";
+
+// ─── Helpers ──────────────────────────────────────────────────────────────────
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+const green  = (t) => `\x1b[32m${t}\x1b[0m`;
+const cyan   = (t) => `\x1b[36m${t}\x1b[0m`;
+const yellow = (t) => `\x1b[33m${t}\x1b[0m`;
+const bold   = (t) => `\x1b[1m${t}\x1b[0m`;
+const dim    = (t) => `\x1b[2m${t}\x1b[0m`;
+
+// ─── Argument parsing ─────────────────────────────────────────────────────────
+
+const projectName = process.argv[2];
+
+if (!projectName) {
+  console.error(`
+  ${bold("Usage:")}
+    npx create-node-prodkit ${cyan("<project-name>")}
+
+  ${bold("Example:")}
+    npx create-node-prodkit my-api
+`);
+  process.exit(1);
+}
+
+if (!/^[a-z0-9-_]+$/i.test(projectName)) {
+  console.error(`\n  Project name "${projectName}" contains invalid characters.\n  Use only letters, numbers, hyphens, and underscores.\n`);
+  process.exit(1);
+}
+
+const targetDir = join(process.cwd(), projectName);
+
+if (existsSync(targetDir)) {
+  console.error(`\n  Directory "${projectName}" already exists. Choose a different name.\n`);
+  process.exit(1);
+}
+
+// ─── File copy ────────────────────────────────────────────────────────────────
+
+const templateDir = join(__dirname, "../templates");
+
+// Files where {{PROJECT_NAME}} should be replaced
+const PLACEHOLDER_FILES = new Set(["package.json"]);
+
+function copyDir(src, dest) {
+  mkdirSync(dest, { recursive: true });
+
+  for (const entry of readdirSync(src)) {
+    const srcPath  = join(src, entry);
+    const destPath = join(dest, entry);
+
+    if (statSync(srcPath).isDirectory()) {
+      copyDir(srcPath, destPath);
+    } else {
+      let content = readFileSync(srcPath, "utf8");
+
+      if (PLACEHOLDER_FILES.has(entry)) {
+        content = content.replaceAll("{{PROJECT_NAME}}", projectName);
+      }
+
+      // Rename gitignore → .gitignore (npm strips dotfiles from tarballs)
+      const finalDest = entry === "gitignore"
+        ? join(dest, ".gitignore")
+        : destPath;
+
+      writeFileSync(finalDest, content, "utf8");
+    }
+  }
+}
+
+// ─── Bootstrap ────────────────────────────────────────────────────────────────
+
+console.log(`
+  ${bold("create-node-prodkit")}  ${dim("v" + JSON.parse(readFileSync(join(__dirname, "../package.json"), "utf8")).version)}
+
+  Scaffolding project ${cyan(bold(projectName))} ...
+`);
+
+copyDir(templateDir, targetDir);
+console.log(`  ${green("✓")} Files copied`);
+
+console.log(`  ${yellow("⟳")} Installing dependencies ...`);
+
+try {
+  execSync("npm install", { cwd: targetDir, stdio: "inherit" });
+} catch {
+  console.error("\n  npm install failed. Run it manually inside the project.\n");
+  process.exit(1);
+}
+
+console.log(`
+  ${green(bold("✓ Done!"))}  Your project is ready.
+
+  ${dim("Next steps:")}
+
+    ${cyan(`cd ${projectName}`)}
+    ${cyan("cp .env.example .env")}
+    ${cyan("npm run dev")}
+
+  ${dim("Docs:")}  README.md
+`);

package/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "create-node-prodkit",
+  "version": "1.0.0",
+  "description": "Production-grade Node.js + Express skeleton CLI — scaffold a new project in seconds",
+  "license": "ISC",
+  "author": "vinay",
+  "type": "module",
+  "bin": {
+    "create-node-prodkit": "./bin/create.js"
+  },
+  "files": [
+    "bin",
+    "templates",
+    "README.md"
+  ],
+  "scripts": {
+    "dev": "nodemon src/server.js"
+  },
+  "keywords": [
+    "nodejs",
+    "express",
+    "scaffold",
+    "boilerplate",
+    "starter",
+    "cli",
+    "production"
+  ],
+  "nodemonConfig": {
+    "watch": ["src"],
+    "ext": "js,json",
+    "ignore": ["logs/*"],
+    "exec": "node src/server.js"
+  },
+  "dependencies": {
+    "axios": "^1.13.5",
+    "dotenv": "^17.3.1",
+    "express": "^5.2.1",
+    "express-rate-limit": "^8.2.1"
+  },
+  "devDependencies": {
+    "eslint": "^9.39.2",
+    "nodemon": "^3.1.13",
+    "prettier": "^3.8.1"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}

package/templates/.env.example

@@ -0,0 +1,28 @@
+# Server
+PORT=3000
+
+# API
+API_TIMEOUT=5000
+
+# Logging
+# internal → writes to logs/ directory
+# external → POSTs to LOG_SERVICE_URL
+LOG_MODE=internal
+LOG_SERVICE_URL=
+
+# LOG_TYPE controls sensitive field handling in logs
+# 1 = show values as-is   (development)
+# 2 = mask values          (staging)
+# 3 = remove keys entirely (production)
+LOG_TYPE=1
+
+# Database (uncomment and fill in what you need)
+# MONGO_URI=mongodb://localhost:27017/mydb
+# MYSQL_HOST=localhost
+# MYSQL_USER=root
+# MYSQL_PASSWORD=
+# MYSQL_DATABASE=mydb
+# PG_HOST=localhost
+# PG_USER=postgres
+# PG_PASSWORD=
+# PG_DATABASE=mydb

package/templates/gitignore

@@ -0,0 +1,6 @@
+node_modules/
+.env
+logs/
+*.log
+*.backup
+.DS_Store

package/templates/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "{{PROJECT_NAME}}",
+  "version": "1.0.0",
+  "description": "",
+  "license": "ISC",
+  "author": "",
+  "type": "module",
+  "main": "src/server.js",
+  "scripts": {
+    "dev": "nodemon src/server.js",
+    "start": "node src/server.js"
+  },
+  "nodemonConfig": {
+    "watch": ["src"],
+    "ext": "js,json",
+    "ignore": ["logs/*"],
+    "exec": "node src/server.js"
+  },
+  "dependencies": {
+    "axios": "^1.13.5",
+    "dotenv": "^17.3.1",
+    "express": "^5.2.1",
+    "express-rate-limit": "^8.2.1"
+  },
+  "devDependencies": {
+    "eslint": "^9.39.2",
+    "nodemon": "^3.1.13",
+    "prettier": "^3.8.1"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}

package/templates/src/app.js

@@ -0,0 +1,21 @@
+import express from "express";
+import routes from "./routes/index.route.js";
+import { errorMiddleware } from "./middlewares/error.middleware.js";
+import { ipMiddleware } from "./middlewares/ip.middleware.js";
+import { rateLimitMiddleware } from "./middlewares/rateLimit.middleware.js";
+
+const app = express();
+
+app.use(express.json());
+app.use(rateLimitMiddleware);
+app.use(ipMiddleware);
+
+app.get("/", (req, res) => {
+  res.send("Welcome to the API!");
+});
+
+app.use("/api/v1", routes);
+
+app.use(errorMiddleware);
+
+export default app;

package/templates/src/config/app.config.js

@@ -0,0 +1,25 @@
+import dotenv from "dotenv";
+dotenv.config();
+
+export default {
+  port: process.env.PORT || 3000,
+
+  api: {
+    timeout: Number(process.env.API_TIMEOUT) || 5000,
+  },
+
+  rateLimit: {
+    windowMs: 15 * 60 * 1000, // 15 minutes
+    max: 100, // max requests per window per IP
+  },
+
+  logging: {
+    mode: process.env.LOG_MODE || "internal", // internal | external
+    externalUrl: process.env.LOG_SERVICE_URL || "",
+    directory: "logs",
+    fileName: "app",
+    maxSize: 5 * 1024 * 1024,
+    dailyRotate: true,
+    logType: Number(process.env.LOG_TYPE) || 1
+  },
+};

package/templates/src/controllers/sample.controller.js

@@ -0,0 +1,11 @@
+import { asyncHandler } from "../utils/asyncHandler.js";
+import { ResponseUtil } from "../utils/response.util.js";
+import { sampleService } from "../services/sample.service.js";
+
+export const getSample = asyncHandler(async (req, res) => {
+
+  const data = await sampleService();
+
+  return ResponseUtil.success(res, "Posts fetched successfully", data);
+
+});

package/templates/src/db/mongo.db.js

@@ -0,0 +1,14 @@
+// MongoDB connection setup
+// Install: npm install mongoose
+//
+// import mongoose from "mongoose";
+// import config from "../config/app.config.js";
+//
+// export const connectMongo = async () => {
+//   await mongoose.connect(config.db.uri);
+//   console.log("MongoDB connected");
+// };
+//
+// Then in server.js:
+//   import { connectMongo } from "./db/mongo.db.js";
+//   connectMongo().then(() => app.listen(config.port, ...));

package/templates/src/db/mysql.db.js

@@ -0,0 +1,17 @@
+// MySQL connection setup
+// Install: npm install mysql2
+//
+// import mysql from "mysql2/promise";
+// import config from "../config/app.config.js";
+//
+// export const db = mysql.createPool({
+//   host:     config.db.host,
+//   user:     config.db.user,
+//   password: config.db.password,
+//   database: config.db.database,
+// });
+//
+// export const connectMySQL = async () => {
+//   await db.getConnection();
+//   console.log("MySQL connected");
+// };

package/templates/src/db/postgres.db.js

@@ -0,0 +1,20 @@
+// PostgreSQL connection setup
+// Install: npm install pg
+//
+// import pg from "pg";
+// import config from "../config/app.config.js";
+//
+// const { Pool } = pg;
+//
+// export const db = new Pool({
+//   host:     config.db.host,
+//   user:     config.db.user,
+//   password: config.db.password,
+//   database: config.db.database,
+//   port:     config.db.port || 5432,
+// });
+//
+// export const connectPostgres = async () => {
+//   await db.connect();
+//   console.log("PostgreSQL connected");
+// };

package/templates/src/middlewares/encrypt.middleware.js

@@ -0,0 +1,4 @@
+export const encryptMiddleware = (req, res, next) => {
+  // Placeholder for encryption logic
+  next();
+};

package/templates/src/middlewares/error.middleware.js

@@ -0,0 +1,23 @@
+import { ResponseUtil } from "../utils/response.util.js";
+import { logService } from "../utils/log.util.js";
+
+export const errorMiddleware = async (err, req, res, next) => {
+  await logService("error", err.message, {
+    stack: err.stack
+  });
+
+  switch (err.status) {
+    case 400:
+      return ResponseUtil.badRequest(res, err.message);
+    case 401:
+      return ResponseUtil.unauthorized(res, err.message);
+    case 403:
+      return ResponseUtil.forbidden(res, err.message);
+    case 404:
+      return ResponseUtil.notFound(res, err.message);
+    case 422:
+      return ResponseUtil.validation(res, err.message, err.errors);
+    default:
+      return ResponseUtil.exception(res, err.message);
+  }
+};

package/templates/src/middlewares/ip.middleware.js

@@ -0,0 +1,20 @@
+import { ResponseUtil } from "../utils/response.util.js";
+
+export const ipMiddleware = (req, res, next) => {
+  const allowedIps = [
+    "127.0.0.1",
+    "::1",
+    "192.168.1.10"
+  ];
+
+  const clientIp =
+    req.headers["x-forwarded-for"]?.split(",")[0]?.trim() ||
+    req.socket.remoteAddress;
+
+  if (!allowedIps.includes(clientIp)) {
+       return ResponseUtil.forbidden(res, "Access denied: Unauthorized IP address");
+
+  }
+
+  next();
+};

package/templates/src/middlewares/rateLimit.middleware.js

@@ -0,0 +1,18 @@
+import rateLimit from "express-rate-limit";
+import config from "../config/app.config.js";
+import { ResponseUtil } from "../utils/response.util.js";
+
+export const rateLimitMiddleware = rateLimit({
+  windowMs: config.rateLimit.windowMs,
+  max: config.rateLimit.max,
+  standardHeaders: true,
+  legacyHeaders: false,
+
+  handler: (req, res) => {
+    return ResponseUtil.send(
+      res,
+      429,
+      "Too many requests. Please try again later."
+    );
+  }
+});

package/templates/src/repositories/sample.repository.js

@@ -0,0 +1,10 @@
+import { apiCall } from "../utils/axios.util.js";
+
+export const sampleRepository = {
+  getPosts: async () => {
+    return apiCall({
+      method: "GET",
+      url: `https://jsonplaceholder.typicode.com/posts`
+    });
+  }
+};

package/templates/src/routes/index.route.js

@@ -0,0 +1,8 @@
+import express from "express";
+import sampleRoutes from "./sample1.route.js";
+
+const router = express.Router();
+
+router.use("/sample", sampleRoutes);
+
+export default router;

package/templates/src/routes/sample1.route.js

@@ -0,0 +1,8 @@
+import express from "express";
+import { getSample } from "../controllers/sample.controller.js";
+
+const router = express.Router();
+
+router.get("/posts", getSample);
+
+export default router;

package/templates/src/server.js

@@ -0,0 +1,6 @@
+import app from "./app.js";
+import config from "./config/app.config.js";
+
+app.listen(config.port, () => {
+  console.log(`Server running on port: ${config.port}`);
+});

package/templates/src/services/sample.service.js

@@ -0,0 +1,17 @@
+import { sampleRepository } from "../repositories/sample.repository.js";
+import { logService } from "../utils/log.util.js";
+
+export const sampleService = async () => {
+  
+  const data = await sampleRepository.getPosts();
+  await logService("info", "All posts fetched from repository", { count: data.length, posts: data});
+
+  if (!data) {
+    const error = new Error("Data not found");
+    error.status = 404;
+    throw error;
+  }
+
+
+  return data;
+};

package/templates/src/utils/asyncHandler.js

@@ -0,0 +1,5 @@
+export const asyncHandler = (fn) => {
+  return (req, res, next) => {
+    Promise.resolve(fn(req, res, next)).catch(next);
+  };
+};

package/templates/src/utils/axios.util.js

@@ -0,0 +1,19 @@
+import axios from "axios";
+import config from "../config/app.config.js";
+
+export const apiCall = async (options) => {
+  try {
+    const response = await axios({
+      ...options,
+      timeout: config.api.timeout,
+    });
+
+    return response.data;
+  } catch (error) {
+    attempts++;
+
+    if (attempts >= config.api.retries) {
+      throw error;
+    }
+  }
+};

package/templates/src/utils/log.util.js

@@ -0,0 +1,51 @@
+import fs from "fs";
+import path from "path";
+import axios from "axios";
+import config from "../config/app.config.js";
+import { sanitizeLogData } from "./logSanitizer.util.js";
+
+const logDir = config.logging.directory;
+
+if (!fs.existsSync(logDir)) {
+  fs.mkdirSync(logDir);
+}
+
+const getFileName = () => {
+  if (config.logging.dailyRotate) {
+    const date = new Date().toISOString().split("T")[0];
+    return `${config.logging.fileName}-${date}.log`;
+  }
+  return `${config.logging.fileName}.log`;
+};
+
+export const logService = async (level, message, meta = {}) => {
+  const sanitizedMeta = sanitizeLogData(meta);
+
+  const logData = {
+    level,
+    message,
+    timestamp: new Date().toLocaleString("en-IN", { timeZone: "Asia/Kolkata" }),
+    meta: sanitizedMeta,
+  };
+
+  // External log mode
+  if (config.logging.mode === "external" && config.logging.externalUrl) {
+    try {
+      await axios.post(config.logging.externalUrl, logData);
+      return;
+    } catch (err) {
+      console.error("External logging failed");
+    }
+  }
+
+  // Internal file logging
+  const filePath = path.join(logDir, getFileName());
+  const logLine = JSON.stringify(logData) + "\n";
+
+  fs.appendFileSync(filePath, logLine);
+
+  const stats = fs.statSync(filePath);
+  if (stats.size > config.logging.maxSize) {
+    fs.renameSync(filePath, `${filePath}.backup`);
+  }
+};

package/templates/src/utils/logSanitizer.util.js

@@ -0,0 +1,50 @@
+import { sensitiveKeys } from "./sensitiveKeys.util.js";
+import config from "../config/app.config.js";
+
+const maskValue = (value) => {
+  if (typeof value !== "string") return "******";
+  if (value.length <= 4) return "****";
+  return value.slice(0, 2) + "****" + value.slice(-2);
+};
+
+export const sanitizeLogData = (data) => {
+  if (!data || typeof data !== "object") return data;
+
+  const processObject = (obj) => {
+    if (Array.isArray(obj)) {
+      return obj.map(processObject);
+    }
+
+    const newObj = {};
+
+    for (const key in obj) {
+      const value = obj[key];
+
+      if (sensitiveKeys.includes(key)) {
+        // LOG_TYPE 1 → show everything
+        if (config.logging.logType === 1) {
+          newObj[key] = value;
+        }
+
+        // LOG_TYPE 2 → mask
+        else if (config.logging.logType === 2) {
+          newObj[key] = maskValue(value);
+        }
+
+        // LOG_TYPE 3 → remove
+        else if (config.logging.logType === 3) {
+          continue;
+        }
+      } else {
+        newObj[key] =
+          typeof value === "object" && value !== null
+            ? processObject(value)
+            : value;
+      }
+    }
+
+    return newObj;
+  };
+
+  return processObject(data);
+};

package/templates/src/utils/response.util.js

@@ -0,0 +1,43 @@
+export const ResponseUtil = {
+  send(res, statusCode, message, data = null, errors = null) {
+    return res.status(statusCode).json({
+      success: statusCode < 400,
+      statusCode,
+      message,
+      data,
+      errors
+    });
+  },
+
+  success(res, message = "Success", data = null) {
+    return this.send(res, 200, message, data);
+  },
+
+  created(res, message = "Created successfully", data = null) {
+    return this.send(res, 201, message, data);
+  },
+
+  badRequest(res, message = "Bad request", errors = null) {
+    return this.send(res, 400, message, null, errors);
+  },
+
+  unauthorized(res, message = "Unauthorized") {
+    return this.send(res, 401, message);
+  },
+
+  forbidden(res, message = "Forbidden") {
+    return this.send(res, 403, message);
+  },
+
+  notFound(res, message = "Resource not found") {
+    return this.send(res, 404, message);
+  },
+
+  validation(res, message = "Validation failed", errors = []) {
+    return this.send(res, 422, message, null, errors);
+  },
+
+  exception(res, message = "Internal server error") {
+    return this.send(res, 500, message);
+  }
+};

package/templates/src/utils/sensitiveKeys.util.js

@@ -0,0 +1,3 @@
+export const sensitiveKeys = [
+  "userId", "id"
+];