nodejs-quickstart-structure 1.1.6

package/README.md

@@ -0,0 +1,98 @@
+# Node.js Quickstart Generator
+
+A powerful CLI tool to scaffold production-ready Node.js microservices with built-in best practices, allowing you to choose between **MVC** or **Clean Architecture**, **JavaScript** or **TypeScript**, and your preferred database.
+
+![Demo](docs/demo.gif)
+
+## Features
+
+- **Interactive CLI**: Easy-to-use prompts to configure your project.
+- **Multiple Architectures**: Supports both **MVC** (Model-View-Controller) and **Clean Architecture**.
+- **Language Support**: Choose between **JavaScript** and **TypeScript**.
+- **Database Integration**: Pre-configured setup for **MySQL** or **PostgreSQL**.
+- **Microservices Ready**: Optional **Kafka** integration for event-driven communication.
+- **Dockerized**: Automatically generates `docker-compose.yml` for DB, Kafka, and Zookeeper.
+- **Database Migrations**: Integrated **Flyway** support for SQL migrations.
+- **Professional Standards**: Generated projects come with highly professional, industry-standard tooling.
+
+## 🏆 Professional Standards (New)
+
+We don't just generate boilerplate; we generate **production-ready** foundations. Every project includes:
+
+-   **🔍 Code Quality**: Pre-configured `Eslint` and `Prettier` for consistent coding standards.
+-   **🛡️ Security**: Built-in `Helmet`, `HPP`, `CORS`, and Rate-Limiting middleware.
+-   **🧪 Testing Strategy**: Integrated `Jest` and `Supertest` setup for Unit and Integration testing.
+-   **🔄 CI/CD Support**: Optional **GitHub Actions** workflow integration.
+-   **⚓ Git Hooks**: `Husky` and `Lint-Staged` to ensure no bad code is ever committed.
+-   **🐳 DevOps**: Highly optimized **Multi-Stage Dockerfile** for small, secure production images.
+
+## Installation
+
+You can install the tool globally directly from GitHub:
+
+```bash
+npm install -g paudang/nodejs-quickstart-structure
+```
+
+### Manual Installation (For Development)
+
+If you want to modify the CLI itself:
+
+1.  Clone this repository:
+    ```bash
+    git clone https://github.com/paudang/nodejs-quickstart-structure.git
+    cd nodejs-quickstart-structure
+    ```
+2.  Install dependencies:
+    ```bash
+    npm install
+    ```
+3.  Link globally:
+    ```bash
+    npm link
+    ```
+
+## Usage
+
+Once installed, simply run the following command in any directory where you want to create a new project:
+
+```bash
+nodejs-quickstart init
+```
+
+### Configuration Options
+
+The CLI will guide you through the following steps:
+
+1.  **Project Name**: The name of the folder to create.
+2.  **Language**: `JavaScript` or `TypeScript`.
+3.  **Architecture**: `MVC` or `Clean Architecture`.
+4.  **Database**: `MySQL` or `PostgreSQL`.
+5.  **Database Name**: The name of the initial database.
+6.  **Communication**: `REST APIs` (default) or `Kafka`.
+7.  **CI/CD**: `Include GitHub Actions Workflow` (Optional).
+
+## Generated Project Structure
+
+The generated project will include:
+
+-   `src/`: Source code (controllers, routes, services/use-cases).
+-   `flyway/sql/`: SQL migration scripts.
+-   `docker-compose.yml`: Services configuration for DB, Flyway, and Kafka.
+-   `package.json`: Dependencies and scripts (`start`, `dev`, `build`).
+-   `tsconfig.json`: (If TypeScript is selected) Type checking configuration.
+
+### Getting Started with the Generated App
+
+```bash
+cd <your-project-name>
+
+# Start infrastructure (DB, etc.)
+npm install
+
+docker-compose up
+```
+
+## License
+
+ISC

package/bin/index.js

