nodejs-quickstart-structure 1.4.3 → 1.6.1

package/CHANGELOG.md

@@ -0,0 +1,59 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [1.6.1] - 2026-02-11
+
+### Fixed
+- Included `CHANGELOG.md` in the published npm package so users can see version history.
+- Updated `README.md` with details on 64+ supported project combinations.
+
+## [1.6.0] - 2026-02-10
+
+### Refactored
+- Modularized `lib/generator.js` into distinct modules (`lib/modules/`) for better maintainability.
+- Extracted logic for project setup, config files, database, app setup, and Kafka.
+
+### Fixed
+- Resolved syntax error in `UserRepository.js` for Clean Architecture projects with 'None' database.
+- Increased health check timeout to 60s in validation scripts to prevent false positives in heavy environments (MySQL + Kafka).
+- Fixed missing `src/views` copy logic for MVC projects, resolving Docker build errors.
+- Corrected CLI argument parsing to properly exclude undefined flags (e.g., `--db-name`).
+- Removed obsolete `version: '3.8'` from `docker-compose.yml`.
+
+## [1.5.0] - 2026-02-10
+
+### Added
+- Implemented structured logging with `winston-daily-rotate-file` (14-day retention, daily rotation).
+- Added HTTP request logging using `morgan` middleware.
+
+### Fixed
+- Resolved `EACCES` permission errors for log directories in Docker.
+
+## [1.4.5] - 2026-02-10
+
+### Changed
+- Bumped version to 1.4.5.
+
+## [1.4.4] - 2026-02-10
+
+### Added
+- Created `CHANGELOG.md` to track release history.
+
+## [1.4.3] - 2026-02-10
+
+### Fixed
+- Updated CLI help text description to include MongoDB support.
+- Fixed unexpected character issues in npm scripts.
+- General bug fixes and improvements.
+
+## [1.0.0] - 2026-02-03
+
+### Added
+- Initial release of `nodejs-quickstart-structure`.
+- Scaffolding for MVC and Clean Architecture.
+- Support for Express.js.
+- Database integration (MongoDB, MySQL, PostgreSQL).

package/README.md

@@ -2,6 +2,8 @@
 
 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.
 
+[![Medium Article](https://img.shields.io/badge/Medium-Read%20Article-black?logo=medium)](https://medium.com/@paudang/nodejs-quickstart-generator-93c276d60e0b)
+
 ![Demo](docs/demo.gif)
 
 ## Features
@@ -26,6 +28,18 @@ We don't just generate boilerplate; we generate **production-ready** foundations
 -   **⚓ 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.
 
+## 🧩 64+ Project Combinations
+
+The CLI supports a massive number of configurations to fit your exact needs:
+
+-   **64 Core Combinations**:
+    -   **MVC Architecture**: 48 variants (Languages × View Engines × Databases × Communication Patterns)
+    -   **Clean Architecture**: 16 variants (Languages × Databases × Communication Patterns)
+-   **128 Total Scenarios**:
+    -   Every combination can be generated with or without **GitHub Actions CI/CD**, doubling the possibilities.
+
+For a detailed list of all supported cases, check out [docs/generateCase.md](docs/generateCase.md).
+
 ## Installation
 
 You can install the tool globally directly from npm:
@@ -34,24 +48,6 @@ You can install the tool globally directly from npm:
 npm install -g 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:

package/docs/generateCase.md

@@ -3,12 +3,12 @@
 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**: 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)
+- **MVC Architecture**: 48 Combinations
+  - (2 Languages × 3 View Engines × 4 Databases (incl. None) × 2 Patterns)
+- **Clean Architecture**: 16 Combinations
+  - (2 Languages × 1 View Engine (None) × 4 Databases (incl. None) × 2 Patterns)
 
-**Total Core Combinations: 48**
+**Total Core Combinations: 64**
 
 > **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.
 
@@ -54,13 +54,25 @@ This document lists the **48 possible project combinations** supported by the `n
 | 34 | TypeScript | MVC | Pug | PostgreSQL | Kafka |
 | 35 | TypeScript | MVC | Pug | MongoDB | REST APIs |
 | 36 | TypeScript | MVC | Pug | MongoDB | Kafka |
+| 37 | JavaScript | MVC | None | None | REST APIs |
+| 38 | JavaScript | MVC | None | None | Kafka |
+| 39 | JavaScript | MVC | EJS | None | REST APIs |
+| 40 | JavaScript | MVC | EJS | None | Kafka |
+| 41 | JavaScript | MVC | Pug | None | REST APIs |
+| 42 | JavaScript | MVC | Pug | None | Kafka |
+| 43 | TypeScript | MVC | None | None | REST APIs |
+| 44 | TypeScript | MVC | None | None | Kafka |
+| 45 | TypeScript | MVC | EJS | None | REST APIs |
+| 46 | TypeScript | MVC | EJS | None | Kafka |
+| 47 | TypeScript | MVC | Pug | None | REST APIs |
+| 48 | TypeScript | MVC | Pug | None | Kafka |
 
-## 2. Clean Architecture (12 Cases)
+## 2. Clean Architecture (16 Cases)
 *Note: Clean Architecture does not use server-side view engines (EJS/Pug).*
 
 | # | Language | Architecture | View Engine | Database | Communication |
 | :--- | :--- | :--- | :--- | :--- | :--- |
-| 37 | JavaScript | Clean Architecture | N/A | MySQL | REST APIs |
+| 1 | 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 |
@@ -72,3 +84,7 @@ This document lists the **48 possible project combinations** supported by the `n
 | 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 |
+| 49 | JavaScript | Clean Architecture | N/A | None | REST APIs |
+| 50 | JavaScript | Clean Architecture | N/A | None | Kafka |
+| 51 | TypeScript | Clean Architecture | N/A | None | REST APIs |
+| 52 | TypeScript | Clean Architecture | N/A | None | Kafka |

package/docs/generatorFlow.md

@@ -23,7 +23,7 @@ The generator prompts the user for the following configurations. These determine
 | **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** | `None`, `MySQL`, `PostgreSQL`, `MongoDB` | `None` | 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. |
@@ -42,6 +42,7 @@ The `generateProject` function in `lib/generator.js` executes the following step
 4.  **Render `docker-compose.yml`**:
     *   Uses `templates/common/docker-compose.yml.ejs`.
     *   Configures services (DB, Zookeeper/Kafka) based on selection.
+    *   **Note**: If Database is `None`, DB services are excluded.
 5.  **Render `README.md`**:
     *   Generates custom documentation specific to the selected stack.
 6.  **Render `src/index.{js|ts}`**:
@@ -65,11 +66,14 @@ The `generateProject` function in `lib/generator.js` executes the following step
 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.
+    *   **None**: Skips migration setup.
 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).
