exp-node-server 1.1.0

package/README.md

@@ -0,0 +1,180 @@
+# ⚡ Express + Mongoose + TypeScript Module Generator
+
+[![npm version](https://img.shields.io/npm/v/exp-cli-gen.svg)](https://www.npmjs.com/package/exp-cli-gen)
+[![npm downloads](https://img.shields.io/npm/dw/exp-cli-gen.svg)](https://www.npmjs.com/package/exp-cli-gen)
+[![npm total downloads](https://img.shields.io/npm/dt/exp-cli-gen.svg)](https://www.npmjs.com/package/exp-cli-gen)
+[![GitHub stars](https://img.shields.io/github/stars/abumahid/mongo-server-stater-pack.svg)](https://github.com/abumahid/mongo-server-stater-pack/stargazers)
+[![GitHub issues](https://img.shields.io/github/issues/abumahid/mongo-server-stater-pack.svg)](https://github.com/abumahid/mongo-server-stater-pack/issues)
+[![License](https://img.shields.io/github/license/abumahid/mongo-server-stater-pack.svg)](https://github.com/abumahid/mongo-server-stater-pack/blob/main/LICENSE)
+[![GitHub last commit](https://img.shields.io/github/last-commit/abumahid/mongo-server-stater-pack.svg)](https://github.com/abumahid/mongo-server-stater-pack/commits/main)
+[![Made with TypeScript](https://img.shields.io/badge/Made%20with-TypeScript-blue.svg)](https://www.typescriptlang.org/)
+[![Node.js](https://img.shields.io/badge/Node.js-18+-green.svg)](https://nodejs.org/)
+
+---
+
+## 🚀 Overview
+
+**exp-cli-gen** is a powerful **Express + TypeScript module generator** that uses **Mongoose** for database interaction.  
+It automatically creates a complete module structure — including **models, controllers, services, routes, Zod validations, and Swagger documentation** — all in one command.
+
+Ideal for developers who want to quickly scaffold modular Express APIs with clean architecture and ready-to-use integrations.
+
+---
+
+## ✨ Features
+
+- ⚙️ Generates full-featured Express + TypeScript modules  
+- 🧩 Automatically integrates Mongoose models and Zod validations  
+- 📘 Adds Swagger documentation automatically  
+- 🚀 Clones and sets up a ready-to-run Express starter project  
+- 🔁 Can add new modules anytime with a single command  
+- 🧠 Skips redundant setup if the starter pack already exists  
+- 💪 Built for scalability and maintainability
+
+---
+
+## 📦 Installation
+
+Install globally:
+
+```bash
+npm install -g exp-cli-gen
+```
+Or run directly using npx (recommended):
+
+```bash
+npx exp-cli-gen <module-name>
+```
+## Usage
+🏗️ Generate your first module
+
+Run:
+
+```bash
+npx exp-cli-gen test
+```
+First run example:
+
+```bash
+Need to install the following packages:
+exp-cli-gen@1.0.1
+Ok to proceed? (y)
+
+⠋ No Express project found. Cloning starter pack...
+✔ Starter project cloned!
+
+✔ Git logs removed!
+
+📦 Installing dependencies...
+
+🚀 Project setup complete.
+🧩 Generating module: test...
+✔ test.interface.ts created
+✔ test.schema.ts created
+✔ test.validation.ts created
+✔ test.route.ts created
+✔ test.controller.ts created
+✔ test.service.ts created
+✔ test.swagger.ts created
+
+🔗 Route added to src/app/routes.ts
+📘 Swagger doc added to src/swaggerOptions.ts
+✨ Module 'test' created successfully!
+
+```
+
+## 📁 Generated Module Structure
+
+Each generated module will contain the following files:
+
+```pgsql
+src/app/modules/<module-name>/
+ ├── <module-name>.interface.ts
+ ├── <module-name>.schema.ts
+ ├── <module-name>.validation.ts
+ ├── <module-name>.route.ts
+ ├── <module-name>.controller.ts
+ ├── <module-name>.service.ts
+ └── <module-name>.swagger.ts
+```
+
+## 🔄 Add More Modules
+
+Need another module? Just run:
+
+```bash
+npx exp-cli-gen products
+```
+
+If the starter project already exists, it will skip cloning and directly add the new module.
+
+Example output:
+```bash
+ℹ 📦 Starter folder already exists. Skipping clone.
+📦 Dependencies already installed. Skipping npm install.
+🧩 Generating module: products...
+✔ products files created
+✨ Module 'products' created successfully!
+
+src/app/modules/products/
+ ├── products.interface.ts
+ ├── products.schema.ts
+ ├── products.validation.ts
+ ├── products.route.ts
+ ├── products.controller.ts
+ ├── products.service.ts
+ └── products.swagger.ts
+```
+
+Then, refresh your Swagger docs at:
+```bash
+http://localhost:5000/docs
+```
+
+You’ll see your new routes automatically added.
+
+---
+
+## ⚙️ Configuration
+
+After setup, update your .env file following the .env.example file in the starter project.
+
+To start the server:
+```bash
+npm run dev
+```
+Open Swagger documentation at:
+```bash
+http://localhost:5000/docs
+```
+
+---
+## 🧠 Tech Stack
+
+- Express.js — Backend framework
+- TypeScript — Strongly typed JavaScript
+- Mongoose — MongoDB ORM
+- Zod — Runtime schema validation
+- Swagger — API documentation
+- CLI (Node.js) — Command-line automation
+
+---
+## 🧩 Starter Pack Repository
+
+This CLI uses the following base project as a starter:
+
+👉 [mongo-server-stater-pack](https://github.com/abumahid/mongo-server-stater-pack.git)
+
+---
+## 💬 Author
+
+Abu Mahid
+
+🧠 [GitHub Profile](https://github.com/abumahid)
+
+💼 [npm Profile](https://www.npmjs.com/~dev_abumahid)
+
+---
+### ⭐ Star this project
+
+If you like this CLI, please give it a ⭐ on GitHub — it helps others discover it too! Thank you!

package/bin/cli.js

@@ -0,0 +1,41 @@
+#!/usr/bin/env node
+
+import chalk from "chalk";
+import { createProject } from "../src/createProject.js";
+import { generateModule } from "../src/generateModule.js";
+import { validateModuleName } from "../src/utils/validateModuleName.js";
+import { validateProjectName } from "../src/utils/validateProjectName.js";
+
+const args = process.argv.slice(2);
+
+if (!args.length) {
+    console.log(chalk.yellow("Usage:"));
+    console.log("  npx express-server -c <project-name>");
+    console.log("  npx express-server -g <module-name>");
+    process.exit(0);
+}
+
+const command = args[0];
+
+if (command === "-c") {
+    const projectName = validateProjectName(args[1]);
+
+    if (!projectName) {
+        console.log(chalk.red("❌ Project name required"));
+        process.exit(1);
+    }
+
+    await createProject(projectName);
+} else if (command === "-g") {
+    const moduleName = validateModuleName(args[1]);
+
+    if (!moduleName) {
+        console.log(chalk.red("❌ Module name required"));
+        process.exit(1);
+    }
+    await generateModule(moduleName);
+}
+else {
+    console.log(chalk.red("❌ Invalid command, use -c or -g"));
+    process.exit(1);
+}

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "exp-node-server",
+  "version": "1.1.0",
+  "type": "module",
+  "bin": {
+    "exp-node-server": "./bin/cli.js"
+  },
+  "files": [
+    "bin",
+    "src",
+    "templates"
+  ],
+  "dependencies": {
+    "chalk": "^5.3.0",
+    "ora": "^7.0.1",
+    "inquirer": "^9.2.7"
+  },
+  "keywords": [
+    "express",
+    "mongoose",
+    "typescript",
+    "cli",
+    "generator",
+    "nodejs",
+    "api",
+    "module-generator",
+    "exp-cli-gen"
+  ],
+  "engines": {
+    "node": ">=20.0.0"
+  }
+}

package/src/createProject.js

@@ -0,0 +1,58 @@
+import chalk from "chalk";
+import fs from "fs";
+import inquirer from "inquirer";
+import ora from "ora";
+import path from "path";
+import { fileURLToPath } from "url";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+export async function createProject(projectName) {
+
+    // ask user template
+    const answers = await inquirer.prompt([
+        {
+            type: "list",
+            name: "template",
+            message: "Select a project template:",
+            choices: [
+                { name: "Mongoose (MongoDB)", value: "mongoose" },
+                { name: "Prisma (PostgreSQL)", value: "prisma" },
+            ],
+        },
+    ]);
+
+    const template = answers.template;
+
+    const templateDir = path.join(
+        __dirname,
+        `../templates/${template}`
+    );
+
+    const targetDir = path.join(process.cwd(), projectName);
+
+    if (fs.existsSync(targetDir)) {
+        console.log(chalk.red("❌ Folder already exists"));
+        process.exit(1);
+    }
+
+    const spinner = ora(`Creating ${template} project...`).start();
+
+    try {
+
+        fs.cpSync(templateDir, targetDir, {
+            recursive: true,
+        });
+
+        spinner.succeed("Project created successfully");
+
+        console.log(chalk.green(`\nNext steps:`));
+        console.log(chalk.cyan(`cd ${projectName}`));
+        console.log(chalk.cyan(`npm install`));
+        console.log(chalk.cyan(`npm run dev`));
+
+    } catch (err) {
+        spinner.fail("Failed to create project");
+        console.error(err);
+    }
+}

package/src/generateModule.js

@@ -0,0 +1,61 @@
+import chalk from "chalk";
+import path from "path";
+import { createDir, createFile } from "./utils.js";
+import { controllerGenerator } from "./utils/controllerGenerator.js";
+import { routeGenerator } from "./utils/routeGenerator.js";
+import { injectRoute } from "./utils/routeInjector.js";
+import { schemaGenerator } from "./utils/schemaGenerator.js";
+import { serviceGenerator } from "./utils/serviceGenerator.js";
+import { swaggerGenerator } from "./utils/swaggerGenerator.js";
+import { injectSwagger } from "./utils/swaggerInjector.js";
+import { validationGenerator } from "./utils/validationGenerator.js";
+
+export async function generateModule(name) {
+
+    const base = path.join(
+        process.cwd(),
+        "src/app/modules",
+        name
+    );
+
+    createDir(base);
+
+    createFile(
+        path.join(base, `${name}.controller.ts`),
+        controllerGenerator(name)
+    );
+
+    createFile(
+        path.join(base, `${name}.service.ts`),
+        serviceGenerator(name)
+    );
+
+    createFile(
+        path.join(base, `${name}.route.ts`),
+        routeGenerator(name)
+    );
+
+    createFile(
+        path.join(base, `${name}.schema.ts`),
+        schemaGenerator(name)
+    );
+
+    createFile(
+        path.join(base, `${name}.interface.ts`),
+        `export type T_${name} = {
+        }`
+    );
+
+    createFile(
+        path.join(base, `${name}.validation.ts`),
+        validationGenerator(name)
+    );
+    createFile(
+        path.join(base, `${name}.swagger.ts`),
+        swaggerGenerator(name)
+    );
+    injectRoute(name);
+    injectSwagger(name);
+
+    console.log(chalk.green(`\nModule '${name}' created successfully`));
+}

package/src/utils/controllerGenerator.js

@@ -0,0 +1,70 @@
+export const controllerGenerator = (name) => {
+    return `
+import catchAsync from "../../utils/catch_async";
+import manageResponse from "../../utils/manage_response";
+import { ${name}_service } from "./${name}.service";
+
+const get_all_${name} = catchAsync(async (req, res) => {
+  const result = await ${name}_service.get_all_${name}_from_db(req);
+  manageResponse(res, {
+    success: true,
+    statusCode: 200,
+    message: "All ${name} fetched successfully.",
+    data: result,
+    meta: {},
+  });
+});
+
+const get_single_${name} = catchAsync(async (req, res) => {
+  const result = await ${name}_service.get_single_${name}_from_db(req);
+  manageResponse(res, {
+    success: true,
+    statusCode: 200,
+    message: "Single ${name} fetched successfully.",
+    data: result,
+    meta: {},
+  });
+});
+
+const create_${name} = catchAsync(async (req, res) => {
+  const result = await ${name}_service.create_${name}_into_db(req);
+  manageResponse(res, {
+    success: true,
+    statusCode: 200,
+    message: "${name} created successfully.",
+    data: result,
+    meta: {},
+  });
+});
+
+const update_${name} = catchAsync(async (req, res) => {
+  const result = await ${name}_service.update_${name}_into_db(req);
+  manageResponse(res, {
+    success: true,
+    statusCode: 200,
+    message: "${name} updated successfully.",
+    data: result,
+    meta: {},
+  });
+});
+
+const delete_${name} = catchAsync(async (req, res) => {
+  const result = await ${name}_service.delete_${name}_from_db(req);
+  manageResponse(res, {
+    success: true,
+    statusCode: 200,
+    message: "${name} deleted successfully.",
+    data: result,
+    meta: {},
+  });
+});
+
+export const ${name}_controller = {
+  get_all_${name},
+  get_single_${name},
+  create_${name},
+  update_${name},
+  delete_${name},
+};
+    `
+}

package/src/utils/routeGenerator.js

@@ -0,0 +1,27 @@
+export const routeGenerator = (name) => {
+
+    return `
+    import { Router } from "express";
+import RequestValidator from "../../middlewares/request_validator";
+import { ${name}_controller } from "./${name}.controller";
+import { ${name}_validations } from "./${name}.validation";
+
+const router = Router();
+
+router.get("/", ${name}_controller.get_all_${name});
+router.post(
+  "/",
+  RequestValidator(${name}_validations.create_${name}),
+  ${name}_controller.create_${name},
+);
+router.get("/:id", ${name}_controller.get_single_${name});
+router.patch(
+  "/:id",
+  RequestValidator(${name}_validations.update_${name}),
+  ${name}_controller.update_${name},
+);
+router.delete("/:id", ${name}_controller.delete_${name});
+
+export default router;
+    `
+}

package/src/utils/routeInjector.js

@@ -0,0 +1,40 @@
+import chalk from "chalk";
+import fs from "fs";
+import path from "path";
+
+export function injectRoute(name) {
+    const routeFile = path.join(process.cwd(), "src/routes.ts");
+
+    if (!fs.existsSync(routeFile)) {
+        console.log(chalk.yellow("routes.ts not found"));
+        return;
+    }
+
+    let content = fs.readFileSync(routeFile, "utf-8");
+
+    const importLine = `import ${name}Route from "./app/modules/${name}/${name}.route";`;
+    const routeEntry = `{ path: "/${name}", route: ${name}Route },`;
+
+    // add import
+    if (!content.includes(importLine)) {
+        const lastImportIndex = content.lastIndexOf("import ");
+        const nextLine = content.indexOf("\n", lastImportIndex);
+
+        content =
+            content.slice(0, nextLine + 1) +
+            importLine +
+            "\n" +
+            content.slice(nextLine + 1);
+    }
+
+    // add route entry
+    if (!content.includes(routeEntry)) {
+        content = content.replace(
+            /const moduleRoutes = \[/,
+            `const moduleRoutes = [\n  ${routeEntry}`
+        );
+    }
+
+    fs.writeFileSync(routeFile, content);
+    console.log(chalk.green(`Route registered for ${name}`));
+}

package/src/utils/schemaGenerator.js

@@ -0,0 +1,11 @@
+export const schemaGenerator = (name) => {
+    return `
+import { Schema, model } from "mongoose";
+import { T_${name} } from "./${name}.interface";
+
+const schema = new Schema<T_${name}>({});
+
+export const ${name}_model = model("${name}", schema);
+
+ `
+}

package/src/utils/serviceGenerator.js

@@ -0,0 +1,49 @@
+export const serviceGenerator = (name) => {
+    return `
+import { Request } from "express";
+import { ${name}_model } from "./${name}.schema";
+
+const get_all_${name}_from_db = async (req: Request) => {
+  // define your own login here
+  const result = await ${name}_model.find().lean();
+  return result;
+};
+
+const get_single_${name}_from_db = async (req: Request) => {
+  // define your own login here
+  const { id } = req.params;
+  const result = await ${name}_model.findById(id).lean();
+  return result;
+};
+
+const create_${name}_into_db = async (req: Request) => {
+  // define your own login here
+  const result = await ${name}_model.create(req.body);
+  return result;
+};
+
+const update_${name}_into_db = async (req: Request) => {
+  // define your own login here
+  const { id } = req.params;
+  const result = await ${name}_model.findByIdAndUpdate(id, req.body, {
+    new: true,
+  });
+  return result;
+};
+
+const delete_${name}_from_db = async (req: Request) => {
+  // define your own login here
+  const { id } = req.params;
+  const result = await ${name}_model.findByIdAndDelete(id);
+  return result;
+};
+
+export const ${name}_service = {
+  get_all_${name}_from_db,
+  get_single_${name}_from_db,
+  create_${name}_into_db,
+  update_${name}_into_db,
+  delete_${name}_from_db,
+};
+    `
+}

package/src/utils/swaggerGenerator.js

@@ -0,0 +1,112 @@
+export const swaggerGenerator = (name) => {
+    return `
+    export const ${name}SwaggerDocs = {
+  "/api/${name}": {
+    post: {
+      tags: ["${name}"],
+      summary: "Create  new ${name}",
+      description: "",
+      requestBody: {
+        required: true,
+        content: {
+          "application/json": {
+            example: JSON.stringify({}), // put your request body
+          },
+        },
+      },
+      responses: {
+        201: { description: "${name} created successfully" },
+        500: { description: "Validation error or internal server error" },
+      },
+    },
+    get: {
+      tags: ["${name}"],
+      summary: "Get all ${name}",
+      description: "",
+      parameters: [
+        {
+          name: "page",
+          in: "query",
+          required: false,
+          schema: { type: "number" },
+        },
+        {
+          name: "limit",
+          in: "query",
+          required: false,
+          schema: { type: "number" },
+        },
+      ],
+      responses: {
+        200: { description: "${name} fetched successfully" },
+        401: { description: "unauthorized" },
+      },
+    },
+  },
+
+  "/api/${name}/{id}": {
+    get: {
+      tags: ["${name}"],
+      summary: "Get single ${name}",
+      description: "",
+      parameters: [
+        {
+          name: "id",
+          in: "path",
+          required: true,
+          schema: { type: "string" },
+        },
+      ],
+      responses: {
+        200: { description: "${name} fetched successfully" },
+        401: { description: "unauthorized" },
+      },
+    },
+    patch: {
+      tags: ["${name}"],
+      summary: "Update ${name}",
+      description: "",
+      parameters: [
+        {
+          name: "id",
+          in: "path",
+          required: true,
+          schema: { type: "string" },
+        },
+      ],
+      requestBody: {
+        required: true,
+        content: {
+          "application/json": {
+            example: JSON.stringify({}), // put your request body
+          },
+        },
+      },
+      responses: {
+        200: { description: "${name} updated successfully" },
+        500: { description: "Validation error or internal server error" },
+      },
+    },
+    delete: {
+      tags: ["${name}"],
+      summary: "Delete ${name}",
+      description: "",
+      parameters: [
+        {
+          name: "id",
+          in: "path",
+          required: true,
+          schema: { type: "string" },
+        },
+      ],
+      responses: {
+        200: { description: "${name} delete successfully" },
+        401: { description: "unauthorized" },
+      },
+    },
+  },
+};
+
+    
+    `
+}