@@ -0,0 +1,66 @@
+#!/usr/bin/env node
+
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { getProjectDetails } from '../lib/prompts.js';
+import { generateProject } from '../lib/generator.js';
+import { readFileSync } from 'fs';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const pkg = JSON.parse(readFileSync(join(__dirname, '../package.json'), 'utf-8'));
+
+const program = new Command();
+
+program
+    .name('nodejs-quickstart')
+    .description('🚀 CLI to scaffold production-ready Node.js microservices.\n\nGenerates projects with:\n- MVC or Clean Architecture\n- REST or Kafka\n- MySQL or PostgreSQL\n- Docker & Flyway support')
+    .version(pkg.version, '-v, --version', 'Output the current version')
+    .addHelpText('after', `
+\n${chalk.yellow('Example:')}
+  $ nodejs-quickstart init   ${chalk.gray('# Start the interactive setup')}
+`);
+
+program
+    .command('init')
+    .description('Initialize a new Node.js project')
+    .option('-n, --project-name <name>', 'Project name')
+    .option('-l, --language <language>', 'Language (JavaScript, TypeScript)')
+    .option('-a, --architecture <architecture>', 'Architecture (MVC, Clean Architecture)')
+    .option('--view-engine <view>', 'View Engine (None, EJS, Pug) - MVC only')
+    .option('-d, --database <database>', 'Database (MySQL, PostgreSQL)')
+    .option('--db-name <name>', 'Database name')
+    .option('-c, --communication <communication>', 'Communication (REST APIs, Kafka)')
+    .option('--include-ci', 'Include GitHub Actions CI Workflow')
+    .action(async (options) => {
+        // Fix for Commander camelCase conversion
+        if (options.includeCi) {
+            options.includeCI = options.includeCi;
+            delete options.includeCi;
+        }
+
+        console.log(chalk.blue('Welcome to the Node.js Quickstart Generator!'));
+
+        try {
+            const answers = await getProjectDetails(options);
+            console.log(chalk.green('\nConfiguration received:'));
+            console.log(JSON.stringify(answers, null, 2));
+
+            console.log(chalk.yellow('\nGenerating project...'));
+            await generateProject(answers);
+
+            console.log(chalk.green('\n✔ Project generated successfully!'));
+            console.log(chalk.cyan(`\nNext steps:\n  cd ${answers.projectName}\n  npm install\n  docker-compose up\n-----------------------\nStart the app manually:\n  npm install\n  npm run dev`));
+
+        } catch (error) {
+            console.error(chalk.red('Error generating project:'), error);
+            process.exit(1);
+        }
+    });
+
+program.parse(process.argv);
+
+if (!process.argv.slice(2).length) {
+    program.outputHelp();
+}

package/docs/generateCase.md

@@ -0,0 +1,58 @@
+# NodeJS Quickstart Generator - Test Cases
+
+This document lists the **32 possible project combinations** supported by the `nodejs-quickstart` CLI. These combinations cover all supported languages, architectures, databases, and communication patterns.
+
+## Summary
+- **MVC Architecture**: 24 Combinations
+  - (2 Languages × 3 View Engines × 2 Databases × 2 Patterns)
+- **Clean Architecture**: 8 Combinations
+  - (2 Languages × 1 View Engine (None) × 2 Databases × 2 Patterns)
+
+**Total Core Combinations: 32**
+
+> **Note on CI/CD**: Each of these 32 combinations can be generated with or without the **GitHub Actions CI Workflow** (`--include-ci`). This effectively creates **64 possible project states**. The validation script currently defaults to *including* CI to verify the full "Professional Standards" feature set.
+
+---
+
+## 1. MVC Architecture (24 Cases)
+
+| # | Language | Architecture | View Engine | Database | Communication |
+| :--- | :--- | :--- | :--- | :--- | :--- |
+| 1 | JavaScript | MVC | None | MySQL | REST APIs |
+| 2 | JavaScript | MVC | None | MySQL | Kafka |
+| 3 | JavaScript | MVC | None | PostgreSQL | REST APIs |
+| 4 | JavaScript | MVC | None | PostgreSQL | Kafka |
+| 5 | JavaScript | MVC | EJS | MySQL | REST APIs |
+| 6 | JavaScript | MVC | EJS | MySQL | Kafka |
+| 7 | JavaScript | MVC | EJS | PostgreSQL | REST APIs |
+| 8 | JavaScript | MVC | EJS | PostgreSQL | Kafka |
+| 9 | JavaScript | MVC | Pug | MySQL | REST APIs |
+| 10 | JavaScript | MVC | Pug | MySQL | Kafka |
+| 11 | JavaScript | MVC | Pug | PostgreSQL | REST APIs |
+| 12 | JavaScript | MVC | Pug | PostgreSQL | Kafka |
+| 13 | TypeScript | MVC | None | MySQL | REST APIs |
+| 14 | TypeScript | MVC | None | MySQL | Kafka |
+| 15 | TypeScript | MVC | None | PostgreSQL | REST APIs |
+| 16 | TypeScript | MVC | None | PostgreSQL | Kafka |
+| 17 | TypeScript | MVC | EJS | MySQL | REST APIs |
+| 18 | TypeScript | MVC | EJS | MySQL | Kafka |
+| 19 | TypeScript | MVC | EJS | PostgreSQL | REST APIs |
+| 20 | TypeScript | MVC | EJS | PostgreSQL | Kafka |
+| 21 | TypeScript | MVC | Pug | MySQL | REST APIs |
+| 22 | TypeScript | MVC | Pug | MySQL | Kafka |
+| 23 | TypeScript | MVC | Pug | PostgreSQL | REST APIs |
+| 24 | TypeScript | MVC | Pug | PostgreSQL | Kafka |
+
+## 2. Clean Architecture (8 Cases)
+*Note: Clean Architecture does not use server-side view engines (EJS/Pug).*
+
+| # | Language | Architecture | View Engine | Database | Communication |
+| :--- | :--- | :--- | :--- | :--- | :--- |
+| 25 | JavaScript | Clean Architecture | N/A | MySQL | REST APIs |
+| 26 | JavaScript | Clean Architecture | N/A | MySQL | Kafka |
+| 27 | JavaScript | Clean Architecture | N/A | PostgreSQL | REST APIs |
+| 28 | JavaScript | Clean Architecture | N/A | PostgreSQL | Kafka |
+| 29 | TypeScript | Clean Architecture | N/A | MySQL | REST APIs |
+| 30 | TypeScript | Clean Architecture | N/A | MySQL | Kafka |
+| 31 | TypeScript | Clean Architecture | N/A | PostgreSQL | REST APIs |
+| 32 | TypeScript | Clean Architecture | N/A | PostgreSQL | Kafka |

package/lib/generator.js

@@ -0,0 +1,315 @@
+import fs from 'fs-extra';
+import path from 'path';
+import ejs from 'ejs';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+export const generateProject = async (config) => {
+    const { projectName, architecture, database, dbName, communication, language, viewEngine, includeCI } = config;
+    const targetDir = path.resolve(process.cwd(), projectName);
+    const templatesDir = path.join(__dirname, '../templates');
+
+    // 1. Create project directory
+    if (await fs.pathExists(targetDir)) {
+        throw new Error(`Directory ${projectName} already exists.`);
+    }
+    await fs.ensureDir(targetDir);
+
+    // 2. Select Structure Template
+    const structureMap = {
+        'MVC': 'mvc',
+        'Clean Architecture': 'clean-architecture'
+    };
+    const archTemplate = structureMap[architecture];
+    const langExt = language === 'TypeScript' ? 'ts' : 'js';
+    const templatePath = path.join(templatesDir, archTemplate, langExt);
+
+    // Copy base structure
+    await fs.copy(templatePath, targetDir);
+
+    // 3. Render package.json
+    const packageJsonPath = path.join(targetDir, 'package.json');
+    const packageTemplate = await fs.readFile(path.join(templatesDir, 'common', 'package.json.ejs'), 'utf-8');
+    const packageContent = ejs.render(packageTemplate, {
+        projectName,
+        database,
+        communication,
+        language,
+        viewEngine
+    });
+    await fs.writeFile(packageJsonPath, packageContent);
+
+    // 4. Render docker-compose.yml
+    const dockerComposePath = path.join(targetDir, 'docker-compose.yml');
+    const dockerTemplate = await fs.readFile(path.join(templatesDir, 'common', 'docker-compose.yml.ejs'), 'utf-8');
+    const dockerContent = ejs.render(dockerTemplate, {
+        projectName,
+        database,
+        dbName,
+        communication
+    });
+    await fs.writeFile(dockerComposePath, dockerContent);
+
+    // Render README.md
+    const readmePath = path.join(targetDir, 'README.md');
+    const readmeTemplate = await fs.readFile(path.join(templatesDir, 'common', 'README.md.ejs'), 'utf-8');
+    const readmeContent = ejs.render(readmeTemplate, {
+        projectName,
+        architecture,
+        database,
+        communication,
+        language
+    });
+    await fs.writeFile(readmePath, readmeContent);
+
+    // Render index file (ts/js)
+    const indexFileName = language === 'TypeScript' ? 'index.ts' : 'index.js';
+    const indexPath = path.join(targetDir, 'src', indexFileName);
+    const indexTemplateSource = path.join(templatePath, 'src', `${indexFileName}.ejs`);
+    
+    if (await fs.pathExists(indexTemplateSource)) {
+        const indexTemplate = await fs.readFile(indexTemplateSource, 'utf-8');
+        const indexContent = ejs.render(indexTemplate, { 
+            communication, 
+            viewEngine,
+            database,
+            architecture,
+            projectName
+        });
+        await fs.writeFile(indexPath, indexContent);
+        await fs.remove(path.join(targetDir, 'src', `${indexFileName}.ejs`));
+    }
+
+    // Render Dynamic Controllers/Repositories (User) because they depend on DB type
+    // MVC Controller
+    if (architecture === 'MVC') {
+        const userControllerName = language === 'TypeScript' ? 'userController.ts' : 'userController.js';
+        const userControllerPath = path.join(targetDir, 'src/controllers', userControllerName);
+        const userControllerTemplate = path.join(templatePath, 'src/controllers', `${userControllerName}.ejs`);
+
+        if (await fs.pathExists(userControllerTemplate)) {
+            const content = ejs.render(await fs.readFile(userControllerTemplate, 'utf-8'), { database });
+            await fs.writeFile(userControllerPath, content);
+            await fs.remove(path.join(targetDir, 'src/controllers', `${userControllerName}.ejs`));
+        }
+    } 
+    // Clean Architecture Repo
+    else if (architecture === 'Clean Architecture') {
+        const repoName = language === 'TypeScript' ? 'UserRepository.ts' : 'UserRepository.js';
+        const repoPath = path.join(targetDir, 'src/infrastructure/repositories', repoName); 
+        const repoTemplate = path.join(templatePath, 'src/infrastructure/repositories', `${repoName}.ejs`);
+
+        if (await fs.pathExists(repoTemplate)) {
+            const content = ejs.render(await fs.readFile(repoTemplate, 'utf-8'), { database });
+            await fs.writeFile(repoPath, content);
+            await fs.remove(path.join(targetDir, 'src/infrastructure/repositories', `${repoName}.ejs`));
+        }
+    }
+    // Render Server (Clean Arch JS only)
+    if (architecture === 'Clean Architecture' && language === 'JavaScript') {
+         const serverName = 'server.js';
+         const serverPath = path.join(targetDir, 'src/infrastructure/webserver', serverName);
+         const serverTemplate = path.join(templatePath, 'src/infrastructure/webserver', `${serverName}.ejs`);
+         
+         if (await fs.pathExists(serverTemplate)) {
+             const content = ejs.render(await fs.readFile(serverTemplate, 'utf-8'), { communication });
+             await fs.writeFile(serverPath, content);
+             await fs.remove(path.join(targetDir, 'src/infrastructure/webserver', `${serverName}.ejs`));
+         }
+    }
+
+    // Copy Kafka files if selected
+    if (communication === 'Kafka') {
+        const kafkaSource = path.join(templatesDir, 'common', 'kafka', langExt);
+        await fs.copy(kafkaSource, path.join(targetDir, 'src'));
+
+        if (architecture === 'Clean Architecture') {
+            // Clean Architecture Restructuring
+            await fs.ensureDir(path.join(targetDir, 'src/infrastructure/messaging'));
+            await fs.ensureDir(path.join(targetDir, 'src/infrastructure/config'));
+
+            const serviceExt = language === 'TypeScript' ? 'ts' : 'js';
+            
+            // Move Service to Infrastructure/Messaging
+            await fs.move(
+                path.join(targetDir, `src/services/kafkaService.${serviceExt}`), 
+                path.join(targetDir, `src/infrastructure/messaging/kafkaClient.${serviceExt}`),
+                { overwrite: true }
+            );
+
+            // Move Config to Infrastructure/Config
+            await fs.move(
+                path.join(targetDir, `src/config/kafka.${serviceExt}`),
+                path.join(targetDir, `src/infrastructure/config/kafka.${serviceExt}`),
+                { overwrite: true }
+            );
+
+            // Cleanup old folders
+            await fs.remove(path.join(targetDir, 'src/services'));
+            // Only remove src/config if empty? But src/config came from kafka copy.
+            // However, other parts might use src/config?
+            // In Clean Arch, config is usually in infrastructure? 
+            // Only Kafka adds src/config. Base template doesn't have src/config for Clean Arch (it uses src/infrastructure/database).
+            await fs.remove(path.join(targetDir, 'src/config'));
+
+            // Remove REST-specific folders (Interfaces)
+            await fs.remove(path.join(targetDir, 'src/interfaces/routes'));
+            await fs.remove(path.join(targetDir, 'src/interfaces/controllers'));
+        } else if (architecture === 'MVC' && (!viewEngine || viewEngine === 'None')) {
+            // MVC Cleanup
+            await fs.remove(path.join(targetDir, 'src/controllers'));
+            await fs.remove(path.join(targetDir, 'src/routes'));
+        }
+    }
+
+    // 5. Copy Common Files (.gitignore, Dockerfile, etc.)
+    await fs.copy(path.join(templatesDir, 'common', '_gitignore'), path.join(targetDir, '.gitignore'));
+    await fs.copy(path.join(templatesDir, 'common', '.dockerignore'), path.join(targetDir, '.dockerignore'));
+    // await fs.copy(path.join(templatesDir, 'common', 'Dockerfile'), path.join(targetDir, 'Dockerfile'));
+    const dockerfileTemplate = await fs.readFile(path.join(templatesDir, 'common', 'Dockerfile'), 'utf-8');
+    const dockerfileContent = ejs.render(dockerfileTemplate, { 
+        language,
+        viewEngine
+    });
+    await fs.writeFile(path.join(targetDir, 'Dockerfile'), dockerfileContent);
+
+    if (language === 'TypeScript') {
+        await fs.copy(path.join(templatesDir, 'common', 'tsconfig.json'), path.join(targetDir, 'tsconfig.json'));
+    }
+
+    // 6. Database Migrations (Flyway)
+    await fs.ensureDir(path.join(targetDir, 'flyway/sql'));
+    const dbType = database === 'PostgreSQL' ? 'postgres' : 'mysql';
+    await fs.copy(path.join(templatesDir, 'db', dbType), path.join(targetDir, 'flyway/sql'));
+
+    // 7. Database Config
+    const dbConfigFileName = language === 'TypeScript' ? 'database.ts' : 'database.js';
+    const dbConfigTemplateSource = path.join(templatesDir, 'common', 'database', langExt, `${dbConfigFileName}.ejs`);
+    
+    let dbConfigTarget;
+
+
+    // Copy configurations
+    if (architecture === 'MVC') {
+        // Copy Views
+        if (viewEngine && viewEngine !== 'None') {
+            await fs.copy(path.join(templatesDir, 'common', 'views', viewEngine.toLowerCase()), path.join(targetDir, 'src/views'));
+        }
+        await fs.ensureDir(path.join(targetDir, 'src/config'));
+        dbConfigTarget = path.join(targetDir, 'src/config', dbConfigFileName);
+    } else {
+        // Clean Architecture
+        await fs.ensureDir(path.join(targetDir, 'src/infrastructure/database'));
+        dbConfigTarget = path.join(targetDir, 'src/infrastructure/database', dbConfigFileName);
+    }
+
+    if (await fs.pathExists(dbConfigTemplateSource)) {
+        const dbTemplate = await fs.readFile(dbConfigTemplateSource, 'utf-8');
+        const dbContent = ejs.render(dbTemplate, { database, dbName });
+        await fs.writeFile(dbConfigTarget, dbContent);
+    }
+
+    // Render Models
+    const modelFileName = language === 'TypeScript' ? 'User.ts' : 'User.js';
+    const modelTemplateSource = path.join(templatesDir, 'common', 'database', langExt, 'models', `${modelFileName}.ejs`);
+    let modelTarget;
+
+    if (architecture === 'MVC') {
+        await fs.ensureDir(path.join(targetDir, 'src/models'));
+        modelTarget = path.join(targetDir, 'src/models', modelFileName);
+    } else {
+        await fs.ensureDir(path.join(targetDir, 'src/infrastructure/database/models'));
+        modelTarget = path.join(targetDir, 'src/infrastructure/database/models', modelFileName);
+    }
+
+    if (await fs.pathExists(modelTemplateSource)) {
+        // Models need architecture to decide import path
+        const modelTemplate = await fs.readFile(modelTemplateSource, 'utf-8');
+        const modelContent = ejs.render(modelTemplate, { architecture });
+        await fs.writeFile(modelTarget, modelContent);
+    }
+
+    // 8. View Engine (MVC)
+    if (architecture === 'MVC' && viewEngine && viewEngine !== 'None') {
+    }
+
+    // 9. Render Swagger Config (if .ejs exists)
+    // MVC TS
+    const swaggerMvcTs = path.join(targetDir, 'src', 'config', 'swagger.ts.ejs');
+    if (await fs.pathExists(swaggerMvcTs)) {
+        const content = ejs.render(await fs.readFile(swaggerMvcTs, 'utf-8'), { communication });
+        await fs.writeFile(path.join(targetDir, 'src', 'config', 'swagger.ts'), content);
+        await fs.remove(swaggerMvcTs);
+    }
+    // Clean Architecture TS
+    const swaggerCleanTs = path.join(targetDir, 'src', 'config', 'swagger.ts.ejs');
+    // Note: In Clean Arch, it might be in src/infrastructure/webserver or src/config depending on refactor.
+    // Based on previous moves, we saw it in src/config for TS.
+    if (await fs.pathExists(swaggerCleanTs)) {
+        const content = ejs.render(await fs.readFile(swaggerCleanTs, 'utf-8'), { communication });
+        await fs.writeFile(path.join(targetDir, 'src', 'config', 'swagger.ts'), content);
+        await fs.remove(swaggerCleanTs);
+    }
+
+    // 10. Copy Professional Config Files (Eslint, Prettier, Husky)
+    const eslintTemplate = await fs.readFile(path.join(templatesDir, 'common', '.eslintrc.json.ejs'), 'utf-8');
+    const eslintContent = ejs.render(eslintTemplate, { language });
+    await fs.writeFile(path.join(targetDir, '.eslintrc.json'), eslintContent);
+
+    await fs.copy(path.join(templatesDir, 'common', '.prettierrc'), path.join(targetDir, '.prettierrc'));
+    await fs.copy(path.join(templatesDir, 'common', '.lintstagedrc'), path.join(targetDir, '.lintstagedrc'));
+
+    // 10. Copy Test Config & Samples
+    const jestTemplate = await fs.readFile(path.join(templatesDir, 'common', 'jest.config.js.ejs'), 'utf-8');
+    const jestContent = ejs.render(jestTemplate, { language });
+    await fs.writeFile(path.join(targetDir, 'jest.config.js'), jestContent);
+
+    // Create tests directory
+    await fs.ensureDir(path.join(targetDir, 'tests'));
+    const healthTestTemplate = await fs.readFile(path.join(templatesDir, 'common', 'tests', 'health.test.ts.ejs'), 'utf-8');
+    // For now, the sample test is simple and doesn't explicitly depend on projectName, but we render it just in case we add more dynamic content later
+    const healthTestContent = ejs.render(healthTestTemplate, { language }); 
+    const testFileName = language === 'TypeScript' ? 'health.test.ts' : 'health.test.js';
+    await fs.writeFile(path.join(targetDir, 'tests', testFileName), healthTestContent);
+
+    // 11. Copy CI/CD Config (Optional)
+    if (includeCI) {
+        await fs.ensureDir(path.join(targetDir, '.github/workflows'));
+        await fs.copy(path.join(templatesDir, 'common', '.github/workflows/ci.yml'), path.join(targetDir, '.github/workflows/ci.yml'));
+    }
+
+    console.log(`
+      ====================================================
+             Node.js Project Created Successfully!
+      ====================================================
+
+      Project: ${projectName}
+      Architecture: ${architecture}
+      Language: ${language}
+      Database: ${database}
+      Communication: ${communication}
+
+      ----------------------------------------------------
+      ✨  High-Quality Standards Applied:
+      ----------------------------------------------------
+      ✅  Linting & Formatting: Eslint + Prettier configured
+      ✅  Git Hooks: Husky + Lint-Staged ready
+      ✅  Security: Helmet, CORS, Rate-Limiting added
+      ✅  Testing: Jest setup for Unit/Integration tests
+      ✅  Docker: Production-ready multi-stage build
+      ${includeCI ? '✅  CI/CD: GitHub Actions Workflow ready' : '❌  CI/CD: Skipped (User preferred)'}
+
+      ----------------------------------------------------
+      👉  Next Steps:
+      ----------------------------------------------------
+      1. cd ${projectName}
+      2. git init
+      3. npm install
+      4. npm run prepare      (To setup Husky hooks)
+      5. docker-compose up -d (To start DB/Infrastructure)
+      6. npm run dev          (To start development server)
+      7. npm test             (To run tests)
+    `);
+};

package/lib/prompts.js

@@ -0,0 +1,76 @@
+import inquirer from 'inquirer';
+
+const validateName = (name) => {
+    return /^[a-zA-Z0-9-_]+$/.test(name) ? true : 'Project name may only include letters, numbers, underscores and hashes.';
+};
+
+export const getProjectDetails = async (options = {}) => {
+    const questions = [
+        {
+            type: 'input',
+            name: 'projectName',
+            message: 'Project name:',
+            default: 'nodejs-service',
+            validate: validateName,
+            when: !options.projectName
+        },
+        {
+            type: 'list',
+            name: 'language',
+            message: 'Select Language:',
+            choices: ['JavaScript', 'TypeScript'],
+            default: 'TypeScript',
+            when: !options.language
+        },
+        {
+            type: 'list',
+            name: 'architecture',
+            message: 'Select Architecture:',
+            choices: ['MVC', 'Clean Architecture'],
+            default: 'MVC',
+            when: !options.architecture
+        },
+        {
+            type: 'list',
+            name: 'viewEngine',
+            message: 'Select View Engine:',
+            choices: ['None', 'EJS', 'Pug'],
+            when: (answers) => (options.architecture || answers.architecture) === 'MVC' && !options.viewEngine,
+            default: 'None'
+        },
+        {
+            type: 'list',
+            name: 'database',
+            message: 'Select Database:',
+            choices: ['MySQL', 'PostgreSQL'],
+            default: 'MySQL',
+            when: !options.database
+        },
+        {
+            type: 'input',
+            name: 'dbName',
+            message: 'Database Name:',
+            default: 'demo',
+            validate: validateName,
+            when: !options.dbName
+        },
+        {
+            type: 'list',
+            name: 'communication',
+            message: 'Microservices Communication:',
+            choices: ['REST APIs', 'Kafka'],
+            default: 'REST APIs',
+            when: !options.communication
+        },
+        {
+            type: 'confirm',
+            name: 'includeCI',
+            message: 'Include GitHub Actions CI Workflow? (Professional CI/CD pipeline included)',
+            default: false,
+            when: !options.includeCI
+        }
+    ];
+
+    const answers = await inquirer.prompt(questions);
+    return { ...options, ...answers };
+};

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "nodejs-quickstart-structure",
+  "version": "1.1.6",
+  "type": "module",
+  "description": "A CLI to scaffold Node.js microservices with MVC or Clean Architecture",
+  "main": "bin/index.js",
+  "bin": {
+    "nodejs-quickstart": "./bin/index.js"
+  },
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1",
+    "test:e2e": "npm run test:e2e:windows",
+    "test:e2e:windows": "node scripts/validate-windows.js",
+    "test:e2e:linux": "node scripts/validate-linux.js"
+  },
+  "keywords": [
+    "nodejs",
+    "cli",
+    "scaffold",
+    "mvc",
+    "clean-architecture"
+  ],
+  "author": "Pau Dang <paudang@example.com>",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/paudang/nodejs-quickstart-structure.git"
+  },
+  "bugs": {
+    "url": "https://github.com/paudang/nodejs-quickstart-structure/issues"
+  },
+  "homepage": "https://github.com/paudang/nodejs-quickstart-structure#readme",
+  "license": "ISC",
+  "dependencies": {
+    "chalk": "^5.4.1",
+    "commander": "^13.1.0",
+    "ejs": "^3.1.10",
+    "fs-extra": "^11.3.0",
+    "inquirer": "^12.4.1"
+  }
+}

package/templates/clean-architecture/js/src/domain/models/User.js

@@ -0,0 +1,9 @@
+class User {
+    constructor(id, name, email) {
+        this.id = id;
+        this.name = name;
+        this.email = email;
+    }
+}
+
+module.exports = User;

package/templates/clean-architecture/js/src/domain/repositories/UserRepository.js

@@ -0,0 +1,9 @@
+class UserRepository {
+    async save(user) {
+        // Database logic would go here
+        user.id = Math.floor(Math.random() * 1000);
+        return user;
+    }
+}
+
+module.exports = UserRepository;