xpresso-cli 1.3.0

package/LICENSE

@@ -0,0 +1,15 @@
+ISC License
+
+Copyright (c) 2026, Krish Dhiman
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

package/bin/cli.js

@@ -0,0 +1,26 @@
+#!/usr/bin/env node
+
+import { program } from 'commander';
+import { initCommand } from './commands/init.js';
+import { createServiceCommand } from './commands/createService.js';
+
+// ==========================================
+// CLI Application
+// ==========================================
+
+program
+    .name('create-node-app')
+    .description('Scaffold a new Node.js application');
+
+program
+    .command('init [project-directory]', { isDefault: true })
+    .description('Initialize a new Node.js project (Default command)')
+    .action(initCommand);
+
+program
+    .command('create-service <serviceName>')
+    .alias('create')
+    .description('Scaffold a new service (model, controller, routes)')
+    .action(createServiceCommand);
+
+program.parse(process.argv);

package/bin/commands/createService.js

@@ -0,0 +1,147 @@
+import fs from 'fs';
+import path from 'path';
+import chalk from 'chalk';
+import ora from 'ora';
+
+export async function createServiceCommand(serviceName, targetDir = process.cwd()) {
+    if (!serviceName) {
+        console.error(chalk.red('Please provide a service name. Example: create-node-app create-service auth'));
+        process.exit(1);
+    }
+
+    const currentDir = targetDir;
+    const packageJsonPath = path.join(currentDir, 'package.json');
+    
+    // Default to no database if not found
+    let dbType = 'none'; 
+    
+    if (fs.existsSync(packageJsonPath)) {
+        try {
+            const pkg = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+            const deps = pkg.dependencies || {};
+            if (deps.mongoose) {
+                dbType = 'mongoose';
+            } else if (deps.sequelize) {
+                dbType = 'sequelize';
+            }
+        } catch (error) {
+            console.warn(chalk.yellow('Could not parse package.json. Defaulting to standard model generation.'));
+        }
+    } else {
+        console.warn(chalk.yellow('No package.json found in current directory. Generating service without database dependencies.'));
+    }
+
+    const serviceDir = path.join(currentDir, 'services', serviceName);
+    const controllerDir = path.join(serviceDir, 'controller');
+    const modelDir = path.join(serviceDir, 'model');
+    const routesDir = path.join(serviceDir, 'routes');
+
+    const spinner = ora(`Generating ${serviceName} service...`).start();
+
+    try {
+        // Create directories
+        fs.mkdirSync(controllerDir, { recursive: true });
+        fs.mkdirSync(modelDir, { recursive: true });
+        fs.mkdirSync(routesDir, { recursive: true });
+
+        // Generate Controller
+        const controllerContent = `export default {
+    // Add your controller methods here
+    // exampleMethod: async (req, res, next) => { ... }
+}
+`;
+        fs.writeFileSync(path.join(controllerDir, `${serviceName}.controller.js`), controllerContent);
+
+        // Generate Routes
+        const routesContent = `import express from 'express'
+import ${serviceName}Controller from '../controller/${serviceName}.controller.js'
+
+const router = express.Router({ caseSensitive: true })
+
+// Add your routes here
+// router.get('/', ${serviceName}Controller.exampleMethod)
+
+export default router
+`;
+        fs.writeFileSync(path.join(routesDir, `${serviceName}.routes.js`), routesContent);
+
+        // Generate Model
+        let modelContent = '';
+        if (dbType === 'sequelize') {
+            modelContent = `import { DataTypes } from 'sequelize'
+import sequelize from '../../../config/db.config.js'
+
+const ${serviceName.charAt(0).toUpperCase() + serviceName.slice(1)} = sequelize.define('${serviceName}', {
+    name: {
+        type: DataTypes.STRING,
+        allowNull: false
+    }
+}, {
+    timestamps: true
+})
+
+export default ${serviceName.charAt(0).toUpperCase() + serviceName.slice(1)}
+`;
+        } else {
+            // Default to mongoose structure
+            modelContent = `import mongoose from "mongoose";
+
+const ${serviceName}Schema = new mongoose.Schema({
+    
+})
+
+export default mongoose.model('${serviceName}', ${serviceName}Schema);
+`;
+        }
+        
+        fs.writeFileSync(path.join(modelDir, `${serviceName}.model.js`), modelContent);
+
+        // Try to update app.js automatically
+        const appJsPath = path.join(currentDir, 'app.js');
+        if (fs.existsSync(appJsPath)) {
+            let appJsContent = fs.readFileSync(appJsPath, 'utf8');
+
+            const importStatement = `import ${serviceName}Routes from './services/${serviceName}/routes/${serviceName}.routes.js'`;
+            const useStatement = `app.use('/api/${serviceName}', ${serviceName}Routes)`;
+
+            // Inject import statement after the last import
+            if (!appJsContent.includes(importStatement)) {
+                const lastImportIndex = appJsContent.lastIndexOf('import ');
+                if (lastImportIndex !== -1) {
+                    const endOfLastImport = appJsContent.indexOf('\n', lastImportIndex);
+                    appJsContent = appJsContent.slice(0, endOfLastImport + 1) + importStatement + '\n' + appJsContent.slice(endOfLastImport + 1);
+                } else {
+                    appJsContent = importStatement + '\n' + appJsContent;
+                }
+            }
+
+            // Inject app.use statement before app.get('/', or before export default
+            if (!appJsContent.includes(useStatement)) {
+                const appGetIndex = appJsContent.indexOf("app.get('/'");
+                if (appGetIndex !== -1) {
+                    appJsContent = appJsContent.slice(0, appGetIndex) + useStatement + '\n\n' + appJsContent.slice(appGetIndex);
+                } else {
+                    const exportIndex = appJsContent.lastIndexOf('export default app');
+                    if (exportIndex !== -1) {
+                        appJsContent = appJsContent.slice(0, exportIndex) + useStatement + '\n\n' + appJsContent.slice(exportIndex);
+                    } else {
+                        appJsContent += '\n' + useStatement + '\n';
+                    }
+                }
+            }
+
+            fs.writeFileSync(appJsPath, appJsContent);
+            spinner.succeed(`Successfully created ${chalk.green(serviceName)} service and updated app.js`);
+        } else {
+            spinner.succeed(`Successfully created ${chalk.green(serviceName)} service at ./services/${serviceName}`);
+            console.log(`\nDon't forget to register your routes in ${chalk.cyan('app.js')}!`);
+            console.log(`  import ${serviceName}Routes from './services/${serviceName}/routes/${serviceName}.routes.js'`);
+            console.log(`  app.use('/api/${serviceName}', ${serviceName}Routes)\n`);
+        }
+
+    } catch (err) {
+        spinner.fail(`Failed to create ${serviceName} service.`);
+        console.error(err);
+        process.exit(1);
+    }
+}