+    *   **None**: Skips this step.
 12. **Model Generation**:
     *   Renders `User` model (Mongoose schema or Sequelize/TypeORM model) in the appropriate directory.
+    *   **None**: Generates a simple Mock Entity/Model class with in-memory data for testing.
 13. **View Engine Setup (MVC)**:
     *   If selected, copies views (`views/ejs` or `views/pug`) and `public` assets.
 14. **Swagger Config**:

package/docs/releaseNoteRule.md

@@ -0,0 +1,42 @@
+# Release Process
+
+This document outlines the steps to release a new version of `nodejs-quickstart-structure`.
+
+## 1. Update Changelog
+
+Before releasing, update `CHANGELOG.md`:
+1.  Create a new header for the new version (e.g., `## [1.4.6] - 2026-02-12`).
+2.  Document new features, bug fixes, and changes.
+3.  Save the file.
+
+## 2. Commit Changelog
+
+Stage the `CHANGELOG.md` changes but **do not commit yet** if you want to include it in the version bump commit.
+```bash
+git add CHANGELOG.md
+```
+
+## 3. Bump Version & Tag
+
+Run the appropriate `npm version` command. This will assume you have a clean working directory (after staging `CHANGELOG.md`).
+```bash
+npm version patch   # For bug fixes (1.4.5 -> 1.4.6)
+npm version minor   # For new features (1.4.5 -> 1.5.0)
+npm version major   # For breaking changes (1.4.5 -> 2.0.0)
+```
+*Note: This command automatically updates `package.json`, creates a git commit with the new version number, and creates a git tag (e.g., `v1.4.6`).*
+
+## 4. Push Changes & Tags
+
+Push the new commit and the new tag to GitHub:
+```bash
+git push origin main
+git push origin --follow-tags
+```
+
+## 5. Publish to NPM (Optional)
+
+If you are publishing this package to the npm registry:
+```bash
+npm publish
+```

package/lib/generator.js

@@ -1,342 +1,67 @@
-import fs from 'fs-extra';
 import path from 'path';
-import ejs from 'ejs';
 import { fileURLToPath } from 'url';
+import { setupProjectDirectory, copyBaseStructure, copyCommonFiles } from './modules/project-setup.js';
+import { renderPackageJson, renderDockerCompose, renderReadme, renderDockerfile, renderProfessionalConfig, setupCiCd, renderTestSample } from './modules/config-files.js';
+import { renderIndexFile, renderDynamicComponents, renderSwaggerConfig, setupViews as setupSrcViews } from './modules/app-setup.js';
+import { setupDatabase } from './modules/database-setup.js';
+import { setupKafka, setupViews } from './modules/kafka-setup.js';
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 
 export const generateProject = async (config) => {
-    const { projectName, architecture, database, dbName, communication, language, viewEngine, ciProvider } = config;
+    const { projectName, architecture, language } = 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);
+    await setupProjectDirectory(targetDir, projectName);
 
-    // 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);
+    // 2. Select & Copy Base Structure
+    const { templatePath } = await copyBaseStructure(templatesDir, targetDir, architecture, language);
 
     // 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);
+    await renderPackageJson(templatesDir, targetDir, config);
 
     // 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,
