micro-service-maker 1.0.0

package/.env

@@ -0,0 +1,7 @@
+NODE_ENV = dev
+DB = mongodb://localhost:27017/vistro
+PORT = 4000
+LAST_PORT = 4000
+CLIENT = http://localhost:3000
+CLIENT_DOMAIN = localhost
+SERVER = http://localhost:4000

package/Dockerfile

@@ -0,0 +1,15 @@
+FROM node:22-alpine
+
+WORKDIR /app
+
+COPY package*.json ./
+
+RUN npm install
+
+COPY . .
+
+RUN npm run build
+
+EXPOSE 4000
+
+CMD ["node", "dist/app.js"]

package/dist/app.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/app.js

@@ -0,0 +1,279 @@
+#!/usr/bin/env node
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const chalk_1 = __importDefault(require("chalk"));
+const prompts_1 = __importDefault(require("prompts"));
+const dotenv_1 = __importDefault(require("dotenv"));
+dotenv_1.default.config();
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const child_process_1 = require("child_process");
+const boilerPlate_1 = require("./utils/boilerPlate");
+const loader_1 = require("./utils/loader");
+/*
+ * Check service name entered by user
+ * - should not be empty
+ * - only letters, numbers and "-" allowed
+*/
+const validateService = (service) => {
+    if (!service || service.length === 0) {
+        throw new Error('Service name is required!');
+    }
+    const regex = /^[a-zA-Z0-9-]+$/;
+    const isValidServiceName = regex.test(service);
+    if (!isValidServiceName) {
+        throw new Error('Service name must not contain spaces or symbols (only "-" allowed).');
+    }
+    // convert service name to lowercase
+    return service.toLowerCase();
+};
+// *Exit the app with a message
+const exitApp = (message = null) => {
+    console.log('\n' + chalk_1.default.red('─'.repeat(40)));
+    console.log(`${chalk_1.default.bgRed.white.bold(' EXIT ')} ${chalk_1.default.red(message || 'Process terminated by user.')}`);
+    console.log(chalk_1.default.red('─'.repeat(40)) + '\n');
+    process.exit(0);
+};
+/*
+ * Create a folder
+ * Throw error if folder already exists
+*/
+const makeFolder = (path) => {
+    const isFolderExist = fs_1.default.existsSync(path);
+    if (isFolderExist) {
+        throw new Error(`${path.split('\\').pop()}: service alredy exists !`);
+    }
+    fs_1.default.mkdirSync(path);
+};
+// * Copy files from pipeline folder to service folder
+const copyFiles = (files, inputPath, outputPath) => {
+    files.forEach((file) => {
+        fs_1.default.copyFileSync(path_1.default.join(`${inputPath}`, file), path_1.default.join(`${outputPath}`, file));
+    });
+};
+const getBoilerPlateFileData = (file, serviceName) => {
+    if (file.endsWith("router.ts")) {
+        return (0, boilerPlate_1.routerCode)(serviceName);
+    }
+    if (file.endsWith("model.ts")) {
+        return (0, boilerPlate_1.modelCode)(serviceName);
+    }
+    if (file.endsWith("interface.ts")) {
+        return (0, boilerPlate_1.interfaceCode)(serviceName);
+    }
+    return "";
+};
+// *Create empty files inside src folder
+const createFiles = (files, serviceName, srcPath) => {
+    files.forEach((file) => {
+        const fileName = `${serviceName}${file}`;
+        const filePath = path_1.default.join(srcPath, fileName);
+        fs_1.default.writeFileSync(filePath, getBoilerPlateFileData(file, serviceName));
+    });
+};
+// * Increase LAST_PORT value in pipeline .env file
+const updateLastPort = (pipeLinePath) => {
+    const envFilePath = path_1.default.join(pipeLinePath, ".env");
+    const envData = fs_1.default.readFileSync(envFilePath, "utf-8");
+    let lines = envData.split("\n");
+    lines = lines.map(line => {
+        if (line.trim().startsWith("LAST_PORT")) {
+            const [key, value] = line.split("=");
+            const newPort = parseInt(value.trim()) + 1;
+            return `${key.trim()} = ${newPort}`;
+        }
+        return line;
+    });
+    fs_1.default.writeFileSync(envFilePath, lines.join("\n"), "utf-8");
+};
+//  * Create .env file for new service
+//  * Use LAST_PORT as PORT
+const createEnvForNewService = (pipeLinePath, servicePath) => {
+    const envFilePath = path_1.default.join(pipeLinePath, ".env");
+    const serviceEnvPath = path_1.default.join(servicePath, ".env");
+    const envData = fs_1.default.readFileSync(envFilePath, "utf-8");
+    let lines = envData.split("\n");
+    let lastPort = null;
+    lines = lines.filter(line => {
+        if (line.trim().startsWith("LAST_PORT")) {
+            const [, value] = line.split("=");
+            lastPort = value.trim();
+            return false;
+        }
+        return true;
+    });
+    if (!lastPort) {
+        throw new Error("LAST_PORT not found in pipeline .env file");
+    }
+    lines = lines.map(line => {
+        if (line.trim().startsWith("PORT")) {
+            const [key] = line.split("=");
+            return `${key.trim()} = ${lastPort}`;
+        }
+        if (line.trim().startsWith("SERVER")) {
+            return line.replace(/:\d+/, `:${lastPort}`);
+        }
+        return line;
+    });
+    fs_1.default.writeFileSync(serviceEnvPath, lines.join("\n"), "utf-8");
+};
+const createDockerFileForService = (pipelinePath, servicePath, newPort) => {
+    const pipelineDockerFilePath = path_1.default.join(pipelinePath, "Dockerfile");
+    const newDockerFilePath = path_1.default.join(servicePath, "Dockerfile");
+    const dockerFileData = fs_1.default.readFileSync(pipelineDockerFilePath, "utf-8");
+    const replacedWithDocker = dockerFileData.replace(/EXPOSE\s*\d+/, `EXPOSE ${newPort}`);
+    fs_1.default.writeFileSync(newDockerFilePath, replacedWithDocker);
+};
+const ceratePackageDotJsonFileForService = (pipeLinePath, servicePath, serviceName) => {
+    const sourcePath = 'package.json';
+    const destinationPath = path_1.default.join(servicePath, 'package.json');
+    let packageJsonRaw = fs_1.default.readFileSync(sourcePath, "utf-8");
+    const packageJson = JSON.parse(packageJsonRaw);
+    packageJson.name = serviceName;
+    packageJson.scripts = {
+        ...packageJson.scripts,
+        dev: "ts-node-dev --respawn --transpile-only src/app.ts",
+    };
+    fs_1.default.writeFileSync(destinationPath, JSON.stringify(packageJson, null, 2), "utf-8");
+};
+const getNewPort = (pipeLinePath) => {
+    const envPath = path_1.default.join(pipeLinePath, ".env");
+    const envData = fs_1.default.readFileSync(envPath, "utf-8");
+    const lastPort = envData.split('\n').find(line => line.startsWith("LAST_PORT"))?.split("=")[1]?.trim();
+    if (!lastPort) {
+        throw new Error("last port not found.");
+    }
+    return parseInt(lastPort);
+};
+const addGateway = (gatewayPath, serviceName, newPort) => {
+    const data = (0, boilerPlate_1.gatewayCode)(serviceName, newPort);
+    const input = path_1.default.join(gatewayPath, "src", "app.ts");
+    fs_1.default.appendFileSync(input, data);
+};
+const addServer = async (gatewayPath, serviceName) => {
+    const mainPath = path_1.default.resolve(gatewayPath, "../../");
+    const destinationPath = path_1.default.join(mainPath, "src", "servers.json");
+    // 1️Read JSON safely
+    const raw = fs_1.default.readFileSync(destinationPath, "utf-8");
+    const serversData = JSON.parse(raw);
+    //  Avoid duplicates
+    if (!serversData.includes(serviceName)) {
+        serversData.push(serviceName);
+    }
+    //  Write back (pretty format)
+    fs_1.default.writeFileSync(destinationPath, JSON.stringify(serversData, null, 2));
+};
+const app = async () => {
+    try {
+        const msg = " WELCOME TEAM ! ";
+        const line = "═".repeat(msg.length);
+        console.log(chalk_1.default.blue(`╔${line}╗`));
+        console.log(chalk_1.default.blue("║") + chalk_1.default.bgBlue.white.bold(msg) + chalk_1.default.blue("║"));
+        console.log(chalk_1.default.blue(`╚${line}╝`));
+        // Ask user for service name
+        const res = await (0, prompts_1.default)({
+            type: 'text',
+            name: 'service',
+            message: `${chalk_1.default.yellow('⚙')} ${chalk_1.default.white.bold('Service Configuration')}\n  ${chalk_1.default.gray('└─')} ${chalk_1.default.blue.bold('Enter service name || To exit app write :q\n')}`,
+            format: val => val.trim()
+        });
+        if (res.service === ":q") {
+            exitApp();
+        }
+        if (res.service === "pipline") {
+            exitApp("Pipeline name is not allowed !");
+        }
+        // validate service name 
+        const serviceName = validateService(res.service);
+        // set all required paths
+        const appPath = __dirname;
+        const currentDir = process.cwd();
+        const pipeLinePath = path_1.default.resolve(appPath, "../");
+        const gatewayPath = path_1.default.join(path_1.default.resolve(currentDir, "../"), "gateway");
+        const rootPath = currentDir; //path.resolve(appPath, "../../")
+        const servicePath = path_1.default.join(rootPath, serviceName);
+        const srcPath = path_1.default.join(servicePath, "src");
+        const appFilePath = path_1.default.join(srcPath, "app.ts");
+        // files to copy from pipeline
+        const fileListForCopy = [
+            "tsconfig.json",
+            ".gitignore",
+            "example.env",
+        ];
+        // files to create in src folder
+        const filesListForCreate = [
+            ".controller.ts",
+            ".service.ts",
+            ".interface.ts",
+            ".enum.ts",
+            ".middleware.ts",
+            ".dto.ts",
+            ".router.ts",
+            ".model.ts"
+        ];
+        // create folders
+        makeFolder(servicePath);
+        makeFolder(srcPath);
+        // create empty app.ts
+        fs_1.default.writeFileSync(appFilePath, (0, boilerPlate_1.appCode)(serviceName));
+        // update port and create env file
+        updateLastPort(pipeLinePath);
+        createEnvForNewService(pipeLinePath, servicePath);
+        //crete Packages.json file
+        ceratePackageDotJsonFileForService(pipeLinePath, servicePath, serviceName);
+        // update port and crete new docker file
+        const newPort = getNewPort(pipeLinePath);
+        createDockerFileForService(pipeLinePath, servicePath, newPort);
+        // copy config files
+        copyFiles(fileListForCopy, pipeLinePath, servicePath);
+        // create src files
+        createFiles(filesListForCreate, serviceName, srcPath);
+        // Adding gateway
+        addGateway(gatewayPath, serviceName, newPort);
+        // Adding services in Server
+        await addServer(gatewayPath, serviceName);
+        console.log(`\n${chalk_1.default.green('✨')} ${chalk_1.default.white.bold('Generation Complete')}\n` +
+            `${chalk_1.default.gray('│')}\n` +
+            `${chalk_1.default.gray('└──')} ${chalk_1.default.green.bold('Service:')}  ${chalk_1.default.white(serviceName)}\n` +
+            `${chalk_1.default.gray('└──')} ${chalk_1.default.green.bold('Status:')}   ${chalk_1.default.cyan('Created Successfully')}\n` +
+            `${chalk_1.default.gray('└──')} ${chalk_1.default.green.bold('Time:')}     ${chalk_1.default.gray(new Date().toLocaleTimeString())}\n`);
+        console.log(chalk_1.default.cyan.bold("\n ⚡ SYSTEM UPDATE "));
+        console.log(chalk_1.default.black.bgCyan(" PHASE ") + chalk_1.default.cyan(" ❯ Synchronizing Packages..."));
+        console.log(chalk_1.default.dim(" ———————————————————————————————————— "));
+        (0, loader_1.startLoader)();
+        console.log(chalk_1.default.bgWhite.black.bold(" AUTHOR ") +
+            chalk_1.default.bgHex('#6272a4').white.bold(" Satyam Sharma ") +
+            chalk_1.default.cyan(" ❯❯ ") +
+            chalk_1.default.hex('#12c2e9').underline("https://github.com/sharmasatyam121104-devloper"));
+        (0, child_process_1.exec)("npm install", { cwd: servicePath }, (err) => {
+            if (err && err instanceof Error) {
+                throw new Error(`Failed during dependency installation - ${err.message}`);
+            }
+            console.log("\n");
+            const line = "━".repeat(serviceName.length + 50);
+            console.log(chalk_1.default.yellow(line));
+            console.log(chalk_1.default.yellow("  ✨ ") +
+                chalk_1.default.bold.white(serviceName.toUpperCase()) +
+                chalk_1.default.green(" dependency install  successfully! 🛰️"));
+            console.log(chalk_1.default.yellow(line));
+            // --- NEXT STEPS SECTION ---
+            console.log("\n" + chalk_1.default.cyan.bold("  👉 NEXT STEPS:"));
+            console.log(chalk_1.default.white("  1. Go back  : ") + chalk_1.default.bold.magenta("cd .."));
+            console.log(chalk_1.default.white("  2. Enter Dir: ") + chalk_1.default.bold.magenta(`cd ${serviceName}`));
+            console.log(chalk_1.default.white("  3. Launch   : ") + chalk_1.default.bold.bgHex('#FF8C00').black(" npm run dev "));
+            exitApp();
+        });
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            console.log(`\n\n${chalk_1.default.bgRed.white.bold(' ERROR ')} ${chalk_1.default.red(error)}\n`);
+            setTimeout(() => {
+                app();
+            }, 500);
+        }
+    }
+};
+app();

