create-backend-templates 1.0.1

package/Readme.md

@@ -0,0 +1,129 @@
+# Backend Project Generator CLI
+
+[![npm version](https://img.shields.io/npm/v/create-backend.svg)](https://www.npmjs.com/package/create-backend)
+[![License](https://img.shields.io/npm/l/create-backend.svg)](https://github.com/dee-raj/create-backend/blob/main/LICENSE)
+[![Node.js Version](https://img.shields.io/node/v/create-backend.svg)](https://nodejs.org/)
+
+> ⚡ A fast, interactive CLI to scaffold modern backend projects with **Express** or **NestJS**, MongoDB/MySQL/Postgres, Prisma support, and optional features like Auth, Swagger, Docker, and ESLint.
+
+---
+
+## Features
+
+- Scaffold backend projects with **Express.js** or **NestJS**
+- Choose **TypeScript** or **JavaScript**
+- Database support:
+  - MongoDB (Mongoose)
+  - MySQL (Prisma)
+  - PostgreSQL (Prisma)
+- Optional extra features:
+  - JWT Authentication
+  - Swagger API Docs
+  - Docker support
+  - ESLint + Prettier setup
+- Git initialized with first commit
+- Interactive CLI with colorized UI and progress bars
+- **Offline ready**: Bundled templates for instant scaffolding without git cloning
+- Works on Windows, macOS, and Linux
+
+---
+
+## Installation
+
+```bash
+npm install -g create-backend
+````
+
+or via **yarn**
+
+```bash
+yarn global add create-backend
+```
+
+---
+
+## Usage
+
+### List Available Templates
+
+```bash
+create-backend --list
+```
+
+Output:
+
+```
+• Express + TypeScript (Mongo)         → express-ts-mongo
+• NestJS + TypeScript (Mongo)          → nest-ts-mongo
+• Express + JavaScript (Mongo)         → express-js-mongo
+• Express + TS + Prisma (MySQL)        → express-ts-prisma-mysql
+• Express + TS + Prisma (Postgres)     → express-ts-prisma-postgres
+• Nest + TS + Prisma (MySQL)           → nest-ts-prisma-mysql
+• Nest + TS + Prisma (Postgres)        → nest-ts-prisma-postgres
+```
+
+---
+
+### Generate a New Project
+
+Run the CLI:
+
+```bash
+create-backend
+```
+
+Follow the prompts to:
+
+1. Select **Framework** (Express / NestJS)
+2. Choose **Language** (TypeScript / JavaScript)
+3. Pick **Database** (MongoDB / MySQL / PostgreSQL)
+4. Enable optional **features** (Auth, Swagger, Docker, ESLint)
+5. Specify **Project Name**
+
+The CLI will:
+
+* Clone the selected template
+* Generate `.env` for your database
+* Install dependencies with progress bar
+* Initialize git and create initial commit
+* Optional features scaffolding
+
+---
+
+### Example
+
+```bash
+? Choose Framework: Express
+? Language: JavaScript
+? Database: MongoDB
+? Add Features: Auth, Swagger, Docker, ESLint
+? Project Name: my-backend
+```
+
+After completion:
+
+```bash
+cd my-backend
+npm run dev
+# or
+npm start
+code .
+```
+
+---
+
+## Contributing
+
+Contributions are welcome! Please follow these steps:
+
+1. Fork the repository
+2. Create a feature branch: `git checkout -b feature/my-feature`
+3. Commit your changes: `git commit -m 'Add my feature'`
+4. Push to the branch: `git push origin feature/my-feature`
+5. Open a Pull Request
+
+---
+
+## License
+
+MIT © 2025 [Dhurbaraj N Joshi](https://github.com/dee-raj)

package/bin/index.js

@@ -0,0 +1,17 @@
+#!/usr/bin/env node
+import { runCLI, listTemplates } from "../src/cli.js";
+import updateProject from "../src/update.js";
+
+const args = process.argv.slice(2);
+
+if (args.includes("--list")) {
+    listTemplates();
+    process.exit(0);
+}
+
+if (args[0] === "update") {
+    updateProject(args[1]);
+    process.exit(0);
+}
+
+runCLI();

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "create-backend-templates",
+  "version": "1.0.1",
+  "description": "This is node backend creation with multiples templates and features like jwt & etc.",
+  "bin": {
+    "create-backend": "./bin/index.js"
+  },
+  "keywords": [
+    "backend",
+    "templates",
+    "nodejs",
+    "express",
+    "jwt",
+    "nest",
+    "mongodb",
+    "mongoose",
+    "prisma",
+    "sql"
+  ],
+  "license": "ISC",
+  "author": "Dhurbaraj N Joshi",
+  "type": "module",
+  "main": "bin/index.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "dependencies": {
+    "chalk": "^5.6.2",
+    "cli-progress": "^3.12.0",
+    "commander": "^14.0.2",
+    "execa": "^9.6.1",
+    "fs-extra": "^11.3.3",
+    "inquirer": "^13.1.0",
+    "ora": "^9.0.0"
+  }
+}

package/scripts/verify-templates.js

@@ -0,0 +1,51 @@
+import fs from 'fs';
+import path from 'path';
+import chalk from 'chalk';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+const templatesDir = path.join(__dirname, '../templates');
+const requiredFiles = ['package.json', 'README.md', 'src/prisma/schema.prisma'];
+
+const templates = [
+    'express-ts-prisma-mysql',
+    'express-ts-prisma-postgres',
+    'nest-ts-prisma-mysql',
+    'nest-ts-prisma-postgres'
+];
+
+console.log(chalk.blue('Verifying templates...\n'));
+
+let hasErrors = false;
+
+templates.forEach(template => {
+    const templatePath = path.join(templatesDir, template);
+
+    if (!fs.existsSync(templatePath)) {
+        console.log(chalk.red(`✖ Template missing: ${template}`));
+        hasErrors = true;
+        return;
+    }
+
+    console.log(chalk.cyan(`Checking ${template}...`));
+
+    requiredFiles.forEach(file => {
+        const filePath = path.join(templatePath, file);
+        if (!fs.existsSync(filePath)) {
+            console.log(chalk.red(`  ✖ Missing file: ${file}`));
+            hasErrors = true;
+        } else {
+            console.log(chalk.green(`  ✔ ${file} exists`));
+        }
+    });
+    console.log('');
+});
+
+if (hasErrors) {
+    console.log(chalk.red('Verification failed with errors.'));
+    process.exit(1);
+} else {
+    console.log(chalk.green('All templates verified successfully!'));
+}

package/src/cli.js

@@ -0,0 +1,166 @@
+import inquirer from "inquirer";
+import chalk from "chalk";
+import scaffold from "./utils/scaffold.js";
+import { ensureGitInstalled } from "./utils/git.js";
+
+const headline = text => console.log(chalk.bold.bgBlue.white(`\n ${text} \n`));
+
+const section = text => console.log(chalk.bold.cyan(`\n› ${text}`));
+
+const success = text => console.log(chalk.green(`✔ ${text}`));
+
+const warn = text => console.log(chalk.yellow(`⚠ ${text}`));
+
+const error = text => console.log(chalk.bold.redBright(`\n✖   ${text}\n`));
+
+export function listTemplates() {
+    headline("Available Templates");
+
+    const list = [
+        ["Express + TypeScript (Mongo)", "express-ts-mongo"],
+        ["NestJS + TypeScript (Mongo)", "nest-ts-mongo"],
+        ["Express + JavaScript (Mongo)", "express-js-mongo"],
+        ["Express + TS + Prisma (MySQL)", "express-ts-prisma-mysql"],
+        ["Express + TS + Prisma (Postgres)", "express-ts-prisma-postgres"],
+        ["Nest + TS + Prisma (MySQL)", "nest-ts-prisma-mysql"],
+        ["Nest + TS + Prisma (Postgres)", "nest-ts-prisma-postgres"],
+    ];
+
+    list.forEach(([label, key]) =>
+        console.log(`${chalk.white("•")} ${chalk.green(label)}  ${chalk.gray(`→ ${key}`)}`)
+    );
+
+    console.log(chalk.dim("\nUsage: create-backend --list\n"));
+}
+
+
+const delay = (ms) => new Promise(res => setTimeout(res, ms));
+
+async function typeLine(text, speed = 40) {
+    for (let char of text) {
+        process.stdout.write(char);
+        await delay(speed);
+    }
+    process.stdout.write("\n");
+}
+
+const banner = async () => {
+    console.log(
+        chalk.blueBright("\n╔══════════════════════════════════════╗") +
+        chalk.blueBright("\n║") + chalk.white.bold("   BACKEND PROJECT GENERATOR CLI      ") + chalk.blueBright("║") +
+        chalk.blueBright("\n╚══════════════════════════════════════╝\n")
+    );
+    const lines = [
+        chalk.green("\n[~] Initializing Backend Generator..."),
+        chalk.green("[|] Loading Modules..."),
+        chalk.green("[/] Ready")
+    ];
+
+
+    for (const line of lines) {
+        await typeLine(line, 10);
+        await delay(300);
+    }
+    console.log();
+};
+
+
+export async function runCLI() {
+    try {
+        await banner();
+        await ensureGitInstalled();
+        section("Select technologies\n");
+
+        const answers = await inquirer.prompt([
+            {
+                type: "rawlist",
+                name: "framework",
+                message: chalk.bold.white("Choose Framework"),
+                choices: [
+                    { name: chalk.cyan("Express"), value: "express" },
+                    { name: chalk.magenta("NestJS"), value: "nest" }
+                ],
+                theme: {
+                    style: {
+                        highlight: (text) => chalk.underline(text)
+                    }
+                }
+            },
+            {
+                type: "rawlist",
+                name: "language",
+                message: chalk.bold.white("Language"),
+                choices: [
+                    { name: chalk.blueBright("TypeScript"), value: "ts" },
+                    { name: chalk.yellowBright("JavaScript"), value: "js" }
+                ],
+                theme: {
+                    style: {
+                        highlight: (text) => chalk.underline(text)
+                    }
+                }
+            },
+            {
+                type: "rawlist",
+                name: "database",
+                message: chalk.bold.white("Database"),
+                choices: [
+                    { name: chalk.green("MongoDB"), value: "mongo" },
+                    { name: chalk.blue("MySQL"), value: "mysql" },
+                    { name: chalk.blueBright("PostgreSQL"), value: "postgres" }
+                ],
+                theme: {
+                    style: {
+                        highlight: (text) => chalk.underline(text)
+                    }
+                }
+            },
+            {
+                type: "checkbox",
+                name: "features",
+                message: chalk.bold.white("Add Features"),
+                choices: [
+                    { name: chalk.green("Auth (JWT)"), value: "auth" },
+                    { name: chalk.cyan("Swagger Docs"), value: "swagger" },
+                    { name: chalk.yellow("Docker Support"), value: "docker" },
+                    { name: chalk.magenta("ESLint Rules"), value: "eslint" }
+                ],
+                theme: {
+                    style: {
+                        highlight: (text) => chalk.underline(text)
+                    }
+                }
+            },
+            {
+                type: "input",
+                name: "folder",
+                message: chalk.bold.white("Project Name"),
+                default: "backend-service"
+            }
+        ]);
+
+        const { framework, language, database, features, folder } = answers;
+
+        let key = `${framework}-${language}-${database}`;
+        if (database !== "mongo") key = `${framework}-${language}-prisma-${database}`;
+
+        section("Template Selected");
+        console.log(chalk.green(`→ ${key}`));
+
+        section("Generating Project...");
+        await scaffold(key, folder, database, features);
+
+        success("Project created successfully.");
+        console.log(
+            chalk.white("\nNext steps") +
+            chalk.gray(" (copy & run):") +
+            "\n" +
+            chalk.green(`   cd ${folder}\n   npm run dev  `) +
+            chalk.gray("// or npm start") +
+            "\n   code .\n"
+        );
+    } catch (err) {
+        error(`Something went wrong: ${err.message}`);
+        process.exit(1);
+    }
+}

package/src/config/repoMap.js

@@ -0,0 +1,12 @@
+export const repoMap = {
+    // available at this version
+    "express-ts-mongo": "https://github.com/dee-raj/backend-ts.git",
+    "nest-ts-mongo": "https://github.com/dee-raj/nest.git",
+    "express-js-mongo": "https://github.com/dee-raj/backend.git|devlopment",
+
+    // not available at this version
+    "express-ts-prisma-mysql": "templates/express-ts-prisma-mysql",
+    "express-ts-prisma-postgres": "templates/express-ts-prisma-postgres",
+    "nest-ts-prisma-mysql": "templates/nest-ts-prisma-mysql",
+    "nest-ts-prisma-postgres": "templates/nest-ts-prisma-postgres"
+};

package/src/update.js

@@ -0,0 +1,15 @@
+import fs from "fs-extra";
+import { execa } from "execa";
+import ora from "ora";
+
+export default async function updateProject(folder) {
+    const spinner = ora("Updating project...").start();
+
+    try {
+        if (fs.existsSync(`${folder}/.git`)) await execa("git", ["pull"], { cwd: folder });
+        await execa("npm", ["install"], { cwd: folder });
+        spinner.succeed("✔ Project updated");
+    } catch (e) {
+        spinner.fail("Update failed");
+    }
+}

package/src/utils/env.js

@@ -0,0 +1,45 @@
+import fs from "fs-extra";
+import chalk from "chalk";
+import readline from "readline";
+
+async function ask(question) {
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    return new Promise(resolve => rl.question(question, ans => {
+        rl.close();
+        resolve(ans.trim().toLowerCase());
+    }));
+}
+
+export async function generateEnv(db, folder, projectName = "myapp") {
+    // DB template map
+    const envTemplates = {
+        mongo: `MONGODB_URI="mongodb://localhost:27017/${projectName}"\nPORT=5000`,
+        mysql: `DATABASE_URL="mysql://root:password@localhost:3306/${projectName}"\nPORT=5000`,
+        postgres: `DATABASE_URL="postgresql://user:password@localhost:5432/${projectName}?schema=public"\nPORT=5000`,
+    };
+
+    if (!envTemplates[db]) {
+        console.log(chalk.red(`✘ Unknown database type: ${db}`));
+        console.log(chalk.yellow("Supported: mongo | mysql | postgres"));
+        return;
+    }
+
+    fs.ensureDirSync(folder); // auto-create target folder if missing
+    const envPath = `${folder}/.env`;
+
+    // If .env already exists, confirm overwrite
+    if (fs.existsSync(envPath)) {
+        const confirm = await ask(chalk.yellow(".env already exists. Overwrite? (y/n): "));
+        if (confirm !== "y") return console.log(chalk.red("✘ Cancelled"));
+    }
+
+    fs.writeFileSync(envPath, envTemplates[db]);
+
+    // styled success output with typing animation
+    const message = "✔ .env file generated successfully";
+    for (let char of message) {
+        process.stdout.write(chalk.green(char));
+        await new Promise(res => setTimeout(res, 12));
+    }
+    console.log("\n");
+};

package/src/utils/git.js

@@ -0,0 +1,61 @@
+import { execa } from "execa";
+import chalk from "chalk";
+import fs from "fs-extra";
+import path from "path";
+
+// small typing output utility
+async function typeLog(text, color = chalk.white, speed = 10) {
+    for (let char of text) {
+        process.stdout.write(color(char));
+        await new Promise(res => setTimeout(res, speed));
+    }
+    process.stdout.write("\n");
+}
+
+export async function ensureGitInstalled() {
+    try {
+        const gv = await execa("git", ["--version"]);
+        console.log(chalk.green("✔   Found git is already installed and its version: ", gv.stdout));
+    } catch (err) {
+        console.log(chalk.red("\n✘ Git is not installed on this system."));
+        console.log(chalk.yellow("Install Git: https://git-scm.com/downloads\n"));
+        process.exit(1);
+    }
+}
+
+export async function initGit(folder) {
+    try {
+        // check if .git already exists
+        if (fs.existsSync(path.join(folder, ".git"))) {
+            console.log(chalk.yellow("⚠ Git repository already initialized. Skipping init.\n"));
+            return;
+        }
+
+        // initialize repository
+        await typeLog("→ Initializing Git repository...", chalk.cyanBright);
+
+        await execa("git", ["init"], { cwd: folder });
+        await execa("git", ["add", "."], { cwd: folder });
+        await execa("git", ["commit", "-m", "Initial commit"], { cwd: folder });
+
+        // generate .gitignore if not exist
+        const gitignorePath = path.join(folder, ".gitignore");
+        if (!fs.existsSync(gitignorePath)) {
+            fs.writeFileSync(gitignorePath, `
+node_modules
+.env
+dist
+build
+coverage
+*.log
+`);
+            await typeLog("✔ .gitignore created", chalk.green);
+        }
+
+        await typeLog("✔ Git initialized successfully and first commit created.", chalk.green);
+
+    } catch (err) {
+        console.log(chalk.red("\n✘ Git initialization failed."));
+        console.log(chalk.gray(err.message), "\n");
+    }
+}

package/src/utils/installer.js

@@ -0,0 +1,74 @@
+import { execa } from "execa";
+import chalk from "chalk";
+import cliProgress from "cli-progress";
+import ora from "ora";
+import inquirer from "inquirer";
+
+/* Detect available package manager */
+async function detectPkgManager() {
+    const managers = ["pnpm", "yarn", "bun", "npm"];
+    for (const m of managers) {
+        try { await execa(m, ["-v"]); return m; }
+        catch { }
+    }
+    return "npm";
+}
+
+export async function installDependencies(folder) {
+    console.log(chalk.cyan("\nInstalling dependencies...\n"));
+
+    const pkgManager = await detectPkgManager();
+    const spinner = ora(`Using ${pkgManager}...`).start();
+
+    await new Promise(res => setTimeout(res, 800));
+    spinner.succeed(chalk.green(`Detected package manager: ${pkgManager}`));
+
+    const bar = new cliProgress.SingleBar({
+        format: chalk.magenta("Progress") + " |" + chalk.cyan("{bar}") + "| {percentage}%"
+    }, cliProgress.Presets.shades_classic);
+
+    bar.start(100, 0);
+
+    let percent = 0;
+    const interval = setInterval(() => {
+        percent = Math.min(percent + 2, 95);
+        bar.update(percent);
+    }, 250);
+
+    const startTime = Date.now();
+
+    try {
+        const runner = execa(pkgManager, ["install"], { cwd: folder });
+
+        runner.stdout?.on("data", d => process.stdout.write(chalk.gray(d.toString())));
+        runner.stderr?.on("data", d => process.stdout.write(chalk.red(d.toString())));
+
+        await runner;
+
+        clearInterval(interval);
+        bar.update(100);
+        bar.stop();
+
+        const time = ((Date.now() - startTime) / 1000).toFixed(1);
+        console.log(chalk.green(`\n✔ Dependencies installed successfully in ${time}s\n`));
+        return true;
+
+    } catch (err) {
+        clearInterval(interval);
+        bar.stop();
+        console.log(chalk.red("\n✖ Dependency installation failed"));
+        console.log(chalk.red("Error:"), err.message);
+
+        const { retry } = await inquirer.prompt([
+            {
+                type: "confirm",
+                name: "retry",
+                message: "Retry installation?",
+                default: true
+            }
+        ]);
+
+        if (retry) return await installDependencies(folder);
+        else return false;
+    }
+}