package/bin/commands/init.js

@@ -0,0 +1,33 @@
+import path from 'path';
+import chalk from 'chalk';
+import { fileURLToPath } from 'url';
+import { promptUser, copyTemplateFiles, installDependencies, showSuccessMessage } from '../utils/helpers.js';
+import { configureDatabase } from '../utils/database.js';
+import { createServiceCommand } from './createService.js';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+export async function initCommand(projectDirectory) {
+    // 1. Prompt User
+    const { targetDir, packageManager, database } = await promptUser(projectDirectory);
+    const targetPath = path.resolve(process.cwd(), targetDir);
+    const templateDir = path.join(__dirname, '..', '..', 'template');
+
+    console.log(`\nCreating a new Node.js app in ${chalk.green(targetPath)}\n`);
+
+    // 2. Copy Template Files
+    copyTemplateFiles(templateDir, targetPath);
+
+    // 3. Configure Database
+    configureDatabase(targetPath, database);
+
+    // 4. Dynamically generate the 'auth' service so it uses the correct DB model
+    await createServiceCommand('auth', targetPath);
+
+    // 5. Install Dependencies
+    installDependencies(targetPath, packageManager);
+
+    // 6. Success Message
+    showSuccessMessage(targetDir, targetPath, packageManager);
+}

package/bin/create-service-cli.js

@@ -0,0 +1,12 @@
+#!/usr/bin/env node
+
+import { program } from 'commander';
+import { createServiceCommand } from './commands/createService.js';
+
+program
+    .name('create-service')
+    .description('Scaffold a new service (model, controller, routes)')
+    .argument('<serviceName>', 'Name of the service to create')
+    .action(createServiceCommand);
+
+program.parse(process.argv);

package/bin/utils/database.js