package/dist/utils/boilerPlate.d.ts

@@ -0,0 +1,5 @@
+export declare const appCode: (serviceName: string) => string;
+export declare const routerCode: (serviceName: string) => string;
+export declare const interfaceCode: (serviceName: string) => string;
+export declare const modelCode: (serviceName: string) => string;
+export declare const gatewayCode: (serviceName: string, port: number) => string;

package/dist/utils/boilerPlate.js

@@ -0,0 +1,107 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.gatewayCode = exports.modelCode = exports.interfaceCode = exports.routerCode = exports.appCode = void 0;
+const toPascalCase = (str) => str
+    .split("-")
+    .map(word => word.charAt(0).toUpperCase() + word.slice(1))
+    .join("");
+const appCode = (serviceName) => `
+import chalk from 'chalk';
+import dotenv from 'dotenv'
+dotenv.config()
+
+import mongoose from 'mongoose'
+const DB_URI = process.env.DB;
+if (!DB_URI) {
+  throw new Error("DB environment variable is not defined");
+}
+
+mongoose.connect(DB_URI)
+.then(() => {
+  console.log(
+    chalk.bold.green("[ DATABASE ] ") + 
+    chalk.white("${serviceName.padEnd(12)}") + 
+    chalk.gray(" | ") + 
+    chalk.bgGreen.black.bold(" OK ") + 
+    chalk.green(" Connected Successfully")
+  );
+})
+.catch(() => {
+  console.log(
+    chalk.bold.red("[ DATABASE ] ") + 
+    chalk.white("${serviceName.padEnd(12)}") + 
+    chalk.gray(" | ") + 
+    chalk.bgRed.black.bold(" FAIL ") + 
+    chalk.red(" Connection Rejected")
+  );
+});
+
+import express, { Request, Response } from 'express'
+import ${toPascalCase(serviceName)}Router from './${serviceName}.router'
+import morgan from 'morgan'
+import cors from 'cors'
+
+const PORT = process.env.PORT || 5000;
+const app = express()
+app.listen(PORT, ()=>{
+ console.log(chalk.yellow.bold("${serviceName}" + " - Server running on port http://localhost:" + PORT));
+})
+
+app.use(cors({
+  origin: process.env.CLIENT,
+  credentials: true
+}))
+app.use(express.json())
+app.use(express.urlencoded({ extended: false }))
+
+app.use("/${serviceName}", ${toPascalCase(serviceName)}Router)
+
+app.get("/", (req: Request, res: Response) => {
+  res.send("Hello from ${serviceName} service!");
+});
+
+`;
+exports.appCode = appCode;
+const routerCode = (serviceName) => `
+import { Router, Request, Response } from 'express'
+
+const ${toPascalCase(serviceName)}Router = Router()
+
+${toPascalCase(serviceName)}Router.get("/", (req: Request, res: Response) => {
+  res.json({ message: "Hello from ${serviceName} service" })
+})
+
+export default ${toPascalCase(serviceName)}Router
+`;
+exports.routerCode = routerCode;
+const interfaceCode = (serviceName) => `
+import { Document } from "mongoose";
+
+export interface ${toPascalCase(serviceName)}Interface extends Document {
+    
+}
+`;
+exports.interfaceCode = interfaceCode;
+const modelCode = (serviceName) => `
+import { Schema, model } from "mongoose";
+import { ${toPascalCase(serviceName)}Interface } from "./${serviceName}.interface";
+
+const ${toPascalCase(serviceName).charAt(0).toLowerCase() + toPascalCase(serviceName).slice(1)}Schema = new Schema<${toPascalCase(serviceName)}Interface>(
+  {
+
+  },
+  { timestamps: true }
+);
+
+const ${toPascalCase(serviceName)}Model = model<${toPascalCase(serviceName)}Interface>("${toPascalCase(serviceName)}",${toPascalCase(serviceName).charAt(0).toLowerCase() + toPascalCase(serviceName).slice(1)}Schema);
+
+export default ${toPascalCase(serviceName)}Model;
+`;
+exports.modelCode = modelCode;
+const gatewayCode = (serviceName, port) => `
+app.use('/${serviceName}', createProxyMiddleware({
+  target: 'http://localhost:${port}',
+  changeOrigin: true
+}));
+`;
+exports.gatewayCode = gatewayCode;

package/dist/utils/loader.d.ts

@@ -0,0 +1 @@
+export declare const startLoader: () => NodeJS.Timeout;

package/dist/utils/loader.js

@@ -0,0 +1,15 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startLoader = void 0;
+const chalk_1 = __importDefault(require("chalk"));
+const startLoader = () => {
+    const P = ["\\", "|", "/", "-"];
+    let x = 0;
+    return setInterval(() => {
+        process.stdout.write(`\r${chalk_1.default.cyan(P[x++ % P.length])} ${chalk_1.default.white("Installing dependencies... ")}`);
+    }, 100);
+};
+exports.startLoader = startLoader;

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "micro-service-maker",
+  "version": "1.0.0",
+  "main": "dist/app.js",
+  "types": "dist/app.d.ts",
+  "bin": {
+    "msm": "dist/app.js"
+  },
+  "scripts": {
+    "dev": "ts-node-dev  --transpile-only src/app.ts",
+    "build": "tsc",
+    "start": "node dist/app.js"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "description": "",
+  "dependencies": {
+    "chalk": "^4.1.2",
+    "cors": "^2.8.6",
+    "dotenv": "^17.2.3",
+    "express": "^5.2.1",
+    "mongoose": "^9.1.5",
+    "morgan": "^1.10.1",
+    "prompts": "^2.4.2"
+  },
+  "devDependencies": {
+    "@types/cors": "^2.8.19",
+    "@types/express": "^5.0.6",
+    "@types/morgan": "^1.9.10",
+    "@types/node": "^25.2.0",
+    "@types/prompts": "^2.4.9",
+    "ts-node-dev": "^2.0.0",
+    "typescipt": "^1.0.0"
+  }
+}

package/tsconfig.json

@@ -0,0 +1,16 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "node16",
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "strict": true,
+    "declaration": true,
+    "esModuleInterop": true,
+    "moduleResolution": "node16",
+    "forceConsistentCasingInFileNames": true,
+    "skipLibCheck": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["dist"]
+}