-        ciProvider
-    });
-    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'));
-
-        // Render Kafka Service with dynamic logger path
-        const kafkaServiceFileName = `kafkaService.${langExt}`;
-        const kafkaServiceTemplate = path.join(targetDir, 'src', 'services', `${kafkaServiceFileName}.ejs`);
-        
-        if (await fs.pathExists(kafkaServiceTemplate)) {
-            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, configPath });
-            await fs.writeFile(path.join(targetDir, 'src', 'services', kafkaServiceFileName), content);
-            await fs.remove(kafkaServiceTemplate);
-        }
-
-        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
-    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 === '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;
-
-
-    // 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', 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', 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, 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);
-    }
+    await renderDockerCompose(templatesDir, targetDir, config);
 
-    // Render Models
-    const modelFileName = language === 'TypeScript' ? 'User.ts' : 'User.js';
-    const sourceModelName = database === 'MongoDB' ? `${modelFileName}.mongoose.ejs` : `${modelFileName}.ejs`;
-    const modelTemplateSource = path.join(templatesDir, 'common', 'database', langExt, 'models', sourceModelName);
-    let modelTarget;
+    // 5. Render README.md
+    await renderReadme(templatesDir, targetDir, config);
 
-    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);
-    }
+    // 6. Render index file (ts/js)
+    await renderIndexFile(templatePath, targetDir, config);
 
-    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);
-    }
+    // 7. Render Dynamic Components (Controllers/Repos/Server)
+    await renderDynamicComponents(templatePath, targetDir, 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'));
-        }
-    }
+    // 8. Kafka Setup
+    await setupKafka(templatesDir, targetDir, config);
 
-    // 9. Render Swagger Config (if .ejs exists)
-    // MVC TS
-    const swaggerMvcTs = path.join(targetDir, 'src', 'config', 'swagger.ts.ejs');
-    if (await fs.pathExists(swaggerMvcTs)) {
-        if (communication === 'REST APIs') {
-            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)) {
-        if (communication === 'REST APIs') {
-            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);
-    }
+    // 9. Common Files (.gitignore, Dockerfile, tsconfig)
+    await copyCommonFiles(templatesDir, targetDir, language);
+    await renderDockerfile(templatesDir, targetDir, config);
 
-    // 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);
+    // 10. Database Setup (Migrations, Config, Models)
+    // Note: logic for detailed view copying is also handled nicely if we ensure setupDatabase checks correctly,
+    // or we can move strict view logic to setupViews. 
+    // In strict refactor, database-setup handles the content that was in the DB block.
+    await setupDatabase(templatesDir, targetDir, config);
 
-    await fs.copy(path.join(templatesDir, 'common', '.prettierrc'), path.join(targetDir, '.prettierrc'));
-    await fs.copy(path.join(templatesDir, 'common', '.lintstagedrc'), path.join(targetDir, '.lintstagedrc'));
+    // 11. View Engine Public Assets (MVC)
+    await setupViews(templatesDir, targetDir, config);
+    // Copy src/views (MVC)
+    await setupSrcViews(templatesDir, targetDir, config);
 
-    // 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);
+    // 12. Swagger Config
+    await renderSwaggerConfig(targetDir, config);
 
-    // 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);
+    // 13. Professional Config & Tests
+    await renderProfessionalConfig(templatesDir, targetDir, language);
+    await renderTestSample(templatesDir, targetDir, language);
 
-    // 11. Copy CI/CD Config (Optional)
-    // 11. Copy CI/CD Config
-    if (ciProvider === 'GitHub Actions') {
-        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'));
-    } else if (ciProvider === 'Jenkins') {
-        const jenkinsTemplate = await fs.readFile(path.join(templatesDir, 'common', 'Jenkinsfile.ejs'), 'utf-8');
-        const jenkinsContent = ejs.render(jenkinsTemplate, {
-             projectName
-        });
-        await fs.writeFile(path.join(targetDir, 'Jenkinsfile'), jenkinsContent);
-    }
+    // 14. CI/CD
+    await setupCiCd(templatesDir, targetDir, config);
 
     console.log(`
       ====================================================
@@ -346,8 +71,8 @@ export const generateProject = async (config) => {
       Project: ${projectName}
       Architecture: ${architecture}
       Language: ${language}
-      Database: ${database}
-      Communication: ${communication}
+      Database: ${config.database}
+      Communication: ${config.communication}
 
       ----------------------------------------------------
       ✨  High-Quality Standards Applied:
@@ -357,7 +82,7 @@ export const generateProject = async (config) => {
       ✅  Security: Helmet, CORS, Rate-Limiting added
       ✅  Testing: Jest setup for Unit/Integration tests
       ✅  Docker: Production-ready multi-stage build
-      ${ciProvider !== 'None' ? `✅  CI/CD: ${ciProvider} Workflow ready` : '❌  CI/CD: Skipped (User preferred)'}
+      ${config.ciProvider !== 'None' ? `✅  CI/CD: ${config.ciProvider} Workflow ready` : '❌  CI/CD: Skipped (User preferred)'}
 
       ----------------------------------------------------
       👉  Next Steps: