micflow 0.0.0-stage → 1.0.0

package/.env

@@ -0,0 +1,8 @@
+NODE_ENV=dev
+PORT=4000
+LAST_PORT = 4001
+DB=mongodb://localhost:27017/zivio
+CLIENT=http://localhost:3000
+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,226 @@
+#!/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 dotenv_1 = __importDefault(require("dotenv"));
+dotenv_1.default.config();
+const chalk_1 = __importDefault(require("chalk"));
+const inquirer_1 = __importDefault(require("inquirer"));
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const child_process_1 = require("child_process");
+const util_1 = require("util");
+const boilerplate_1 = require("./utils/boilerplate");
+const log = console.log;
+const Exec = (0, util_1.promisify)(child_process_1.exec);
+// console.log("dirname", __dirname)
+// console.log(process.cwd())
+const validateService = (service) => {
+    if (!service || service.length === 0) {
+        throw new Error(chalk_1.default.bgRed.white.bold("Service is required"));
+    }
+    const reqex = /^[a-zA-Z0-9-]+$/;
+    const isValid = reqex.test(service);
+    if (!isValid) {
+        throw new Error(chalk_1.default.bgRed.white.bold("Space or any symbol not allowed in service name so you can use -"));
+    }
+    return service.toLowerCase();
+};
+const exitApp = (msg = null) => {
+    const message = chalk_1.default.bgGreenBright.black.bold(msg || "👋 Good Bye !");
+    log(message);
+    process.exit(0);
+};
+const makeFolder = async (path) => {
+    const isExists = fs_1.default.existsSync(path);
+    if (isExists) {
+        throw new Error(`${path.split("\\").pop()} service is already exists !`);
+    }
+    fs_1.default.mkdirSync(path);
+};
+const copyFiles = (files, inputPath, outputPath) => {
+    files.forEach((file) => {
+        // src, destination
+        fs_1.default.copyFileSync(path_1.default.join(`${inputPath}`, file), path_1.default.join(`${outputPath}`, file));
+    });
+};
+const getBiolerplate = (file, service) => {
+    if (file === ".router.ts")
+        return (0, boilerplate_1.routerBoilerplate)(service);
+    if (file === ".interface.ts")
+        return (0, boilerplate_1.interfaceBoilerplate)(service);
+    if (file === ".model.ts")
+        return (0, boilerplate_1.modelBoilerplate)(service);
+    return "";
+};
+const createFiles = (files, service, srcPath) => {
+    files.forEach((file) => {
+        const filename = `${service}${file}`;
+        const filepath = path_1.default.join(srcPath, filename);
+        fs_1.default.writeFileSync(filepath, getBiolerplate(file, service));
+    });
+};
+const updateLastPort = (pipelinePath, newPort) => {
+    const envFilePath = path_1.default.join(pipelinePath, ".env");
+    const envData = fs_1.default.readFileSync(envFilePath, "utf-8");
+    const updatedPortString = envData.replace(/LAST_PORT\s*=\s*\d+/, `LAST_PORT = ${newPort}`);
+    fs_1.default.writeFileSync(envFilePath, updatedPortString);
+};
+const createEnvForNewService = (pipelinePath, servicePath, newPort) => {
+    const pipelineEnvPath = path_1.default.join(pipelinePath, ".env");
+    const newEnvPath = path_1.default.join(servicePath, ".env");
+    const envData = fs_1.default.readFileSync(pipelineEnvPath, "utf-8");
+    const stringChangedAfterPort = envData.replace(/PORT\s*=\s*\d+/, `PORT = ${newPort}`);
+    const arr = stringChangedAfterPort.split("\n");
+    const modifiedData = arr.map((item) => {
+        if (item.startsWith("LAST_PORT"))
+            return null;
+        if (item.startsWith("SERVER"))
+            return `SERVER = http://localhost:${newPort}\r`;
+        return item;
+    }).filter(Boolean);
+    const finalData = modifiedData.join("\n");
+    fs_1.default.writeFileSync(newEnvPath, finalData);
+};
+const createPackageForNewService = (service, servicePath) => {
+    const data = (0, boilerplate_1.packageBoilerplate)(service);
+    const newPackagePath = path_1.default.join(servicePath, "package.json");
+    fs_1.default.writeFileSync(newPackagePath, data);
+};
+const createDockerFileForNewService = (pipelinePath, servicePath, newPort) => {
+    // console.log("New port", 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");
+    // console.log("Docker file data", dockerFileData)
+    const replacedWithDocker = dockerFileData.replace(/EXPOSE\s*\d+/, `EXPOSE ${newPort}`);
+    // console.log("Replacew with docker", replacedWithDocker)
+    fs_1.default.writeFileSync(newDockerFilePath, replacedWithDocker);
+    // console.log(
+    //     "Saved Dockerfile:",
+    //     fs.readFileSync(newDockerFilePath, "utf-8")
+    // );
+};
+const getNewPort = (pipelinePath) => {
+    const envPath = path_1.default.join(pipelinePath, ".env");
+    const envData = fs_1.default.readFileSync(envPath, "utf-8");
+    const arr = envData.split("\n");
+    const lastPortLine = arr.find((line) => {
+        return line.trimStart().startsWith("LAST_PORT");
+    });
+    // console.log("lastport line", lastPortLine)
+    const regExpForPortValue = /LAST_PORT\s*=\s*(\d+)/;
+    const lastPort = parseInt(lastPortLine?.match(regExpForPortValue)?.[1]);
+    return lastPort + 1;
+};
+const addGateway = (gatewayPath, serviceName, newPort) => {
+    const data = (0, boilerplate_1.gatewayBoilerplate)(serviceName, newPort);
+    const input = path_1.default.join(gatewayPath, "src", "app.ts");
+    fs_1.default.appendFileSync(input, data);
+};
+const addServer = async (gatewayPath, serviceName) => {
+    const main = path_1.default.resolve(gatewayPath, "../../");
+    const inputPath = path_1.default.join(main, "src", "servers.json");
+    try {
+        const fileContent = fs_1.default.readFileSync(inputPath, "utf-8");
+        const servers = JSON.parse(fileContent);
+        if (!servers.includes(serviceName)) {
+            servers.push(serviceName);
+            fs_1.default.writeFileSync(inputPath, JSON.stringify(servers, null, 2), "utf-8");
+        }
+        // console.log("Servers:", servers);
+    }
+    catch (error) {
+        console.error("Failed to update servers.json:", error);
+        throw error;
+    }
+};
+const app = async () => {
+    try {
+        const welcomeMessage = chalk_1.default.bgGreenBright("======= Weclome Team ! =========\n");
+        log(welcomeMessage);
+        const { service } = await inquirer_1.default.prompt({
+            type: "input",
+            name: "service",
+            message: chalk_1.default.yellow("Enter serivce name || to exit press :q\n")
+        });
+        if (service === ":q") {
+            exitApp();
+        }
+        if (service === "pipeline") {
+            exitApp("Pipeline name not allowed");
+        }
+        const serviceName = validateService(service);
+        // console.log(serviceName)
+        // Get the current working directory
+        const currentDir = process.cwd();
+        // Get the current module directory
+        const appPath = __dirname;
+        // Set the project root directory
+        const rootPath = currentDir;
+        // Resolve the pipeline directory
+        const pipelinePath = path_1.default.resolve(appPath, "../");
+        // Resolve the API gateway directory
+        const gatewayPath = path_1.default.join(path_1.default.resolve(currentDir, "../"), "gateway");
+        // Define the new service directory
+        const servicePath = path_1.default.join(rootPath, serviceName);
+        // Define the service source directory
+        const srcPath = path_1.default.join(servicePath, "src");
+        // Define the service entry point file
+        const appFilePath = path_1.default.join(srcPath, "app.ts");
+        const fileListForCopy = [
+            "package-lock.json",
+            "tsconfig.json"
+        ];
+        const filesListForCreate = [
+            ".controller.ts",
+            ".service.ts",
+            ".model.ts",
+            ".interface.ts",
+            ".enum.ts",
+            ".middleware.ts",
+            ".dto.ts",
+            ".router.ts"
+        ];
+        // Service folder
+        makeFolder(servicePath);
+        // Src folder inside service
+        makeFolder(srcPath);
+        // Creating app.ts
+        const newPort = getNewPort(pipelinePath);
+        // console.log("new ports", newPort)
+        const content = (0, boilerplate_1.appBoilerplate)(serviceName, newPort);
+        // console.log("App boilerplate", content)
+        fs_1.default.writeFileSync(appFilePath, content, "utf-8");
+        // Change last port in pipeline
+        updateLastPort(pipelinePath, newPort);
+        createEnvForNewService(pipelinePath, servicePath, newPort);
+        createDockerFileForNewService(pipelinePath, servicePath, newPort);
+        createPackageForNewService(serviceName, servicePath);
+        // Copying all required file or typescript
+        copyFiles(fileListForCopy, pipelinePath, servicePath);
+        // Creating required files for start coding
+        createFiles(filesListForCreate, serviceName, srcPath);
+        // Adding Gateway
+        addGateway(gatewayPath, serviceName, newPort);
+        // Adding server
+        await addServer(gatewayPath, serviceName);
+        log(chalk_1.default.bgGreen.black.bold(" 🚀 Installing dependencies... Please wait ⏳ "));
+        await Exec("npm install", { cwd: servicePath });
+        // await Exec("npm run dev", { cwd: servicePath })
+        log(chalk_1.default.bgYellow.black.bold(`Success - ${serviceName} created successfully !`));
+        log(chalk_1.default.green.bold(`🚀Browse service folder and write npm run dev`));
+        exitApp();
+        // log(chalk.bgYellowBright.black.bold(`Success - ${serviceName} created successfully !`))
+        // exitApp()
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            log(chalk_1.default.bgRed.white.bold(` 🛑 Error - ${error.message} \n`));
+            app();
+        }
+    }
+};
+app();