@@ -0,0 +1,81 @@
+import fs from 'fs';
+import path from 'path';
+
+export function configureDatabase(targetPath, database) {
+    const packageJsonPath = path.join(targetPath, 'package.json');
+    if (!fs.existsSync(packageJsonPath)) return;
+
+    const pkg = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+    pkg.name = path.basename(targetPath);
+
+    const dbConfigPath = path.join(targetPath, 'config', 'db.config.js');
+    const targetConfigDir = path.dirname(dbConfigPath);
+    if (!fs.existsSync(targetConfigDir)) {
+        fs.mkdirSync(targetConfigDir, { recursive: true });
+    }
+
+    if (database === 'MongoDB (Mongoose)') {
+        pkg.dependencies = pkg.dependencies || {};
+        pkg.dependencies.mongoose = '^8.0.0';
+
+        const mongooseContent = `import mongoose from "mongoose"
+
+const options = {
+    serverSelectionTimeoutMS: 10000,
+    dbName: '',
+}
+
+const connectDB = async () => {
+    try {
+        await mongoose.connect('', options)
+        console.log(\`✅ MongoDB connected!\`)
+    } catch (error) {
+        console.error(\`❌ MongoDB connection error: \${error.message}\`)
+        process.exit(1)
+    }
+}
+
+export default connectDB`;
+        fs.writeFileSync(dbConfigPath, mongooseContent);
+
+    } else if (database === 'PostgreSQL (Sequelize)') {
+        pkg.dependencies = pkg.dependencies || {};
+        pkg.dependencies.sequelize = '^6.35.0';
+        pkg.dependencies.pg = '^8.11.3';
+        pkg.dependencies['pg-hstore'] = '^2.3.4';
+
+        const sequelizeContent = `import { Sequelize } from "sequelize"
+
+export const sequelize = new Sequelize(
+    '',          // DB name
+    '',         // User
+    '',      // Password
+    {
+        host: '',
+        dialect: 'postgres',
+        logging: false,
+        port: ''
+    }
+) 
+
+// Test connection
+// (async () => {
+//     try {
+//         await sequelize.authenticate();
+//         console.log("PostgreSQL connected with Sequelize");
+//     } catch (err) {
+//         console.error("Error:", err.message);
+//     }
+// })()
+
+export default sequelize
+`;
+        fs.writeFileSync(dbConfigPath, sequelizeContent);
+
+    } else {
+        fs.writeFileSync(dbConfigPath, '// No database configured\n');
+    }
+
+    // Save updated package.json
+    fs.writeFileSync(packageJsonPath, JSON.stringify(pkg, null, 2));
+}

package/bin/utils/helpers.js

@@ -0,0 +1,96 @@
+import fs from 'fs';
+import path from 'path';
+import chalk from 'chalk';
+import { execSync } from 'child_process';
+import ora from 'ora';
+import inquirer from 'inquirer';
+
+export async function promptUser(projectDirectory) {
+    let targetDir = projectDirectory;
+
+    if (!targetDir) {
+        const answers = await inquirer.prompt([
+            {
+                type: 'input',
+                name: 'projectDirectory',
+                message: 'What is your project named?',
+                default: 'my-app'
+            }
+        ]);
+        targetDir = answers.projectDirectory;
+    }
+
+    const { packageManager, database } = await inquirer.prompt([
+        {
+            type: 'list',
+            name: 'packageManager',
+            message: 'Which package manager would you like to use?',
+            choices: ['npm', 'yarn', 'pnpm'],
+            default: 'npm'
+        },
+        {
+            type: 'list',
+            name: 'database',
+            message: 'Which database would you like to use?',
+            choices: ['MongoDB (Mongoose)', 'PostgreSQL (Sequelize)', 'None'],
+            default: 'MongoDB (Mongoose)'
+        }
+    ]);
+
+    return { targetDir, packageManager, database };
+}
+
+export function copyTemplateFiles(templateDir, targetPath) {
+    const spinner = ora('Copying template files...').start();
+
+    if (fs.existsSync(targetPath)) {
+        spinner.fail(`Directory ${path.basename(targetPath)} already exists.`);
+        process.exit(1);
+    }
+
+    fs.mkdirSync(targetPath, { recursive: true });
+
+    const copyRecursiveSync = (src, dest) => {
+        const exists = fs.existsSync(src);
+        const stats = exists && fs.statSync(src);
+        if (exists && stats.isDirectory()) {
+            if (!fs.existsSync(dest)) fs.mkdirSync(dest);
+            fs.readdirSync(src).forEach((child) => {
+                if (child === 'node_modules') return;
+                copyRecursiveSync(path.join(src, child), path.join(dest, child));
+            });
+        } else {
+            fs.copyFileSync(src, dest);
+        }
+    };
+
+    try {
+        copyRecursiveSync(templateDir, targetPath);
+        spinner.succeed('Template copied successfully.');
+    } catch (err) {
+        spinner.fail('Failed to copy template.');
+        console.error(err);
+        process.exit(1);
+    }
+}
+
+export function installDependencies(targetPath, packageManager) {
+    const installSpinner = ora(`Installing dependencies using ${packageManager}...`).start();
+    try {
+        execSync(`${packageManager} install`, { cwd: targetPath, stdio: 'pipe' });
+        installSpinner.succeed('Dependencies installed successfully.');
+    } catch (err) {
+        installSpinner.fail('Failed to install dependencies.');
+        console.error(err);
+    }
+}
+
+export function showSuccessMessage(targetDir, targetPath, packageManager) {
+    console.log(`\n${chalk.green('Success!')} Created ${path.basename(targetPath)} at ${targetPath}`);
+    console.log('\nInside that directory, you can run several commands:\n');
+    console.log(`  ${chalk.cyan(`${packageManager} run dev`)}`);
+    console.log('    Starts the development server with nodemon.\n');
+    console.log('We suggest that you begin by typing:\n');
+    console.log(`  ${chalk.cyan('cd')} ${targetDir}`);
+    console.log(`  ${chalk.cyan(`${packageManager} run dev`)}\n`);
+}

package/package.json

@@ -0,0 +1,52 @@
+{
+    "name": "xpresso-cli",
+    "version": "1.3.0",
+    "description": "A CLI tool to scaffold Express.js applications.",
+    "main": "index.js",
+    "type": "module",
+    "private": false,
+    "bin": {
+        "xpresso-cli": "bin/cli.js",
+        "create-service": "bin/create-service-cli.js"
+    },
+    "scripts": {
+        "start": "node ./bin/cli.js",
+        "create-service": "node ./bin/cli.js create-service"
+    },
+    "dependencies": {
+        "chalk": "^5.3.0",
+        "commander": "^12.0.0",
+        "inquirer": "^9.2.14",
+        "ora": "^8.0.1"
+    },
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/KrishDhimanOfficial/create_node_app.git"
+    },
+    "keywords": [
+        "express",
+        "express.js",
+        "create-express-app",
+        "node",
+        "nodejs",
+        "cli",
+        "scaffold",
+        "generator",
+        "express-generator",
+        "boilerplate",
+        "starter",
+        "mvc",
+        "modular",
+        "api",
+        "mongoose",
+        "mongodb",
+        "sequelize",
+        "postgresql"
+    ],
+    "author": "Krish Dhiman",
+    "license": "ISC",
+    "bugs": {
+        "url": "https://github.com/KrishDhimanOfficial/create_node_app/issues"
+    },
+    "homepage": "https://github.com/KrishDhimanOfficial/create_node_app#readme"
+}

package/readme.md

@@ -0,0 +1,128 @@
+# 🚀 xpresso-cli
+
+[![npm version](https://img.shields.io/npm/v/xpresso-cli.svg)](https://www.npmjs.com/package/xpresso-cli)
+[![License: ISC](https://img.shields.io/badge/License-ISC-blue.svg)](https://opensource.org/licenses/ISC)
+
+A powerful, incredibly fast CLI tool to instantly scaffold production-ready Node.js Express applications. It comes packed with built-in database configurations and an intuitive modular service generator, saving you hours of boilerplate setup.
+
+---
+
+## ✨ Features
+
+- **⚡ Instant Setup:** Scaffolds a complete, production-ready Express.js MVC/Modular server structure in seconds.
+- **🗄️ Database Ready:** Automatic, hassle-free database setup for **MongoDB (Mongoose)** or **PostgreSQL (Sequelize)**.
+- **🛠️ Service Generator:** Built-in CLI command to automatically generate new service modules (Controllers, Models, Routes) instantly.
+- **🔒 Best Practices Built-in:** Pre-configured `app.js` with CORS, compression, and global error handlers.
+- **📦 Package Manager Choice:** Support for `npm`, `yarn`, and `pnpm`.
+
+---
+
+## 📖 Step-by-Step Guide
+
+### Step 1: Scaffold a New Application
+
+You can use `npx` to create a new application instantly without installing anything globally:
+
+```bash
+npx xpresso-cli my-app
+```
+
+**Alternatively, you can install the CLI globally:**
+
+```bash
+npm install -g xpresso-cli
+```
+
+Then you can use it directly anywhere:
+```bash
+xpresso-cli my-app
+```
+
+*(If you run the command without a folder name, the CLI will interactively ask you for it!)*
+
+### Step 2: Configure Your Project
+
+The interactive CLI will prompt you to make a few quick decisions to tailor your app:
+
+1. **Package Manager:** Choose between `npm`, `yarn`, or `pnpm`.
+2. **Database:** Select your preferred database:
+   - `MongoDB` (uses Mongoose)
+   - `PostgreSQL` (uses Sequelize)
+   - `None` (if you want to set it up yourself later)
+
+Once selected, the CLI will automatically:
+- Generate the folder structure.
+- Configure your database connection file.
+- Generate an initial `auth` service tailored to your database choice.
+- Install all necessary dependencies automatically!
+
+### Step 3: Run Your Application
+
+Navigate into your newly created project and start the development server:
+
+```bash
+cd my-app
+npm start
+```
+*(If you selected yarn or pnpm, use `yarn start` or `pnpm start` respectively).*
+
+You now have a fully functional Node.js server running! 🎉
+
+---
+
+## 🏗️ Generating New Services (The Magic)
+
+Once your application is created, `xpresso-cli` provides an amazing built-in code generator that saves you from writing repetitive boilerplate for new features.
+
+To generate a new service (e.g., for `user` management), navigate into your project folder and run:
+
+```bash
+npx create-service user
+```
+*(If you installed the CLI globally, you can simply type `create-service user`)*
+
+### What happens behind the scenes?
+When you run `create-service user`, the CLI automatically:
+1. Creates a Controller (`services/user/controller/user.controller.js`).
+2. Creates Routes (`services/user/routes/user.routes.js`).
+3. Creates a Model (`services/user/model/user.model.js`) specifically tailored to the database you selected during initial setup!
+4. **Auto-wires everything:** It automatically updates your main `app.js` file to import and register your new `user` routes. You don't have to touch a thing!
+
+---
+
+## 📂 Folder Structure
+
+Here is the clean, modular structure generated for your app:
+
+```text
+my-app/
+├── bin/
+│   └── www                    # Server startup script
+├── config/
+│   └── db.config.js           # Database connection setup
+├── public/                    # Static files
+├── services/
+│   ├── auth/                  # Automatically generated on init
+│   │   ├── controller/
+│   │   ├── model/
+│   │   └── routes/
+│   └── <your-service>/        # Automatically generated via 'create-service'
+├── utils/
+│   └── helper.utils.js        # Helper functions and utilities
+├── app.js                     # Express app configuration (auto-updated with new routes)
+└── package.json               # Project dependencies and scripts
+```
+
+---
+
+## 🤝 Contributing
+
+Contributions, issues, and feature requests are always welcome! Feel free to check the [issues page](https://github.com/KrishDhimanOfficial/create_node_app/issues).
+
+---
+
+## 📄 License
+
+This project is licensed under the [ISC License](LICENSE).
+
+**Created with ❤️ by [Krish Dhiman](https://github.com/KrishDhimanOfficial)**

package/template/app.js

@@ -0,0 +1,36 @@
+import express from 'express'
+import cookieParser from 'cookie-parser'
+import logger from 'morgan'
+import { globalErrorHandler } from './utils/helper.utils.js'
+import compression from 'compression'
+import cors from 'cors'
+import { fileURLToPath } from 'node:url'
+import path from 'node:path'
+
+const __filename = fileURLToPath(import.meta.url)
+const __dirname = path.dirname(__filename)
+const app = express()
+
+app.use(cors())
+app.use(logger('dev'))
+app.use(express.json({ limit: '10kb' }))
+app.use(express.urlencoded({ extended: true }))
+app.use(compression(
+  {
+    level: 4, // compression level
+    threshold: 0, // Compress all
+    memLevel: 9, // memory usuage
+    filter: (req, res) => compression.filter(req, res)
+  }
+))
+app.use(cookieParser())
+app.use(express.static(path.join(__dirname, 'public')))
+
+app.get('/', (req, res) => {
+  return res.send('Hello World!')
+})
+
+// error handler
+app.use(globalErrorHandler)
+
+export default app

package/template/bin/www

@@ -0,0 +1,93 @@
+#!/usr/bin/env node
+
+/**
+ * Module dependencies.
+ */
+
+import app from '../app.js';
+import Debug from 'debug';
+const debug = Debug('create-node:server');
+import http from 'http';
+
+/**
+ * Get port from environment and store in Express.
+ */
+
+const port = normalizePort(process.env.PORT || '3000');
+app.set('port', port);
+
+/**
+ * Create HTTP server.
+ */
+
+const server = http.createServer(app);
+
+/**
+ * Listen on provided port, on all network interfaces.
+ */
+
+server.listen(port, () => {
+  console.log(`✅ Server is running on port ${port}`)
+})
+server.on('error', onError);
+server.on('listening', onListening);
+
+/**
+ * Normalize a port into a number, string, or false.
+ */
+
+function normalizePort(val) {
+  const port = parseInt(val, 10);
+
+  if (isNaN(port)) {
+    // named pipe
+    return val;
+  }
+
+  if (port >= 0) {
+    // port number
+    return port;
+  }
+
+  return false;
+}
+
+/**
+ * Event listener for HTTP server "error" event.
+ */
+
+function onError(error) {
+  if (error.syscall !== 'listen') {
+    throw error;
+  }
+
+  const bind = typeof port === 'string'
+    ? 'Pipe ' + port
+    : 'Port ' + port;
+
+  // handle specific listen errors with friendly messages
+  switch (error.code) {
+    case 'EACCES':
+      console.error(bind + ' requires elevated privileges');
+      process.exit(1);
+      break;
+    case 'EADDRINUSE':
+      console.error(bind + ' is already in use');
+      process.exit(1);
+      break;
+    default:
+      throw error;
+  }
+}
+
+/**
+ * Event listener for HTTP server "listening" event.
+ */
+
+function onListening() {
+  const addr = server.address();
+  const bind = typeof addr === 'string'
+    ? 'pipe ' + addr
+    : 'port ' + addr.port;
+  debug('Listening on ' + bind);
+}

package/template/config/config.js

@@ -0,0 +1,6 @@
+import dotenv from 'dotenv'
+dotenv.config({ quiet: true })
+
+export default {
+
+}

package/template/package.json

@@ -0,0 +1,21 @@
+{
+  "name": "backend",
+  "version": "0.0.0",
+  "private": false,
+  "type": "module",
+  "scripts": {
+    "start": "node ./bin/www",
+    "dev": "nodemon ./bin/www"
+  },
+  "dependencies": {
+    "compression": "^1.8.1",
+    "cookie-parser": "~1.4.4",
+    "cors": "^2.8.6",
+    "debug": "~2.6.9",
+    "express": "^4.22.1",
+    "morgan": "^1.10.1"
+  },
+  "devDependencies": {
+    "nodemon": "^3.1.14"
+  }
+}

package/template/public/css/style.css

@@ -0,0 +1,8 @@
+body {
+  padding: 50px;
+  font: 14px "Lucida Grande", Helvetica, Arial, sans-serif;
+}
+
+a {
+  color: #00B7FF;
+}

package/template/utils/helper.utils.js

@@ -0,0 +1,33 @@
+import { deleteFile } from './removeFile.utils.js'
+
+export const ApiError = (message, statusCode) => {
+    const error = new Error(message)
+    error.statusCode = statusCode
+    error.success = false
+    return error
+}
+
+export const asyncHandler = (fn, name = 'UnknownController') => {
+
+    return (req, res, next) => {
+        Promise.resolve(fn(req, res, next)).catch((err) => {
+            console.error(`🔥 Error in ${name} : ${err.message}`)
+            if (req.file?.filename) deleteFile(req.file?.path)
+            if (req.files && req.files?.length > 0) req.files?.forEach(file => deleteFile(file.path))
+            next(err)
+        })
+    }
+}
+
+export const globalErrorHandler = (err, req, res, next) => {
+    const statusCode = err.statusCode || 500;
+
+    // For API requests (JSON response)
+    return res.status(statusCode).json(
+        {
+            success: false,
+            message: err.message || 'Something went wrong',
+        }
+    )
+}
+

package/template/utils/removeFile.utils.js

@@ -0,0 +1,21 @@
+import { fileURLToPath } from 'node:url'
+import path from 'node:path'
+import fs from 'node:fs'
+import chalk from 'chalk'
+
+const __filename = fileURLToPath(import.meta.url)
+const __dirname = path.dirname(__filename)
+
+
+const deleteFile = async (folderPath) => {
+    try {
+        const imagePath = path.join(__dirname, '..', folderPath)
+        if (!fs.existsSync(imagePath)) return
+
+        await fs.promises.rm(imagePath, { force: true })
+    } catch (error) {
+        console.error(chalk.red('deleteFile error:', error.message))
+    }
+}
+
+export { deleteFile }