nodejs-quickstart-structure 1.3.5 → 1.4.1

package/README.md

@@ -9,10 +9,10 @@ A powerful CLI tool to scaffold production-ready Node.js microservices with buil
 - **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**.
+- **Database Integration**: Pre-configured setup for **MySQL**, **PostgreSQL**, or **MongoDB**.
 - **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.
+- **Database Migrations/Schemas**: Integrated **Flyway** for SQL migrations or **Mongoose** schemas for MongoDB.
 - **Professional Standards**: Generated projects come with highly professional, industry-standard tooling.
 
 ## 🏆 Professional Standards (New)
@@ -67,7 +67,7 @@ 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`.
+4.  **Database**: `MySQL`, `PostgreSQL`, or `MongoDB`.
 5.  **Database Name**: The name of the initial database.
 6.  **Communication**: `REST APIs` (default) or `Kafka`.
 7.  **CI/CD**: `GitHub Actions`, `Jenkins`, or `None`.
@@ -77,7 +77,7 @@ The CLI will guide you through the following steps:
 The generated project will include:
 
 -   `src/`: Source code (controllers, routes, services/use-cases).
--   `flyway/sql/`: SQL migration scripts.
+-   `flyway/sql/`: SQL migration scripts (if SQL database selected).
 -   `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.

package/docs/generateCase.md

@@ -1,20 +1,20 @@
 # 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.
+This document lists the **48 possible project combinations** supported by the `nodejs-quickstart` CLI. These combinations cover all supported languages, architectures, databases (including MongoDB), 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)
+- **MVC Architecture**: 36 Combinations
+  - (2 Languages × 3 View Engines × 3 Databases × 2 Patterns)
+- **Clean Architecture**: 12 Combinations
+  - (2 Languages × 1 View Engine (None) × 3 Databases × 2 Patterns)
 
-**Total Core Combinations: 32**
+**Total Core Combinations: 48**
 
-> **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.
+> **Note on CI/CD**: Each of these 48 combinations can be generated with or without the **GitHub Actions CI Workflow** (`--include-ci`). This effectively creates **96 possible project states**. The validation script currently defaults to *including* CI to verify the full "Professional Standards" feature set.
 
 ---
 
-## 1. MVC Architecture (24 Cases)
+## 1. MVC Architecture (36 Cases)
 
 | # | Language | Architecture | View Engine | Database | Communication |
 | :--- | :--- | :--- | :--- | :--- | :--- |
@@ -22,37 +22,53 @@ This document lists the **32 possible project combinations** supported by the `n
 | 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)
+| 5 | JavaScript | MVC | None | MongoDB | REST APIs |
+| 6 | JavaScript | MVC | None | MongoDB | Kafka |
+| 7 | JavaScript | MVC | EJS | MySQL | REST APIs |
+| 8 | JavaScript | MVC | EJS | MySQL | Kafka |
+| 9 | JavaScript | MVC | EJS | PostgreSQL | REST APIs |
+| 10 | JavaScript | MVC | EJS | PostgreSQL | Kafka |
+| 11 | JavaScript | MVC | EJS | MongoDB | REST APIs |
+| 12 | JavaScript | MVC | EJS | MongoDB | Kafka |
+| 13 | JavaScript | MVC | Pug | MySQL | REST APIs |
+| 14 | JavaScript | MVC | Pug | MySQL | Kafka |
+| 15 | JavaScript | MVC | Pug | PostgreSQL | REST APIs |
+| 16 | JavaScript | MVC | Pug | PostgreSQL | Kafka |
+| 17 | JavaScript | MVC | Pug | MongoDB | REST APIs |
+| 18 | JavaScript | MVC | Pug | MongoDB | Kafka |
+| 19 | TypeScript | MVC | None | MySQL | REST APIs |
+| 20 | TypeScript | MVC | None | MySQL | Kafka |
+| 21 | TypeScript | MVC | None | PostgreSQL | REST APIs |
+| 22 | TypeScript | MVC | None | PostgreSQL | Kafka |
+| 23 | TypeScript | MVC | None | MongoDB | REST APIs |
+| 24 | TypeScript | MVC | None | MongoDB | Kafka |
+| 25 | TypeScript | MVC | EJS | MySQL | REST APIs |
+| 26 | TypeScript | MVC | EJS | MySQL | Kafka |
+| 27 | TypeScript | MVC | EJS | PostgreSQL | REST APIs |
+| 28 | TypeScript | MVC | EJS | PostgreSQL | Kafka |
+| 29 | TypeScript | MVC | EJS | MongoDB | REST APIs |
+| 30 | TypeScript | MVC | EJS | MongoDB | Kafka |
+| 31 | TypeScript | MVC | Pug | MySQL | REST APIs |
+| 32 | TypeScript | MVC | Pug | MySQL | Kafka |
+| 33 | TypeScript | MVC | Pug | PostgreSQL | REST APIs |
+| 34 | TypeScript | MVC | Pug | PostgreSQL | Kafka |
+| 35 | TypeScript | MVC | Pug | MongoDB | REST APIs |
+| 36 | TypeScript | MVC | Pug | MongoDB | Kafka |
+
+## 2. Clean Architecture (12 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 |
+| 37 | JavaScript | Clean Architecture | N/A | MySQL | REST APIs |
+| 38 | JavaScript | Clean Architecture | N/A | MySQL | Kafka |
+| 39 | JavaScript | Clean Architecture | N/A | PostgreSQL | REST APIs |
+| 40 | JavaScript | Clean Architecture | N/A | PostgreSQL | Kafka |
+| 41 | JavaScript | Clean Architecture | N/A | MongoDB | REST APIs |
+| 42 | JavaScript | Clean Architecture | N/A | MongoDB | Kafka |
+| 43 | TypeScript | Clean Architecture | N/A | MySQL | REST APIs |
+| 44 | TypeScript | Clean Architecture | N/A | MySQL | Kafka |
+| 45 | TypeScript | Clean Architecture | N/A | PostgreSQL | REST APIs |
+| 46 | TypeScript | Clean Architecture | N/A | PostgreSQL | Kafka |
+| 47 | TypeScript | Clean Architecture | N/A | MongoDB | REST APIs |
+| 48 | TypeScript | Clean Architecture | N/A | MongoDB | Kafka |

package/docs/generatorFlow.md

@@ -0,0 +1,171 @@
+# Generator Flow Documentation
+
+This document outlines the internal flow of the `nodejs-quickstart-structure` generator, including user options, the step-by-step generation process, and the resulting codebase structures.
+
+## 1. Technologies Used
+
+The `nodejs-quickstart-structure` CLI is built using the following key technologies:
+
+*   **[Node.js](https://nodejs.org/)**: The runtime environment.
+*   **[Commander.js](https://github.com/tj/commander.js)** (`^13.1.0`): For parsing command-line arguments and options.
+*   **[Inquirer.js](https://github.com/SBoudrias/Inquirer.js)** (`^12.4.1`): For interactive command-line user interface (prompts).
+*   **[Chalk](https://github.com/chalk/chalk)** (`^5.4.1`): For terminal string styling (color output).
+*   **[EJS (Embedded JavaScript templates)](https://github.com/mde/ejs)** (`^3.1.10`): For templating files (dynamic content generation).
+*   **[fs-extra](https://github.com/jprichardson/node-fs-extra)** (`^11.3.0`): For enhanced file system methods (copy, ensureDir, etc.).
+
+## 2. User Choices (Cases)
+
+The generator prompts the user for the following configurations. These determine the logic and structure of the generated project.
+
+| Option | Choices | Default | Description |
+| :--- | :--- | :--- | :--- |
+| **Project Name** | Input String | `nodejs-service` | Name of the project directory. |
+| **Language** | `JavaScript`, `TypeScript` | `TypeScript` | The programming language to use. |
+| **Architecture** | `MVC`, `Clean Architecture` | `MVC` | The architectural pattern. |
+| **View Engine** | `None`, `EJS`, `Pug` | `None` | (MVC Only) Template engine for server-side rendering. |
+| **Database** | `MySQL`, `PostgreSQL`, `MongoDB` | `MySQL` | The primary database. |
+| **Database Name** | Input String | `demo` | The name of the database to use/create. |
+| **Communication**| `REST APIs`, `Kafka` | `REST APIs` | The primary communication method. |
+| **CI/CD Provider**| `None`, `GitHub Actions`, `Jenkins`| `None` | Setup for Continuous Integration/Deployment. |
+
+## 3. Main Generator Flow
+
+The `generateProject` function in `lib/generator.js` executes the following steps:
+
+1.  **Create Project Directory**: Ensures the directory does not already exist and creates it.
+2.  **Select & Copy Base Structure**:
+    *   Based on **Architecture** (`mvc`/`clean-architecture`) and **Language** (`js`/`ts`), it selects the appropriate template from `templates/{arch}/{lang}`.
+    *   Copies the entire base template to the target directory.
+3.  **Render `package.json`**:
+    *   Uses `templates/common/package.json.ejs`.
+    *   Injects dependencies based on User Choices (DB drivers, view engines, etc.).
+4.  **Render `docker-compose.yml`**:
+    *   Uses `templates/common/docker-compose.yml.ejs`.
+    *   Configures services (DB, Zookeeper/Kafka) based on selection.
+5.  **Render `README.md`**:
+    *   Generates custom documentation specific to the selected stack.
+6.  **Render `src/index.{js|ts}`**:
+    *   Processes the entry point file to wire up the selected DB and Architecture.
+7.  **Dynamic Component Generation**:
+    *   **MVC**: Generates `userController` (imports specific DB service).
+    *   **Clean Architecture**: Generates `UserRepository` (infrastructure layer implementation).
+    *   **Clean Architecture (JS only)**: Generates `server.js` (webserver setup).
+8.  **Communication Setup (Kafka)**:
+    *   If **Kafka** is selected:
+        *   Copies Kafka client/service templates.
+        *   **Clean Architecture Restructuring**:
+            *   Moves service to `src/infrastructure/messaging`.
+            *   Moves config to `src/infrastructure/config`.
+            *   Removes REST-specific folders (`interfaces/routes`, `interfaces/controllers`).
+        *   **MVC Cleanup**:
+            *   If no View Engine is selected, removes `src/controllers` and `src/routes` (assumes pure worker).
+9.  **Common Configuration**:
+    *   Copies `.gitignore`, `.dockerignore`, `Dockerfile`.
+    *   Copies `tsconfig.json` (if TypeScript).
+10. **Database Setup**:
+    *   **MongoDB**: Sets up `migrate-mongo-config.js` and initial migration script.
+    *   **SQL (MySQL/Postgres)**: Sets up `flyway/sql` directory and copies initial SQL migration files.
+11. **Database Connection Config**:
+    *   Renders `database.{js|ts}` or `mongoose.{js|ts}` based on DB selection.
+    *   Places it in `src/config` (MVC) or `src/infrastructure/database` (Clean Arch).
+12. **Model Generation**:
+    *   Renders `User` model (Mongoose schema or Sequelize/TypeORM model) in the appropriate directory.
+13. **View Engine Setup (MVC)**:
+    *   If selected, copies views (`views/ejs` or `views/pug`) and `public` assets.
+14. **Swagger Config**:
+    *   If **REST APIs** is selected, generates Swagger configuration.
+15. **Code Quality Setup**:
+    *   Generates `.eslintrc.json`, `.prettierrc`, `.lintstagedrc`.
+16. **Test Setup**:
+    *   Generates `jest.config.js` and a sample `health.test.{js|ts}`.
+17. **CI/CD Setup**:
+    *   Copies GitHub Actions workflow or renders `Jenkinsfile` if selected.
+
+## 4. TypeScript vs JavaScript Generation Steps
+
+The logic handles language differences via conditional checks and file extensions (`langExt` variable).
+
+| Step | JavaScript (`js`) | TypeScript (`ts`) |
+| :--- | :--- | :--- |
+| **Base Template** | `templates/{arch}/js` | `templates/{arch}/ts` |
+| **Entry Point** | `src/index.js` | `src/index.ts` |
+| **tsconfig.json** | Skipped | Copied from `templates/common/tsconfig.json` |
+| **Linting** | Standard JS config | TS-specific parser and plugins in `.eslintrc` |
+| **Database Config** | `mongoose.js` / `database.js` | `mongoose.ts` / `database.ts` |
+| **Models/Controllers**| `.js` extension | `.ts` extension |
+| **Build Step** | No compilation needed | Compilation typically handled by `tsc` or `ts-node` in dev |
+
+## 5. Possible Codebase Structures
+
+The final structure depends heavily on **Architecture**, **Communication**, and **View Engine**.
+
+### Case A: MVC (REST API)
+Standard architecture for web APIs.
+
+```text
+project-name/
+├── src/
+│   ├── config/         # Database, Swagger, etc.
+│   ├── controllers/    # Request handlers
+│   ├── models/         # Database models
+│   ├── routes/         # Express routes
+│   └── index.js|ts     # Entry point
+├── tests/              # Jest tests
+├── package.json
+├── Dockerfile
+└── docker-compose.yml
+```
+
+### Case B: MVC (Web App with Views)
+Includes frontend views rendered on the server.
+
+```text
+project-name/
+├── public/             # CSS, JS, Images
+├── src/
+│   ├── config/
+│   ├── controllers/
+│   ├── models/
+│   ├── routes/
+│   ├── views/          # EJS or Pug templates
+│   └── index.js|ts
+└── ...
+```
+
+### Case C: Clean Architecture (REST API)
+Separation of concerns with Domain, Use Cases, and Infrastructure.
+
+```text
+project-name/
+├── src/
+│   ├── domain/                 # Entities (Enterprise rules)
+│   ├── use_cases/              # Application business rules
+│   ├── interfaces/             # Adapters
+│   │   ├── controllers/
+│   │   └── routes/
+│   ├── infrastructure/         # Frameworks & Drivers
+│   │   ├── config/             # Environment config
+│   │   ├── database/           # DB connection & models
+│   │   ├── repositories/       # Data access implementation
+│   │   └── webserver/          # Express server setup
+│   └── index.js|ts
+└── ...
+```
+
+### Case D: Clean Architecture (Kafka Worker)
+Optimized for event-driven microservices. HTTP routes are removed.
+
+```text
+project-name/
+├── src/
+│   ├── domain/
+│   ├── use_cases/
+│   ├── infrastructure/
+│   │   ├── config/             # Includes Kafka config
+│   │   ├── database/
+│   │   ├── messaging/          # Kafka Client/Consumer
+│   │   ├── repositories/
+│   │   └── webserver/          # (Optional/Minimal)
+│   └── index.js|ts
+└── ...
+```

package/lib/generator.js

@@ -131,15 +131,15 @@ export const generateProject = async (config) => {
         const kafkaServiceTemplate = path.join(targetDir, 'src', 'services', `${kafkaServiceFileName}.ejs`);
         
         if (await fs.pathExists(kafkaServiceTemplate)) {
-            const loggerPath = architecture === 'Clean Architecture' ? '../log/logger' : '../utils/logger';
-            // Note: For MVC, it's relative to src/services (../utils/logger). Wait, ../utils/logger means src/utils/logger.
-            // src/services/kafka.ts -> ../utils/logger -> src/utils/logger. Correct.
-            // But wait, generated code for MVC usually puts it in src/services.
-            // Let's re-verify MVC structure for logger.
-            // In MVC, logger is usually in src/utils/logger.ts?
-            // Let's check where logger is copied for MVC.
+            let loggerPath = architecture === 'Clean Architecture' ? '../log/logger' : '../utils/logger';
+            let configPath = '../config/kafka';
+
+            if (language === 'TypeScript') {
+                loggerPath = architecture === 'Clean Architecture' ? '@/infrastructure/log/logger' : '@/utils/logger';
+                configPath = architecture === 'Clean Architecture' ? '@/infrastructure/config/kafka' : '@/config/kafka';
+            }
             
-            const content = ejs.render(await fs.readFile(kafkaServiceTemplate, 'utf-8'), { loggerPath });
+            const content = ejs.render(await fs.readFile(kafkaServiceTemplate, 'utf-8'), { loggerPath, configPath });
             await fs.writeFile(path.join(targetDir, 'src', 'services', kafkaServiceFileName), content);
             await fs.remove(kafkaServiceTemplate);
         }
@@ -198,14 +198,33 @@ export const generateProject = async (config) => {
         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'));
+    // 6. Database Migrations
+    if (database === 'MongoDB') {
+        // Copy migrate-mongo config
+        const migrateConfigTemplate = await fs.readFile(path.join(templatesDir, 'common', 'migrate-mongo-config.js.ejs'), 'utf-8');
+        const migrateConfigContent = ejs.render(migrateConfigTemplate, { dbName });
+        await fs.writeFile(path.join(targetDir, 'migrate-mongo-config.js'), migrateConfigContent);
+
+        // Setup migrations directory
+        await fs.ensureDir(path.join(targetDir, 'migrations'));
+        
+        // Create initial migration file with timestamp
+        const timestamp = new Date().toISOString().replace(/[-T:.Z]/g, '').slice(0, 14); // YYYYMMDDHHMMSS
+        const migrationTemplate = await fs.readFile(path.join(templatesDir, 'common', 'migrations', 'init.js.ejs'), 'utf-8');
+        await fs.writeFile(path.join(targetDir, 'migrations', `${timestamp}-initial-setup.js`), migrationTemplate);
+
+    } else {
+        // Flyway for SQL
+        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`);
+    const dbConfigFileName = language === 'TypeScript' ? (database === 'MongoDB' ? 'mongoose.ts' : 'database.ts') : (database === 'MongoDB' ? 'mongoose.js' : 'database.js');
+    const dbConfigTemplateSource = database === 'MongoDB'
+        ? path.join(templatesDir, 'common', 'database', langExt, `${dbConfigFileName}.ejs`)
+        : path.join(templatesDir, 'common', 'database', langExt, `${dbConfigFileName}.ejs`);
     
     let dbConfigTarget;
 
