nodexajs 1.0.0

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "nodexajs",
+  "version": "1.0.0",
+  "description": "A scalable Express.js project generator with a standardized architecture",
+  "type": "module",
+  "main": "src/cli.js",
+  "bin": {
+    "nodexa": "./src/cli.js"
+  },
+  "scripts": {
+    "start": "node src/cli.js",
+    "dev": "nodemon src/cli.js"
+  },
+  "keywords": [
+    "nodexa",
+    "nodejs",
+    "express",
+    "expressjs",
+    "cli",
+    "generator",
+    "scaffolding"
+  ],
+  "author": "Dhiraj Mahadik",
+  "license": "MIT",
+  "dependencies": {
+    "commander": "^15.0.0",
+    "inquirer": "^14.2.2"
+  },
+  "devDependencies": {
+    "nodemon": "^3.1.14"
+  }
+}

package/src/cli.js

@@ -0,0 +1,19 @@
+#!/usr/bin/env node
+
+import { Command } from "commander";
+import { initCommand } from "./commands/init.command.js";
+
+const program = new Command();
+
+program
+    .name("nodexa")
+    .description("Nodexa - Node.js and Express.js project generator")
+    .version("0.1.0");
+
+program
+    .command("init")
+    .description("Create a new Express.js project")
+    .argument("<project-name>", "Name of the project")
+    .action(initCommand);
+
+program.parse();

package/src/commands/init.command.js

@@ -0,0 +1,20 @@
+import { generateProject } from "../generators/project.generator.js";
+
+export async function initCommand(projectName) {
+    try {
+        console.log(`\nCreating Nodexa project: ${projectName}\n`);
+
+        await generateProject(projectName);
+
+        console.log("\n✔ Project created successfully!");
+        console.log(`\nNext steps:\n`);
+        console.log(`  cd ${projectName}`);
+        console.log(`  npm install`);
+        console.log(`  npm run dev\n`);
+    } catch (error) {
+        console.error("\n✖ Failed to create project.");
+        console.error(error.message);
+
+        process.exit(1);
+    }
+}

package/src/generators/project.generator.js

@@ -0,0 +1,71 @@
+import fs from "fs/promises";
+import path from "path";
+import { fileURLToPath } from "url";
+import { copyDirectory } from "../utils/file.utils.js";
+import { spawn } from "child_process";
+
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+
+function installDependencies(projectPath) {
+    return new Promise((resolve, reject) => {
+        const npm = spawn("npm", ["install"], {
+            cwd: projectPath,
+            stdio: "inherit",
+            shell: true,
+        });
+
+        npm.on("close", (code) => {
+            if (code === 0) {
+                resolve();
+            } else {
+                reject(
+                    new Error(`npm install failed with exit code ${code}`),
+                );
+            }
+        });
+
+        npm.on("error", reject);
+    });
+}
+
+
+export async function generateProject(projectName) {
+    const projectPath = path.resolve(process.cwd(), projectName);
+
+    const templatePath = path.resolve(
+        __dirname,
+        "../templates/javascript/base",
+    );
+
+    await fs.mkdir(projectPath, {
+        recursive: true,
+    });
+
+    await copyDirectory(templatePath, projectPath, {
+    PROJECT_NAME: projectName,
+});
+
+    console.log("\nInstalling dependencies...\n");
+
+    await installDependencies(projectPath);
+
+    await fs.writeFile(
+        path.join(projectPath, ".env"),
+        "PORT=5000\nNODE_ENV=development\nLOG_LEVEL=info\n",
+    );
+
+    await fs.writeFile(
+        path.join(projectPath, ".env.example"),
+        "PORT=5000\nNODE_ENV=development\nLOG_LEVEL=info\n",
+    );
+
+    await fs.writeFile(
+        path.join(projectPath, ".gitignore"),
+        "node_modules/\n.env\n.DS_Store\n*.log\ncoverage/\nlogs/\n",
+    );
+
+    console.log(`Created project: ${projectPath}`);
+}

package/src/templates/javascript/base/package.json

@@ -0,0 +1,14 @@
+{
+  "name": "{{PROJECT_NAME}}",
+  "version": "1.0.0",
+  "description": "{{PROJECT_NAME}} API",
+  "type": "module",
+  "scripts": {
+    "start": "node --env-file .env src/server.js",
+    "dev": "node --watch src/server.js"
+  },
+  "dependencies": {
+    "express": "^5.1.0",
+    "winston":"3.19.0"
+  }
+}

package/src/templates/javascript/base/src/app.js

@@ -0,0 +1,18 @@
+import express from "express";
+import { errorHandler } from "./middlewares/error.middleware.js";
+
+const app = express();
+
+app.use(express.json());
+app.use(express.urlencoded({ extended: true }));
+
+app.get("/", (req, res) => {
+    return res.json({
+        success: true,
+        message: "Nodexa API is running",
+    });
+});
+
+app.use(errorHandler);
+
+export { app };

package/src/templates/javascript/base/src/controllers/health/health.controller.js

@@ -0,0 +1,16 @@
+import { asyncHandler } from "../../utils/asyncHandler.js";
+import { ApiResponse } from "../utils/ApiResponse.js";
+
+const healthCheck = asyncHandler((req, res) => {
+    return res.status(200).json(
+        new ApiResponse(
+            200,
+            {
+                status: "UP",
+            },
+            "Nodexa API is running",
+        ),
+    );
+})
+
+export { healthCheck };

package/src/templates/javascript/base/src/logger/index.js

@@ -0,0 +1 @@
+export { logger } from "./logger.js";

package/src/templates/javascript/base/src/logger/logger.js