package/dist/utils/boilerplate.d.ts

@@ -0,0 +1,6 @@
+export declare const appBoilerplate: (service: string, port: number) => string;
+export declare const routerBoilerplate: (service: string) => string;
+export declare const interfaceBoilerplate: (service: string) => string;
+export declare const modelBoilerplate: (service: string) => string;
+export declare const packageBoilerplate: (service: string) => string;
+export declare const gatewayBoilerplate: (service: string, port: number) => string;

package/dist/utils/boilerplate.js

@@ -0,0 +1,115 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.gatewayBoilerplate = exports.packageBoilerplate = exports.modelBoilerplate = exports.interfaceBoilerplate = exports.routerBoilerplate = exports.appBoilerplate = void 0;
+const getServiceInPascalCase = (service) => {
+    const arr = service.split("-");
+    const tmp = arr.map((item) => {
+        const firstLetter = item[0].toUpperCase();
+        const restLetter = item.slice(1);
+        return firstLetter + restLetter;
+    });
+    return tmp.join("");
+};
+const appBoilerplate = (service, port) => {
+    return [
+        `import dotenv from "dotenv"`,
+        `dotenv.config()\n`,
+        `import mongoose from "mongoose"`,
+        `mongoose.connect(process.env.DB!)`,
+        `.then(()=>console.log("${service} - Database is running"))`,
+        `.catch(()=>console.log("${service} - Failed to connect with database"))\n`,
+        `import express, { Request, Response } from "express"`,
+        `import ${getServiceInPascalCase(service)}Router from "./${service}.router"`,
+        `import morgan from "morgan"`,
+        `import cors from "cors"`,
+        `const app = express()`,
+        `app.listen(process.env.PORT, ()=>console.log("${service} service is running on - http://localhost:${port}/${service}"))\n`,
+        `app.use(cors({`,
+        `\torigin: process.env.CLIENT,`,
+        `\tcredentials: true`,
+        `}))`,
+        `app.use(express.json())`,
+        `app.use(express.urlencoded({extended: false}))\n`,
+        `app.use("/${service}", ${getServiceInPascalCase(service)}Router)`
+    ].join("\n");
+};
+exports.appBoilerplate = appBoilerplate;
+const routerBoilerplate = (service) => {
+    return [
+        `import {Router, Request, Response} from "express"`,
+        `const ${getServiceInPascalCase(service)}Router = Router()\n`,
+        `${getServiceInPascalCase(service)}Router.get("/", (req: Request, res: Response)=>{`,
+        `\tres.json({message: "Hello from ${service} service"})`,
+        `})\n`,
+        `export default ${getServiceInPascalCase(service)}Router`
+    ].join("\n");
+};
+exports.routerBoilerplate = routerBoilerplate;
+const interfaceBoilerplate = (service) => {
+    const Provider = getServiceInPascalCase(service);
+    return [
+        `import { Document } from "mongoose"\n`,
+        `export interface ${Provider}ModelInterface extends Document {\n`,
+        `\t`,
+        `}`
+    ].join("\n");
+};
+exports.interfaceBoilerplate = interfaceBoilerplate;
+const modelBoilerplate = (service) => {
+    const Provider = getServiceInPascalCase(service);
+    return [
+        `import { Schema, model } from "mongoose"`,
+        `import { ${Provider}ModelInterface } from "./${service}.interface"\n`,
+        `const schema = new Schema<${Provider}ModelInterface>({\n`,
+        `\t`,
+        `}, {timestamps: true})\n`,
+        `const ${Provider}Model = model<${Provider}ModelInterface>("${Provider}", schema)`,
+        `export default ${Provider}Model`
+    ].join("\n");
+};
+exports.modelBoilerplate = modelBoilerplate;
+const packageBoilerplate = (service) => {
+    const data = {
+        "name": service,
+        "version": "1.0.0",
+        "description": "",
+        "main": "index.js",
+        "scripts": {
+            "dev": "ts-node-dev --respawn --transpile-only src/app.ts",
+            "build": "tsc",
+            "start": "node dist/app.js"
+        },
+        "keywords": [],
+        "author": "",
+        "license": "ISC",
+        "type": "commonjs",
+        "dependencies": {
+            "chalk": "^6.0.1",
+            "cors": "^2.8.6",
+            "dotenv": "^18.0.8",
+            "express": "^5.3.0",
+            "inquirer": "^14.2.4",
+            "mongoose": "^9.11.2",
+            "morgan": "^1.12.1"
+        },
+        "devDependencies": {
+            "@types/cors": "^2.8.19",
+            "@types/express": "^5.0.6",
+            "@types/morgan": "^1.9.10",
+            "@types/node": "^26.6.5",
+            "ts-node-dev": "^2.0.0",
+            "typescript": "^6.0.3"
+        }
+    };
+    return JSON.stringify(data, null, 2);
+};
+exports.packageBoilerplate = packageBoilerplate;
+const gatewayBoilerplate = (service, port) => {
+    return [
+        `\n\napp.use("/${service}", createProxyMiddleware({`,
+        `\ttarget: 'http://localhost:${port}/${service}',`,
+        `\tchangeOrigin: true`,
+        `}))`
+    ].join("\n");
+};
+exports.gatewayBoilerplate = gatewayBoilerplate;

