nodejs-quickstart-structure 1.3.9 → 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

@@ -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') {

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.9",
+  "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

@@ -42,8 +42,13 @@ const syncDatabase = async () => {
     let retries = 30;
     while (retries) {
         try {
+            <% 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

@@ -4,15 +4,24 @@ 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/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).

package/templates/common/database/js/models/User.js.mongoose.ejs

@@ -0,0 +1,19 @@
+const mongoose = require('mongoose');
+
+const UserSchema = new mongoose.Schema({
+    name: {
+        type: String,
+        required: true
+    },
+    email: {
+        type: String,
+        required: true,
+        unique: true
+    },
+    createdAt: {
+        type: Date,
+        default: Date.now
+    }
+});
+
+module.exports = mongoose.model('User', UserSchema);

package/templates/common/database/js/mongoose.js.ejs

@@ -0,0 +1,32 @@
+const mongoose = require('mongoose');
+
+let logger;
+<% if (architecture === 'MVC') { %>
+logger = require('../utils/logger');
+<% } else { %>
+logger = require('../log/logger');
+<% } %>
+
+const connectDB = async () => {
+    const dbHost = process.env.DB_HOST || 'localhost';
+    const mongoURI = process.env.MONGO_URI || `mongodb://${dbHost}:27017/<%= dbName %>`;
+    
+    let retries = 5;
+    while (retries) {
+        try {
+            await mongoose.connect(mongoURI, {
+                useNewUrlParser: true,
+                useUnifiedTopology: true
+            });
+            logger.info('MongoDB Connected...');
+            break;
+        } catch (err) {
+            logger.error('MongoDB connection failed:', err);
+            retries -= 1;
+            logger.info(`Retries left: ${retries}. Waiting 5s...`);
+            await new Promise(res => setTimeout(res, 5000));
+        }
+    }
+};
+
+module.exports = connectDB; // Export function to call in index.js

package/templates/common/database/ts/models/User.ts.mongoose.ejs

@@ -0,0 +1,25 @@
+import mongoose, { Schema, Document } from 'mongoose';
+
+export interface IUser extends Document {
+    name: string;
+    email: string;
+    createdAt: Date;
+}
+
+const UserSchema: Schema = new Schema({
+    name: {
+        type: String,
+        required: true
+    },
+    email: {
+        type: String,
+        required: true,
+        unique: true
+    },
+    createdAt: {
+        type: Date,
+        default: Date.now
+    }
+});
+
+export default mongoose.model<IUser>('User', UserSchema);

package/templates/common/database/ts/mongoose.ts.ejs

@@ -0,0 +1,27 @@
+import mongoose from 'mongoose';
+<% if (architecture === 'MVC') { %>
+import logger from '@/utils/logger';
+<% } else { %>
+import logger from '@/infrastructure/log/logger';
+<% } %>
+
+const connectDB = async (): Promise<void> => {
+    const dbHost = process.env.DB_HOST || 'localhost';
+    const mongoURI = process.env.MONGO_URI || `mongodb://${dbHost}:27017/<%= dbName %>`;
+    
+    let retries = 5;
+    while (retries) {
+        try {
+            await mongoose.connect(mongoURI);
+            logger.info('MongoDB Connected...');
+            break;
+        } catch (err) {
+            logger.error('MongoDB connection failed:', err);
+            retries -= 1;
+            logger.info(`Retries left: ${retries}. Waiting 5s...`);
+            await new Promise(res => setTimeout(res, 5000));
+        }
+    }
+};
+
+export default connectDB;

package/templates/common/docker-compose.yml.ejs

@@ -18,7 +18,7 @@ services:
       - DB_PASSWORD=root
       - DB_NAME=<%= dbName %>
 <% } %><% if (database === 'PostgreSQL') { %>      - DB_USER=postgres
-      - DB_PASSWORD=postgres
+      - DB_PASSWORD=root
       - DB_NAME=<%= dbName %>
 <% } -%>
 <% } else { %>
@@ -29,30 +29,52 @@ services:
       - DB_PASSWORD=root
       - DB_NAME=<%= dbName %>
 <% } %><% if (database === 'PostgreSQL') { %>      - DB_USER=postgres
-      - DB_PASSWORD=postgres
+      - DB_PASSWORD=root
       - DB_NAME=<%= dbName %>
 <% } -%>
 <% } %>
   db:
 <% if (database === 'MySQL') { %>    image: mysql:8.0
-    command: --default-authentication-plugin=mysql_native_password
     restart: always
     environment:
       MYSQL_ROOT_PASSWORD: root
       MYSQL_DATABASE: <%= dbName %>
     ports:
       - "${DB_PORT:-3306}:3306"
-<% } %><% if (database === 'PostgreSQL') { %>    image: postgres:15
+    volumes:
+      - ./flyway/sql:/docker-entrypoint-initdb.d
+<% } else if (database === 'PostgreSQL') { %>    image: postgres:15
     restart: always
     environment:
       POSTGRES_USER: postgres
-      POSTGRES_PASSWORD: postgres
+      POSTGRES_PASSWORD: root
       POSTGRES_DB: <%= dbName %>
     ports:
       - "${DB_PORT:-5432}:5432"
-<% } %>    volumes:
-      - <%= database.toLowerCase() %>_data:/var/lib/<% if (database === 'MySQL') { %>mysql<% } else { %>postgresql/data<% } %>
+    volumes:
+      - ./flyway/sql:/docker-entrypoint-initdb.d
+<% } else if (database === 'MongoDB') { %>    image: mongo:latest
+    restart: always
+    environment:
+      MONGO_INITDB_DATABASE: <%= dbName %>
+    ports:
+      - "${DB_PORT:-27017}:27017"
+    volumes:
+      - mongodb_data:/data/db
 
+  mongo-migrate:
+    image: node:18-alpine
+    working_dir: /app
+    volumes:
+      - .:/app
+    command: sh -c "npm install migrate-mongo && npm run migrate"
+    environment:
+      - DB_HOST=db
+      - DB_NAME=<%= dbName %>
+    depends_on:
+      - db
+<% } %>
+<% if (database !== 'MongoDB') { %>
   flyway:
     image: flyway/flyway
     command: -connectRetries=60 migrate
@@ -64,9 +86,10 @@ services:
       FLYWAY_PASSWORD: root
 <% } %><% if (database === 'PostgreSQL') { %>      FLYWAY_URL: jdbc:postgresql://db:5432/<%= dbName %>
       FLYWAY_USER: postgres
-      FLYWAY_PASSWORD: postgres
+      FLYWAY_PASSWORD: root
 <% } %>    depends_on:
       - db