@@ -0,0 +1,47 @@
+import winston from "winston";
+
+const { combine, timestamp, printf, colorize, errors } = winston.format;
+
+const logFormat = printf(({ level, message, timestamp, stack }) => {
+    return `${timestamp} [${level}]: ${stack || message}`;
+});
+
+const logger = winston.createLogger({
+    level: process.env.LOG_LEVEL || "info",
+
+    format: combine(
+        timestamp({
+            format: "YYYY-MM-DD HH:mm:ss",
+        }),
+        errors({
+            stack: true,
+        }),
+        logFormat,
+    ),
+
+    transports: [
+        new winston.transports.Console({
+            format: combine(
+                colorize(),
+                timestamp({
+                    format: "YYYY-MM-DD HH:mm:ss",
+                }),
+                errors({
+                    stack: true,
+                }),
+                logFormat,
+            ),
+        }),
+
+        new winston.transports.File({
+            filename: "logs/error.log",
+            level: "error",
+        }),
+
+        new winston.transports.File({
+            filename: "logs/combined.log",
+        }),
+    ],
+});
+
+export { logger };

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

@@ -0,0 +1,38 @@
+import { ApiError } from "../utils/ApiError.js";
+import { logger } from "../logger/index.js";
+
+const errorHandler = (err, req, res, next) => {
+    let error = err;
+
+    if (!(error instanceof ApiError)) {
+        let statusCode = 500;
+        let message = "Something went wrong";
+
+        error = new ApiError(
+            statusCode,
+            message,
+            error?.errors || [],
+            err.stack,
+        );
+    }
+
+    logger.error(error.message, {
+        stack: error.stack,
+        method: req.method,
+        url: req.originalUrl,
+    });
+
+    const response = {
+        ...error,
+        message: error.message,
+        ...(process.env.NODE_ENV === "development"
+            ? {
+                  stack: error.stack,
+              }
+            : {}),
+    };
+
+    return res.status(error.statusCode).json(response);
+};
+
+export { errorHandler };

package/src/templates/javascript/base/src/routes/health/health.routes.js

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

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

@@ -0,0 +1,9 @@
+import express from "express";
+import healthRoutes from "./health/health.routes.js";
+
+
+const router = express.Router();
+
+router.use("/", healthRoutes);
+
+export { router };

package/src/templates/javascript/base/src/server.js

@@ -0,0 +1,8 @@
+import { app } from "./app.js";
+import { logger } from "./logger/index.js";
+
+const PORT = process.env.PORT || 5000;
+
+app.listen(PORT, () => {
+    logger.info(`Server running on port ${PORT}`);
+});

package/src/templates/javascript/base/src/utils/ApiError.js

@@ -0,0 +1,38 @@
+// eslint-disable-next-line no-unused-vars
+import { errorHandler } from "../middlewares/error.middleware.js";
+
+/**
+ * @description Common Error class to throw an error from anywhere.
+ * The {@link errorHandler} middleware will catch this error at the central place
+ * and it will return an appropriate response to the client.
+ */
+class ApiError extends Error {
+    /**
+     * @param {number} statusCode
+     * @param {string} message
+     * @param {any[]} errors
+     * @param {string} stack
+     */
+    constructor(
+        statusCode,
+        message = "Something went wrong",
+        errors = [],
+        stack = "",
+    ) {
+        super(message);
+
+        this.statusCode = statusCode;
+        this.data = null;
+        this.message = message;
+        this.success = false;
+        this.errors = errors;
+
+        if (stack) {
+            this.stack = stack;
+        } else {
+            Error.captureStackTrace(this, this.constructor);
+        }
+    }
+}
+
+export { ApiError };

package/src/templates/javascript/base/src/utils/ApiResponse.js

@@ -0,0 +1,18 @@
+/**
+ * @description Common response class to send serialized response from anywhere.
+ */
+class ApiResponse {
+    /**
+     * @param {number} statusCode
+     * @param {any} data
+     * @param {string} message
+     */
+    constructor(statusCode, data = null, message = "Success") {
+        this.statusCode = statusCode;
+        this.data = data;
+        this.message = message;
+        this.success = statusCode < 400;
+    }
+}
+
+export { ApiResponse };

package/src/templates/javascript/base/src/utils/asyncHandler.js

@@ -0,0 +1,12 @@
+/**
+ * @param {(req: import("express").Request, res: import("express").Response, next: import("express").NextFunction) => void} requestHandler
+ */
+const asyncHandler = (requestHandler) => {
+    return (req, res, next) => {
+        Promise.resolve(requestHandler(req, res, next)).catch((err) => {
+            next(err);
+        });
+    };
+};
+
+export { asyncHandler };

package/src/utils/file.utils.js

@@ -0,0 +1,40 @@
+import fs from "fs/promises";
+import path from "path";
+
+export async function copyDirectory(
+    source,
+    destination,
+    variables = {},
+) {
+    await fs.mkdir(destination, {
+        recursive: true,
+    });
+
+    const entries = await fs.readdir(source, {
+        withFileTypes: true,
+    });
+
+    for (const entry of entries) {
+        const sourcePath = path.join(source, entry.name);
+        const destinationPath = path.join(destination, entry.name);
+
+        if (entry.isDirectory()) {
+            await copyDirectory(
+                sourcePath,
+                destinationPath,
+                variables,
+            );
+        } else {
+            let content = await fs.readFile(sourcePath, "utf8");
+
+            for (const [key, value] of Object.entries(variables)) {
+                content = content.replaceAll(
+                    `{{${key}}}`,
+                    value,
+                );
+            }
+
+            await fs.writeFile(destinationPath, content);
+        }
+    }
+}