package/package.json

@@ -1,6 +1,38 @@
 {
   "name": "micflow",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "1.0.0",
+  "description": "A CLI tool to scaffold microservices and configure gateway routing",
+  "main": "dist/app.js",
+  "types": "dist/app.d.ts",
+  "bin": {
+    "micflow": "dist/app.js"
+  },
+  "scripts": {
+    "dev": "ts-node-dev --transpile-only src/app.ts",
+    "build": "tsc",
+    "start": "node dist/app.js"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "type": "commonjs",
+  "dependencies": {
+    "chalk": "^4.1.2",
+    "cors": "^2.8.6",
+    "dotenv": "^18.0.8",
+    "express": "^5.3.0",
+    "inquirer": "^8.2.6",
+    "install": "^0.13.0",
+    "mongoose": "^9.11.2",
+    "morgan": "^1.12.1"
+  },
+  "devDependencies": {
+    "@types/cors": "^2.8.19",
+    "@types/express": "^5.0.6",
+    "@types/inquirer": "^8.2.13",
+    "@types/morgan": "^1.9.10",
+    "@types/node": "^26.6.5",
+    "ts-node-dev": "^2.0.0",
+    "typescript": "^6.0.3"
+  }
+}

package/tsconfig.json

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

package/README.md

@@ -1,3 +0,0 @@
-# Temporary Holding Version
-
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.