+<% } %>
 <% if (communication === 'Kafka') { %>  zookeeper:
     image: confluentinc/cp-zookeeper:7.4.0
     environment:

package/templates/common/migrate-mongo-config.js.ejs

@@ -0,0 +1,31 @@
+const config = {
+  mongodb: {
+    url: process.env.MONGO_URI || `mongodb://${process.env.DB_HOST || 'localhost'}:27017`,
+    databaseName: process.env.DB_NAME || '<%= dbName %>',
+
+    options: {
+      // useNewUrlParser: true, // No longer needed in Node.js driver v4+
+      // useUnifiedTopology: true, // No longer needed in Node.js driver v4+
+      // connectTimeoutMS: 3600000, // increase connection timeout to 1 hour
+      // socketTimeoutMS: 3600000, // increase socket timeout to 1 hour
+    }
+  },
+
+  // The migrations dir, can be an relative or absolute path. Only edit this when really necessary.
+  migrationsDir: "migrations",
+
+  // The mongodb collection where the applied changes are stored. Only edit this when really necessary.
+  changelogCollectionName: "changelog",
+
+  // The file extension to create migrations and search for in migration dir 
+  migrationFileExtension: ".js",
+
+  // Enable the algorithm to create a checksum of the file contents and use that in the comparison to determine
+  // if the file should be run.  Requires that scripts are coded to be run multiple times.
+  useFileHash: false,
+
+  // Don't change this, unless you know what you are doing
+  moduleSystem: 'commonjs',
+};
+
+module.exports = config;

package/templates/common/migrations/init.js.ejs

@@ -0,0 +1,23 @@
+module.exports = {
+  async up(db, client) {
+    const adminEmail = 'admin@example.com';
+    const existingAdmin = await db.collection('users').findOne({ email: adminEmail });
+
+    if (!existingAdmin) {
+      await db.collection('users').insertOne({
+        name: 'Admin User',
+        email: adminEmail,
+        createdAt: new Date(),
+        updatedAt: new Date()
+      });
+      console.log('Admin User seeded successfully');
+    } else {
+      console.log('Admin User already exists, skipping seed');
+    }
+  },
+
+  async down(db, client) {
+    // Optional: Undo the seed. Usually for seeds we might want to keep data, but strictly speaking 'down' should reverse 'up'.
+    // await db.collection('users').deleteOne({ email: 'admin@example.com' });
+  }
+};

package/templates/common/package.json.ejs

@@ -13,16 +13,21 @@
     "prepare": "husky install",
     "test": "jest",
     "test:watch": "jest --watch",
-    "test:coverage": "jest --coverage"
+    "test:coverage": "jest --coverage",
+    "migrate": "migrate-mongo up"
   },
   "dependencies": {
     "express": "^4.18.2",
     "dotenv": "^16.3.1",
 <% if (database === 'MySQL') { %>    "mysql2": "^3.6.5",
+    "sequelize": "^6.35.2",
 <% } -%>
 <% if (database === 'PostgreSQL') { %>    "pg": "^8.11.3",
-<% } -%>
     "sequelize": "^6.35.2",
+<% } -%>
+<% if (database === 'MongoDB') { %>    "mongoose": "^8.0.3",
+    "migrate-mongo": "^11.0.0",
+<% } -%>
 <% if (communication === 'Kafka') { %>    "kafkajs": "^2.2.4",
 <% } -%>
 <% if (viewEngine === 'EJS') { %>    "ejs": "^3.1.9",
@@ -35,8 +40,7 @@
     "express-rate-limit": "^7.1.5",
     "winston": "^3.11.0"<% if (communication === 'REST APIs') { %>,
     "swagger-ui-express": "^5.0.0",
-    "swagger-jsdoc": "^6.2.8"
-<% } %>
+    "swagger-jsdoc": "^6.2.8"<% } %>
   },
   "devDependencies": {
     "nodemon": "^3.0.2"<% if (language === 'TypeScript') { %>,

package/templates/mvc/js/src/controllers/userController.js.ejs

@@ -4,7 +4,9 @@ const logger = require('../utils/logger');
 
 const getUsers = async (req, res) => {
   try {
-    const users = await User.findAll();
+<% if (database === 'MongoDB') { %>    const users = await User.find();
+<% } else { %>    const users = await User.findAll();
+<% } -%>
     res.json(users);
   } catch (error) {
     logger.error('Error fetching users:', error);

package/templates/mvc/js/src/index.js.ejs

@@ -50,8 +50,13 @@ const syncDatabase = async () => {
     let retries = 30;
     while (retries) {
         try {
+            <% if (database === 'MongoDB') { %>
+            const connectDB = require('./config/database');
+            await connectDB();
+            <% } else { %>
             const sequelize = require('./config/database');
             await sequelize.sync();
+            <% } %>
             logger.info('Database synced');
             
             // Start Server after DB is ready

package/templates/mvc/ts/src/controllers/userController.ts.ejs

@@ -6,7 +6,9 @@ import logger from '@/utils/logger';
 export class UserController {
     async getUsers(req: Request, res: Response) {
         try {
-            const users = await User.findAll();
+<% if (database === 'MongoDB') { %>            const users = await User.find();
+<% } else { %>            const users = await User.findAll();
+<% } -%>
             res.json(users);
         } catch (error) {
             logger.error('Error fetching users:', error);

package/templates/mvc/ts/src/index.ts.ejs

@@ -60,10 +60,14 @@ const syncDatabase = async () => {
     let retries = 30;
     while (retries) {
         try {
+            <% if (database === 'MongoDB') { %>
+            const connectDB = (await import('@/config/database')).default;
+            await connectDB();
+            <% } else { %>
             const sequelize = (await import('@/config/database')).default;
             await sequelize.sync();
+            <% } %>
             logger.info('Database synced');
-            
             // Start Server after DB is ready
             app.listen(port, async () => {
               logger.info(`Server running on port ${port}`);