@@ -217,22 +236,27 @@ export const generateProject = async (config) => {
             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);
+        dbConfigTarget = path.join(targetDir, 'src/config', database === 'MongoDB' ? (language === 'TypeScript' ? 'database.ts' : 'database.js') : dbConfigFileName);
     } else {
         // Clean Architecture
         await fs.ensureDir(path.join(targetDir, 'src/infrastructure/database'));
-        dbConfigTarget = path.join(targetDir, 'src/infrastructure/database', dbConfigFileName);
+        dbConfigTarget = path.join(targetDir, 'src/infrastructure/database', language === 'TypeScript' ? 'database.ts' : 'database.js');
     }
 
     if (await fs.pathExists(dbConfigTemplateSource)) {
         const dbTemplate = await fs.readFile(dbConfigTemplateSource, 'utf-8');
-        const dbContent = ejs.render(dbTemplate, { database, dbName });
+        const dbContent = ejs.render(dbTemplate, { database, dbName, architecture });
+        // Ensure consistent naming for imports in other files
+        // For MVC, we might want to rename mongoose.js to database.js to minimize refactoring in index.js?
+        // Actually, let's keep it consistent. If MVC, we typically call it 'database.js' in require. 
+        // So we should save it as 'database.js' even if source is mongoose.js.ejs
         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`);
+    const sourceModelName = database === 'MongoDB' ? `${modelFileName}.mongoose.ejs` : `${modelFileName}.ejs`;
+    const modelTemplateSource = path.join(templatesDir, 'common', 'database', langExt, 'models', sourceModelName);
     let modelTarget;
 
     if (architecture === 'MVC') {
@@ -252,6 +276,10 @@ export const generateProject = async (config) => {
 
     // 8. View Engine (MVC)
     if (architecture === 'MVC' && viewEngine && viewEngine !== 'None') {
+        const publicDir = path.join(templatesDir, 'common', 'public');
+        if (await fs.pathExists(publicDir)) {
+            await fs.copy(publicDir, path.join(targetDir, 'public'));
+        }
     }
 
     // 9. Render Swagger Config (if .ejs exists)

package/lib/prompts.js

@@ -42,7 +42,7 @@ export const getProjectDetails = async (options = {}) => {
             type: 'list',
             name: 'database',
             message: 'Select Database:',
-            choices: ['MySQL', 'PostgreSQL'],
+            choices: ['MySQL', 'PostgreSQL', 'MongoDB'],
             default: 'MySQL',
             when: !options.database
         },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nodejs-quickstart-structure",
-  "version": "1.3.5",
+  "version": "1.4.1",
   "type": "module",
   "description": "A CLI to scaffold Node.js microservices with MVC or Clean Architecture",
   "main": "bin/index.js",
@@ -11,7 +11,8 @@
     "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"
+    "test:e2e:linux": "node scripts/validate-linux.js",
+    "test:verify:mongo": "node scripts/verify-migration.js"
   },
   "keywords": [
     "nodejs",
@@ -20,7 +21,7 @@
     "mvc",
     "clean-architecture"
   ],
-  "author": "Pau Dang <phucdangb1400718@gmail.com>",
+  "author": "Pau Dang <[EMAIL_ADDRESS]>",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/paudang/nodejs-quickstart-structure.git"

package/templates/clean-architecture/js/src/index.js.ejs

@@ -11,8 +11,13 @@ const syncDatabase = async () => {
     let retries = 30;
     while (retries) {
         try {
+            <% if (database === 'MongoDB') { %>
+            const connectDB = require('./infrastructure/database/database');
+            await connectDB();
+            <% } else { %>
             const sequelize = require('./infrastructure/database/database');
             await sequelize.sync();
+            <% } %>
             logger.info('Database synced');
             // Start the web server after DB sync
             startServer(PORT);

package/templates/clean-architecture/js/src/infrastructure/repositories/UserRepository.js.ejs

@@ -3,16 +3,25 @@ const UserModel = require('../database/models/User');
 class UserRepository {
   async save(user) {
     const newUser = await UserModel.create({ name: user.name, email: user.email });
-    return { ...user, id: newUser.id };
+<% if (database === 'MongoDB') { %>    return { ...user, id: newUser._id.toString() };
+<% } else { %>    return { ...user, id: newUser.id };
+<% } -%>
   }
 
   async getUsers() {
-    const users = await UserModel.findAll();
+<% if (database === 'MongoDB') { %>    const users = await UserModel.find();
+    return users.map(user => ({
+        id: user._id.toString(),
+        name: user.name,
+        email: user.email
+    }));
+<% } else { %>    const users = await UserModel.findAll();
     return users.map(user => ({
         id: user.id,
         name: user.name,
         email: user.email
     }));
+<% } -%>
   }
 }
 

package/templates/clean-architecture/ts/src/domain/user.ts

@@ -1,6 +1,6 @@
 export class User {
     constructor(
-        public id: number | null,
+        public id: number | string | null,
         public name: string,
         public email: string
     ) { }

package/templates/clean-architecture/ts/src/index.ts.ejs

@@ -4,12 +4,12 @@ import helmet from 'helmet';
 import hpp from 'hpp';
 import rateLimit from 'express-rate-limit';
 import dotenv from 'dotenv';
-import logger from './infrastructure/log/logger';
-<% if (communication === 'REST APIs') { %>import userRoutes from './interfaces/routes/userRoutes';<% } -%>
+import logger from '@/infrastructure/log/logger';
+<% if (communication === 'REST APIs') { %>import userRoutes from '@/interfaces/routes/userRoutes';<% } -%>
 <% if (communication === 'REST APIs') { -%>
 import swaggerUi from 'swagger-ui-express';
-import swaggerSpecs from './config/swagger';<% } -%>
-<% if (communication === 'Kafka') { %>import { KafkaService } from './infrastructure/messaging/kafkaClient';<% } -%>
+import swaggerSpecs from '@/config/swagger';<% } -%>
+<% if (communication === 'Kafka') { %>import { KafkaService } from '@/infrastructure/messaging/kafkaClient';<% } -%>
 
 dotenv.config();
 
@@ -42,8 +42,13 @@ const syncDatabase = async () => {
     let retries = 30;
     while (retries) {
         try {
-            const sequelize = (await import('./infrastructure/database/database')).default;
+            <% if (database === 'MongoDB') { %>
+            const connectDB = (await import('@/infrastructure/database/database')).default;
+            await connectDB();
+            <% } else { %>
+            const sequelize = (await import('@/infrastructure/database/database')).default;
             await sequelize.sync();
+            <% } %>
             logger.info('Database synced');
             
             app.listen(port, async () => {

package/templates/clean-architecture/ts/src/infrastructure/repositories/userRepository.ts.ejs

@@ -1,18 +1,27 @@
-import { User as UserEntity } from '../../domain/user';
-import UserModel from '../database/models/User';
+import { User as UserEntity } from '@/domain/user';
+import UserModel from '@/infrastructure/database/models/User';
 
 export class UserRepository {
     async save(user: UserEntity): Promise<UserEntity> {
         const newUser = await UserModel.create({ name: user.name, email: user.email });
-        return { id: newUser.id, name: newUser.name, email: newUser.email };
+<% if (database === 'MongoDB') { %>        return { id: newUser._id.toString(), name: newUser.name, email: newUser.email };
+<% } else { %>        return { id: newUser.id, name: newUser.name, email: newUser.email };
+<% } -%>
     }
 
     async getUsers(): Promise<UserEntity[]> {
-        const users = await UserModel.findAll();
+<% if (database === 'MongoDB') { %>        const users = await UserModel.find();
+        return users.map(user => ({
+            id: user._id.toString(),
+            name: user.name,
+            email: user.email
+        }));
+<% } else { %>        const users = await UserModel.findAll();
         return users.map(user => ({
             id: user.id,
             name: user.name,
             email: user.email
         }));
+<% } -%>
     }
 }

package/templates/clean-architecture/ts/src/interfaces/controllers/userController.ts

@@ -1,9 +1,9 @@
 import { Request, Response } from 'express';
-import { UserRepository } from '../../infrastructure/repositories/UserRepository';
-import CreateUser from '../../usecases/createUser';
-import GetAllUsers from '../../usecases/getAllUsers';
-import { HTTP_STATUS } from '../../utils/httpCodes';
-import logger from '../../infrastructure/log/logger';
+import { UserRepository } from '@/infrastructure/repositories/UserRepository';
+import CreateUser from '@/usecases/createUser';
+import GetAllUsers from '@/usecases/getAllUsers';
+import { HTTP_STATUS } from '@/utils/httpCodes';
+import logger from '@/infrastructure/log/logger';
 
 export class UserController {
     private createUserUseCase: CreateUser;

package/templates/clean-architecture/ts/src/interfaces/routes/userRoutes.ts

@@ -1,5 +1,5 @@
 import { Router, Request, Response } from 'express';
-import { UserController } from '../controllers/userController';
+import { UserController } from '@/interfaces/controllers/userController';
 
 const router = Router();
 const userController = new UserController();

package/templates/clean-architecture/ts/src/usecases/createUser.ts

@@ -1,6 +1,6 @@
-import { User } from '../domain/user';
+import { User } from '@/domain/user';
 
-import { UserRepository } from '../infrastructure/repositories/UserRepository';
+import { UserRepository } from '@/infrastructure/repositories/UserRepository';
 
 export default class CreateUser {
     constructor(private userRepository: UserRepository) {}

package/templates/clean-architecture/ts/src/usecases/getAllUsers.ts

@@ -1,4 +1,4 @@
-import { UserRepository } from '../infrastructure/repositories/UserRepository';
+import { UserRepository } from '@/infrastructure/repositories/UserRepository';
 
 export default class GetAllUsers {
     constructor(private userRepository: UserRepository) {}

package/templates/common/Dockerfile

@@ -40,6 +40,7 @@ COPY --from=builder /app/src ./src
 # Copy other necessary files (like views if MVC)
 <% if (viewEngine && viewEngine !== 'None') { %>
 COPY --from=builder /app/src/views ./dist/views
+<% if (viewEngine && viewEngine !== 'None') { %>COPY --from=builder /app/public ./public<% } %>
 <% } %>
 
 EXPOSE 3000

package/templates/common/README.md.ejs

@@ -10,7 +10,7 @@ This project comes pre-configured with industry-standard tooling for **Code Qual
 ## 🚀 Key Features
 
 -   **Architecture**: <%= architecture %> (<% if (architecture === 'Clean Architecture') { %>Domain, UseCases, Infrastructure<% } else { %>MVC Pattern<% } %>).
--   **Database**: <%= database %> with **Flyway** migrations.
+-   **Database**: <%= database %> <% if (database !== 'MongoDB') { %>with **Flyway** migrations<% } else { %>with **Mongoose** schemas<% } %>.
 -   **Security**: Helmet, CORS, Rate Limiting, HPP.
 -   **Quality**: Eslint, Prettier, Husky, Lint-Staged.
 -   **Testing**: Jest (Unit & Integration).