nodejs-quickstart-structure 1.12.0 → 1.14.0

package/CHANGELOG.md

@@ -5,6 +5,29 @@ 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.14.0] - 2026-03-09
+### Added
+- **Unit test:**
+  - Unit Testing Framework: Integrated Jest and ts-jest as the core testing suite.
+
+  - Scaffolding Logic: Automatically generates .spec.ts files in the tests/ directory mirroring the src/ structure during project initialization.
+
+  - Quality Gates: Implemented a mandatory Coverage Threshold (>=70%) for lines and functions to ensure long-term maintainability.
+
+  - Mocking Standards: Included pre-configured mocks for Mongoose (database pings) and Express request/response objects.
+
+  - NPM Scripts: Added npm test, npm run test:watch, and npm run test:coverage for seamless developer workflow.
+
+## [1.13.0] - 2026-03-05
+### Added
+- **Enhanced Health Check System:**
+  - Standardized health logic for both MVC and Clean Architecture.
+  - Deep verification: Automatically pings the selected database (MySQL, PostgreSQL, MongoDB) during health checks and returns a `DOWN` status with 500 code if the connection is lost.
+  - Structured response including `uptime`, `memoryUsage`, `database` connectivity status, and `timestamp`.
+- **Improved Graceful Shutdown:**
+  - Standardized signal handling (`SIGINT`, `SIGTERM`) across all architecture types to ensure clean disposal of database and caching resources.
+  - Integrated proper shutdown sequences for Redis, MySQL, PostgreSQL, and MongoDB.
+
 ## [1.12.0] - 2026-03-04
 ### Added
 - **Zod Environment Validation:** Replaced manual `dotenv` process calls in server entry points with a centralized schema parser.
@@ -16,13 +39,13 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [1.11.1] - 2026-03-03
 ### Fixed
-- Fixed relative import paths in Clean Architecture JS `error.middleware.js` — changed to correct 3-level relative paths (`../../../`).
+- Fixed relative import paths in Clean Architecture JS `errorMiddleware.js` — changed to correct 3-level relative paths (`../../../`).
 
 ## [1.11.0] - 2026-03-02
 ### Added
 - **Centralized Error Handling Mechanism:** All generated projects now include a standardized, predictable error response structure for both REST APIs and GraphQL communication types.
   - New `src/errors/` directory with custom error classes: `ApiError`, `NotFoundError`, `BadRequestError`.
-  - New `error.middleware.{ts|js}` global error handler placed at the end of the Express middleware chain in `src/utils/` (MVC) and `src/utils/` + `src/infrastructure/webserver/middlewares/` (Clean Architecture).
+  - New `error.middleware.{ts|js}` global error handler placed at the end of the Express middleware chain in `src/utils/` (MVC) and `src/utils/` + `src/infrastructure/webserver/middleware/` (Clean Architecture).
   - Integrates `winston` logger to automatically log 500-level errors to persistent log files.
   - All controllers updated to pass errors via `next(error)` instead of manually sending responses.
   - **GraphQL:** Apollo Server `formatError` hook configured with `unwrapResolverError` to intercept resolver errors and map `ApiError` instances to structured GraphQL extension codes.
@@ -32,7 +55,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ### Fixed
 - Fixed `swagger.js` / `swagger.yml` being incorrectly generated for non-REST API configurations (GraphQL, Kafka). Converted static `swagger.js` to `swagger.js.ejs` in MVC JS and Clean Architecture JS templates so `renderSwaggerConfig` can conditionally control its generation.
 - Fixed `userRoutes.ts` in Clean Architecture TypeScript template not passing `NextFunction` to controller methods, causing `TypeScript TS2554: Expected 3 arguments` compile errors during Docker builds.
-- Fixed incorrect relative import paths (`../../../../`) in Clean Architecture JS `error.middleware.js` — changed to correct 3-level relative paths (`../../../`).
+- Fixed incorrect relative import paths (`../../../../`) in Clean Architecture JS `errorMiddleware.js` — changed to correct 3-level relative paths (`../../../`).
 - Fixed `HTTP_STATUS` being imported without destructuring from `httpCodes.js` (which uses a plain `module.exports = HTTP_STATUS` default export), causing `Cannot read properties of undefined` runtime errors.
 - Fixed `renderErrorMiddleware` in `app-setup.js` deleting from the **template source directory** instead of the generated project's target directory. This caused error middleware templates to disappear from disk after the first test run, breaking all subsequent generations.
 

package/README.md

@@ -31,13 +31,14 @@ We don't just generate boilerplate; we generate **production-ready** foundations
 -   **🔍 Code Quality**: Pre-configured `Eslint` and `Prettier` for consistent coding standards.
 -   **🛡️ Security**: Built-in `Helmet`, `HPP`, `CORS`, and Rate-Limiting middleware.
 -   **🚨 Error Handling**: Centralized global error middleware with custom error classes and structured JSON responses. GraphQL uses Apollo's `formatError` hook; REST uses Express error middleware.
--   **🧪 Testing Strategy**: Integrated `Jest` and `Supertest` setup for Unit and Integration testing.
+-   **🧪 Testing Excellence**: Integrated `Jest` and `Supertest`. Every generated project maintains **>70% Unit Test coverage** for controllers, services, and resolvers out of the box.
 -   **🔄 CI/CD Integration**: Pre-configured workflows for **GitHub Actions**, **Jenkins**, and **GitLab CI**.
 -   **⚓ Git Hooks**: `Husky` and `Lint-Staged` to ensure no bad code is ever committed.
+-   **🤝 Reliability**: Advanced Health Checks (`/health`) with deep database pings and Graceful Shutdown workflows for zero-downtime rollouts.
 -   **🐳 DevOps**: Highly optimized **Multi-Stage Dockerfile** for small, secure production images.
 -   **🚀 Deployment**: Ship confidently with an integrated **PM2 Ecosystem Configuration** for zero-downtime reloads and robust process management.
 
-## 🧩 240+ Project Combinations
+## 🧩 480+ Project Combinations
 
 The CLI supports a massive number of configurations to fit your exact needs:
 
@@ -45,7 +46,8 @@ The CLI supports a massive number of configurations to fit your exact needs:
     -   **MVC Architecture**: 180 variants (Languages × View Engines × Databases × Communication Patterns × Caching)
     -   **Clean Architecture**: 60 variants (Languages × Databases × Communication Patterns × Caching)
 -   **480 Total Scenarios**:
-    -   Every combination can be generated with or without **GitHub Actions CI/CD**, doubling the possibilities.
+    -   Every combination can be generated with or without (**GitHub Actions CI/CD** / **Jenkins** or **GitLab CI**), tripling the possibilities.
+    -   Every single one of these 480 scenarios is verified to be compatible with our 70% Coverage Threshold policy.
 
 For a detailed list of all supported cases, check out [docs/generateCase.md](docs/generateCase.md).
 

package/lib/generator.js

@@ -2,7 +2,7 @@ import path from 'path';
 import { fileURLToPath } from 'url';
 import { setupProjectDirectory, copyBaseStructure, copyCommonFiles } from './modules/project-setup.js';
 import { renderPackageJson, renderDockerCompose, renderReadme, renderDockerfile, renderProfessionalConfig, setupCiCd, renderTestSample, renderEnvExample, renderPm2Config } from './modules/config-files.js';
-import { renderIndexFile, renderEnvConfig, renderErrorMiddleware, renderDynamicComponents, renderSwaggerConfig, setupViews as setupSrcViews } from './modules/app-setup.js';
+import { renderIndexFile, renderEnvConfig, renderErrorMiddleware, renderDynamicComponents, renderSwaggerConfig, setupViews as setupSrcViews, processAllTests } from './modules/app-setup.js';
 import { setupDatabase } from './modules/database-setup.js';
 import { setupKafka, setupViews } from './modules/kafka-setup.js';
 import { setupCaching } from './modules/caching-setup.js';
@@ -11,6 +11,17 @@ const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 
 export const generateProject = async (config) => {
+    // 0. Normalize configuration with defaults
+    config = {
+        viewEngine: 'None',
+        caching: 'None',
+        dbName: 'demo',
+        ciProvider: 'None',
+        communication: 'REST APIs',
+        database: 'None',
+        ...config
+    };
+
     const { projectName, architecture, language } = config;
     const targetDir = path.resolve(process.cwd(), projectName);
     const templatesDir = path.join(__dirname, '../templates');
@@ -67,8 +78,8 @@ export const generateProject = async (config) => {
     await renderSwaggerConfig(templatesDir, targetDir, config);
 
     // 13. Professional Config & Tests
-    await renderProfessionalConfig(templatesDir, targetDir, language);
-    await renderTestSample(templatesDir, targetDir, language);
+    await renderProfessionalConfig(templatesDir, targetDir, config);
+    await renderTestSample(templatesDir, targetDir, config);
 
     // 14. CI/CD
     await setupCiCd(templatesDir, targetDir, config);
@@ -79,6 +90,9 @@ export const generateProject = async (config) => {
     // 16. PM2 Configuration
     await renderPm2Config(templatesDir, targetDir, config);
 
+    // 17. Process All Tests
+    await processAllTests(targetDir, config);
+
     console.log(`
       ====================================================
              Node.js Project Created Successfully!

package/lib/modules/app-setup.js

@@ -3,20 +3,14 @@ import path from 'path';
 import ejs from 'ejs';
 
 export const renderIndexFile = async (templatePath, targetDir, config) => {
-    const { communication, viewEngine, database, architecture, projectName, language } = config;
+    const { communication, viewEngine, database, architecture, projectName, language, caching } = config;
     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
-        });
+        const indexContent = ejs.render(indexTemplate, { ...config });
         await fs.writeFile(indexPath, indexContent);
         await fs.remove(path.join(targetDir, 'src', `${indexFileName}.ejs`));
     }
@@ -25,7 +19,7 @@ export const renderIndexFile = async (templatePath, targetDir, config) => {
 export const renderEnvConfig = async (templatePath, targetDir, config) => {
     const { language, architecture, database, caching, communication } = config;
     const envExt = language === 'TypeScript' ? 'ts' : 'js';
-    
+
     let configDir = path.join(targetDir, 'src', 'config');
     if (architecture === 'Clean Architecture' && language === 'JavaScript') {
         configDir = path.join(targetDir, 'src', 'infrastructure', 'config');
@@ -33,14 +27,10 @@ export const renderEnvConfig = async (templatePath, targetDir, config) => {
 
     const envTemplatePath = path.join(configDir, `env.${envExt}.ejs`);
     const envDestPath = path.join(configDir, `env.${envExt}`);
-    
+
     if (await fs.pathExists(envTemplatePath)) {
         const envTemplate = await fs.readFile(envTemplatePath, 'utf-8');
-        const envContent = ejs.render(envTemplate, {
-            database,
-            caching,
-            communication
-        });
+        const envContent = ejs.render(envTemplate, { ...config });
         await fs.writeFile(envDestPath, envContent);
         await fs.remove(envTemplatePath);
     }
@@ -48,7 +38,7 @@ export const renderEnvConfig = async (templatePath, targetDir, config) => {
 
 export const renderErrorMiddleware = async (templatePath, targetDir, config) => {
     const { language, architecture } = config;
-    const errName = language === 'TypeScript' ? 'error.middleware.ts' : 'error.middleware.js';
+    const errName = language === 'TypeScript' ? 'errorMiddleware.ts' : 'errorMiddleware.js';
     const errTemplateName = `${errName}.ejs`;
 
     if (architecture === 'MVC') {
@@ -68,8 +58,8 @@ export const renderErrorMiddleware = async (templatePath, targetDir, config) =>
             await fs.writeFile(utilsDest, await fs.readFile(utilsEjsCopy, 'utf-8'));
             await fs.remove(utilsEjsCopy);
         }
-        // Also render the middlewares version if present (NOT removing from template)
-        const mwDir = path.join(targetDir, 'src/infrastructure/webserver/middlewares');
+        // Also render the middleware version if present (NOT removing from template)
+        const mwDir = path.join(targetDir, 'src/infrastructure/webserver/middleware');
         const mwEjsCopy = path.join(mwDir, errTemplateName);
         const mwDest = path.join(mwDir, errName);
         if (await fs.pathExists(mwEjsCopy)) {
@@ -78,6 +68,16 @@ export const renderErrorMiddleware = async (templatePath, targetDir, config) =>
             await fs.remove(mwEjsCopy);
         }
     }
+
+    // Render errorMiddleware spec template
+    const specExt = language === 'TypeScript' ? 'ts' : 'js';
+    const specTemplatePath = path.join(templatePath, '../../common/src/utils', `errorMiddleware.spec.${specExt}.ejs`);
+    if (await fs.pathExists(specTemplatePath)) {
+        const testUtilsDir = path.join(targetDir, 'tests', 'utils');
+        await fs.ensureDir(testUtilsDir);
+        const specContent = ejs.render(await fs.readFile(specTemplatePath, 'utf-8'), config);
+        await fs.writeFile(path.join(testUtilsDir, `errorMiddleware.spec.${specExt}`), specContent);
+    }
 };
 
 export const renderDynamicComponents = async (templatePath, targetDir, config) => {
@@ -86,55 +86,147 @@ export const renderDynamicComponents = async (templatePath, targetDir, config) =
     // MVC Controller
     if (architecture === 'MVC') {
         const userControllerName = language === 'TypeScript' ? 'userController.ts' : 'userController.js';
+        const userControllerSpecName = language === 'TypeScript' ? 'userController.spec.ts' : 'userController.spec.js';
+        
         const userControllerPath = path.join(targetDir, 'src/controllers', userControllerName);
+        const userControllerSpecPath = path.join(targetDir, 'tests/controllers', userControllerSpecName);
+        
         const userControllerTemplate = path.join(templatePath, 'src/controllers', `${userControllerName}.ejs`);
+        const userControllerSpecTemplate = path.join(templatePath, 'src/controllers', `${userControllerSpecName}.ejs`);
 
         if (await fs.pathExists(userControllerTemplate)) {
-            const content = ejs.render(await fs.readFile(userControllerTemplate, 'utf-8'), { database, caching, communication: config.communication });
+            const content = ejs.render(await fs.readFile(userControllerTemplate, 'utf-8'), { ...config });
             await fs.writeFile(userControllerPath, content);
             await fs.remove(path.join(targetDir, 'src/controllers', `${userControllerName}.ejs`));
         }
-    } 
+        
+        if (await fs.pathExists(userControllerSpecTemplate)) {
+            await fs.ensureDir(path.join(targetDir, 'tests/controllers'));
+            const content = ejs.render(await fs.readFile(userControllerSpecTemplate, 'utf-8'), { ...config });
+            await fs.writeFile(userControllerSpecPath, content);
+            await fs.remove(path.join(targetDir, 'src/controllers', `${userControllerSpecName}.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 repoSpecName = language === 'TypeScript' ? 'UserRepository.spec.ts' : 'UserRepository.spec.js';
+        
+        const repoPath = path.join(targetDir, 'src/infrastructure/repositories', repoName);
+        const repoSpecPath = path.join(targetDir, 'tests/infrastructure/repositories', repoSpecName);
+        
         const repoTemplate = path.join(templatePath, 'src/infrastructure/repositories', `${repoName}.ejs`);
+        const repoSpecTemplate = path.join(templatePath, 'src/infrastructure/repositories', `${repoSpecName}.ejs`);
 
         if (await fs.pathExists(repoTemplate)) {
-            const content = ejs.render(await fs.readFile(repoTemplate, 'utf-8'), { database });
+            const content = ejs.render(await fs.readFile(repoTemplate, 'utf-8'), { ...config });
             await fs.writeFile(repoPath, content);
             await fs.remove(path.join(targetDir, 'src/infrastructure/repositories', `${repoName}.ejs`));
         }
+        if (await fs.pathExists(repoSpecTemplate)) {
+            await fs.ensureDir(path.join(targetDir, 'tests/infrastructure/repositories'));
+            const content = ejs.render(await fs.readFile(repoSpecTemplate, 'utf-8'), { ...config });
+            await fs.writeFile(repoSpecPath, content);
+            await fs.remove(path.join(targetDir, 'src/infrastructure/repositories', `${repoSpecName}.ejs`));
+        }
 
         const controllerName = language === 'TypeScript' ? 'userController.ts' : 'userController.js';
+        const controllerSpecName = language === 'TypeScript' ? 'userController.spec.ts' : 'userController.spec.js';
+        
         const controllerPath = path.join(targetDir, 'src/interfaces/controllers', controllerName);
+        const controllerSpecPath = path.join(targetDir, 'tests/interfaces/controllers', controllerSpecName);
+        
         const controllerTemplate = path.join(templatePath, 'src/interfaces/controllers', `${controllerName}.ejs`);
+        const controllerSpecTemplate = path.join(templatePath, 'src/interfaces/controllers', `${controllerSpecName}.ejs`);
 
         if (await fs.pathExists(controllerTemplate)) {
-            const content = ejs.render(await fs.readFile(controllerTemplate, 'utf-8'), { communication: config.communication });
+            const content = ejs.render(await fs.readFile(controllerTemplate, 'utf-8'), { ...config });
             await fs.writeFile(controllerPath, content);
             await fs.remove(path.join(targetDir, 'src/interfaces/controllers', `${controllerName}.ejs`));
         }
+        
+        if (await fs.pathExists(controllerSpecTemplate)) {
+            await fs.ensureDir(path.join(targetDir, 'tests/interfaces/controllers'));
+            const content = ejs.render(await fs.readFile(controllerSpecTemplate, 'utf-8'), { ...config });
+            await fs.writeFile(controllerSpecPath, content);
+            await fs.remove(path.join(targetDir, 'src/interfaces/controllers', `${controllerSpecName}.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: config.communication });
-             await fs.writeFile(serverPath, content);
-             await fs.remove(path.join(targetDir, 'src/infrastructure/webserver', `${serverName}.ejs`));
-         }
+        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'), { ...config });
+            await fs.writeFile(serverPath, content);
+            await fs.remove(path.join(targetDir, 'src/infrastructure/webserver', `${serverName}.ejs`));
+        }
+    }
+
+    // Cleanup REST routes if GraphQL or Kafka is selected
+    if (config.communication !== 'REST APIs') {
+        if (architecture === 'MVC') {
+            await fs.remove(path.join(targetDir, 'src/routes'));
+        } else if (architecture === 'Clean Architecture') {
+            await fs.remove(path.join(targetDir, 'src/interfaces/routes'));
+        }
+    }
+
+    // Advanced Health Check Route Modularization
+    const healthExt = language === 'TypeScript' ? 'ts' : 'js';
+    const healthTemplatePath = path.join(templatePath, '../../common/health', healthExt, `healthRoute.${healthExt}.ejs`);
+
+    if (await fs.pathExists(healthTemplatePath)) {
+        let routeDestDir = path.join(targetDir, 'src', 'routes');
+        if (architecture === 'Clean Architecture') {
+            routeDestDir = path.join(targetDir, 'src', 'interfaces', 'routes');
+        }
+        await fs.ensureDir(routeDestDir);
+
+        const healthRouteContent = ejs.render(await fs.readFile(healthTemplatePath, 'utf-8'), { ...config });
+        await fs.writeFile(path.join(routeDestDir, `healthRoute.${healthExt}`), healthRouteContent);
+
+        // Render health route spec template
+        const healthSpecTemplatePath = path.join(templatePath, '../../common/health', healthExt, `healthRoute.spec.${healthExt}.ejs`);
+        if (await fs.pathExists(healthSpecTemplatePath)) {
+            let testRouteDestDir = path.join(targetDir, 'tests', 'routes');
+            if (architecture === 'Clean Architecture') {
+                testRouteDestDir = path.join(targetDir, 'tests', 'interfaces', 'routes');
+            }
+            await fs.ensureDir(testRouteDestDir);
+            const specContent = ejs.render(await fs.readFile(healthSpecTemplatePath, 'utf-8'), config);
+            await fs.writeFile(path.join(testRouteDestDir, `healthRoute.spec.${healthExt}`), specContent);
+        }
+    }
+
+    // Advanced Graceful Shutdown Modularization
+    const shutdownExt = language === 'TypeScript' ? 'ts' : 'js';
+    const shutdownTemplatePath = path.join(templatePath, '../../common/shutdown', shutdownExt, `gracefulShutdown.${shutdownExt}.ejs`);
+
+    if (await fs.pathExists(shutdownTemplatePath)) {
+        let utilsDestDir = path.join(targetDir, 'src', 'utils');
+        await fs.ensureDir(utilsDestDir);
+
+        const shutdownContent = ejs.render(await fs.readFile(shutdownTemplatePath, 'utf-8'), { ...config });
+        await fs.writeFile(path.join(utilsDestDir, `gracefulShutdown.${shutdownExt}`), shutdownContent);
+
+        // Render graceful shutdown spec template
+        const shutdownSpecTemplatePath = path.join(templatePath, '../../common/shutdown', shutdownExt, `gracefulShutdown.spec.${shutdownExt}.ejs`);
+        if (await fs.pathExists(shutdownSpecTemplatePath)) {
+            const testUtilsDestDir = path.join(targetDir, 'tests', 'utils');
+            await fs.ensureDir(testUtilsDestDir);
+            const specContent = ejs.render(await fs.readFile(shutdownSpecTemplatePath, 'utf-8'), config);
+            await fs.writeFile(path.join(testUtilsDestDir, `gracefulShutdown.spec.${shutdownExt}`), specContent);
+        }
     }
 
     // GraphQL Setup
     if (config.communication === 'GraphQL') {
         const ext = language === 'TypeScript' ? 'ts' : 'js';
         let graphqlInternalPath = architecture === 'MVC' ? 'src/graphql' : 'src/interfaces/graphql';
-        
+
         const sourceGraphqDir = path.join(templatePath, graphqlInternalPath);
         const targetGraphqlDir = path.join(targetDir, graphqlInternalPath);
 
@@ -169,27 +261,18 @@ export const renderDynamicComponents = async (templatePath, targetDir, config) =
         let graphqlInternalPath = architecture === 'MVC' ? 'src/graphql' : 'src/interfaces/graphql';
         await fs.remove(path.join(targetDir, graphqlInternalPath));
     }
-
-    // Cleanup REST routes if GraphQL or Kafka is selected
-    if (config.communication !== 'REST APIs') {
-        if (architecture === 'MVC') {
-            await fs.remove(path.join(targetDir, 'src/routes'));
-        } else if (architecture === 'Clean Architecture') {
-            await fs.remove(path.join(targetDir, 'src/interfaces/routes'));
-        }
-    }
 };
 
 export const renderSwaggerConfig = async (templatesDir, targetDir, config) => {
     const { communication, projectName, architecture, language } = config;
-    
+
     // Check for Swagger config template (typically in src/config/swagger.ts.ejs)
     const swaggerTsTemplate = path.join(targetDir, 'src', 'config', 'swagger.ts.ejs');
     // MVC JS uses swagger.js.ejs in src/config/
     const swaggerJsTemplate = path.join(targetDir, 'src', 'config', 'swagger.js.ejs');
     // Clean Arch JS uses swagger.js.ejs in src/infrastructure/webserver/
     const swaggerJsCleanTemplate = path.join(targetDir, 'src', 'infrastructure', 'webserver', 'swagger.js.ejs');
-    
+
     // Ensure config directory exists
     let configDir = path.join(targetDir, 'src', 'config');
     if (architecture === 'Clean Architecture' && language === 'JavaScript') {
@@ -221,7 +304,7 @@ export const renderSwaggerConfig = async (templatesDir, targetDir, config) => {
             await fs.writeFile(path.join(targetDir, 'src', 'infrastructure', 'webserver', 'swagger.js'), content);
         }
     }
-    
+
     // Always remove the .ejs template after processing (or if non-REST, just delete it)
     if (await fs.pathExists(swaggerTsTemplate)) await fs.remove(swaggerTsTemplate);
     if (await fs.pathExists(swaggerJsTemplate)) await fs.remove(swaggerJsTemplate);
@@ -239,7 +322,44 @@ export const setupViews = async (templatesDir, targetDir, config) => {
     if (architecture === 'MVC' && viewEngine && viewEngine !== 'None') {
         const viewsSource = path.join(templatesDir, 'common', 'views', viewEngine.toLowerCase());
         if (await fs.pathExists(viewsSource)) {
-             await fs.copy(viewsSource, path.join(targetDir, 'src/views'));
+            await fs.copy(viewsSource, path.join(targetDir, 'src/views'));
         }
     }
 };
+
+export const processAllTests = async (targetDir, config) => {
+    const srcDir = path.join(targetDir, 'src');
+    const testsDir = path.join(targetDir, 'tests');
+
+    const processDir = async (currentDir) => {
+        if (!(await fs.pathExists(currentDir))) return;
+        const items = await fs.readdir(currentDir);
+        for (const item of items) {
+
+            const itemPath = path.join(currentDir, item);
+            const stat = await fs.stat(itemPath);
+            if (stat.isDirectory()) {
+                await processDir(itemPath);
+            } else if (itemPath.endsWith('.spec.ts') || 
+                itemPath.endsWith('.spec.js') || 
+                itemPath.endsWith('.spec.ts.ejs') || 
+                itemPath.endsWith('.spec.js.ejs')) {
+                const relativePath = path.relative(srcDir, itemPath);
+
+                const cleanRelativePath = relativePath.replace(/\.ejs$/, '');
+
+                const targetTestPath = path.join(testsDir, cleanRelativePath);
+
+                await fs.ensureDir(path.dirname(targetTestPath));
+
+                const template = await fs.readFile(itemPath, 'utf-8');
+                const content = ejs.render(template, config);
+
+                await fs.writeFile(targetTestPath, content);
+                await fs.remove(itemPath);
+            }
+        }
+    };
+
+    await processDir(srcDir);
+};

package/lib/modules/caching-setup.js

@@ -55,6 +55,19 @@ export const setupCaching = async (templatesDir, targetDir, config) => {
             const cacheTemplate = await fs.readFile(cacheSource, 'utf-8');
             const content = ejs.render(cacheTemplate, { loggerPath });
             await fs.writeFile(cacheTarget, content);
+
+            // Render Spec if exists
+            const specTemplateName = clientObj.replace(`.${langExt}`, `.spec.${langExt}.ejs`);
+            const specTemplateSource = path.join(templatesDir, 'common', 'caching', langExt, specTemplateName);
+            if (await fs.pathExists(specTemplateSource)) {
+                const specTemplate = await fs.readFile(specTemplateSource, 'utf-8');
+                const specLoggerPath = architecture === 'Clean Architecture' ? '@/infrastructure/log/logger' : '@/utils/logger';
+                const specRedisPath = architecture === 'Clean Architecture' ? '@/infrastructure/caching/redisClient' : '@/config/redisClient';
+                const specContent = ejs.render(specTemplate, { ...config, loggerPath: specLoggerPath, redisClientPath: specRedisPath });
+                const specTarget = cacheTarget.replace(`${path.sep}src${path.sep}`, `${path.sep}tests${path.sep}`).replace(`.${langExt}`, `.spec.${langExt}`);
+                await fs.ensureDir(path.dirname(specTarget));
+                await fs.writeFile(specTarget, specContent);
+            }
         }
     }
 };

package/lib/modules/config-files.js

@@ -3,127 +3,90 @@ import path from 'path';
 import ejs from 'ejs';
 
 export const renderPackageJson = async (templatesDir, targetDir, config) => {
-    const { projectName, database, communication, language, viewEngine, caching } = config;
     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,
-        communication,
-        language,
-        viewEngine,
-        caching
-    });
+    const packageContent = ejs.render(packageTemplate, { ...config });
     await fs.writeFile(packageJsonPath, packageContent);
 };
 
 export const renderDockerCompose = async (templatesDir, targetDir, config) => {
-    const { projectName, database, dbName, communication, caching } = config;
     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,
-        caching
-    });
+    const dockerContent = ejs.render(dockerTemplate, { ...config });
     await fs.writeFile(dockerComposePath, dockerContent);
 };
 
 export const renderReadme = async (templatesDir, targetDir, config) => {
-    const { projectName, architecture, database, communication, language, ciProvider, caching } = config;
     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,
-        caching,
-        language,
-        ciProvider
-    });
+    const readmeContent = ejs.render(readmeTemplate, { ...config });
     await fs.writeFile(readmePath, readmeContent);
 };
 
 export const renderDockerfile = async (templatesDir, targetDir, config) => {
-    const { language, viewEngine } = config;
     const dockerfileTemplate = await fs.readFile(path.join(templatesDir, 'common', 'Dockerfile'), 'utf-8');
-    const dockerfileContent = ejs.render(dockerfileTemplate, { 
-        language,
-        viewEngine
-    });
+    const dockerfileContent = ejs.render(dockerfileTemplate, { ...config });
     await fs.writeFile(path.join(targetDir, 'Dockerfile'), dockerfileContent);
 };
 
 export const renderPm2Config = async (templatesDir, targetDir, config) => {
-    const { projectName, database, dbName, communication, language, caching } = config;
     const pm2ConfigPath = path.join(targetDir, 'ecosystem.config.js');
     const pm2Template = await fs.readFile(path.join(templatesDir, 'common', 'ecosystem.config.js.ejs'), 'utf-8');
-    const pm2Content = ejs.render(pm2Template, {
-        projectName,
-        database,
-        dbName,
-        communication,
-        language,
-        caching
-    });
+    const pm2Content = ejs.render(pm2Template, { ...config });
     await fs.writeFile(pm2ConfigPath, pm2Content);
 };
 
-export const renderProfessionalConfig = async (templatesDir, targetDir, language) => {
+export const renderProfessionalConfig = async (templatesDir, targetDir, config) => {
     const eslintTemplate = await fs.readFile(path.join(templatesDir, 'common', 'eslint.config.mjs.ejs'), 'utf-8');
-    const eslintContent = ejs.render(eslintTemplate, { language });
+    const eslintContent = ejs.render(eslintTemplate, { ...config });
     await fs.writeFile(path.join(targetDir, 'eslint.config.mjs'), eslintContent);
 
     await fs.copy(path.join(templatesDir, 'common', '.prettierrc'), path.join(targetDir, '.prettierrc'));
     await fs.copy(path.join(templatesDir, 'common', '.lintstagedrc'), path.join(targetDir, '.lintstagedrc'));
 
     const jestTemplate = await fs.readFile(path.join(templatesDir, 'common', 'jest.config.js.ejs'), 'utf-8');
-    const jestContent = ejs.render(jestTemplate, { language });
+    const jestContent = ejs.render(jestTemplate, { ...config });
     await fs.writeFile(path.join(targetDir, 'jest.config.js'), jestContent);
 };
 
 export const setupCiCd = async (templatesDir, targetDir, config) => {
-    const { ciProvider, projectName } = config;
+    const { ciProvider } = 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 });
+        const jenkinsContent = ejs.render(jenkinsTemplate, { ...config });
         await fs.writeFile(path.join(targetDir, 'Jenkinsfile'), jenkinsContent);
     } else if (ciProvider === 'GitLab CI') {
         const gitlabTemplate = await fs.readFile(path.join(templatesDir, 'common', '.gitlab-ci.yml.ejs'), 'utf-8');
-        const gitlabContent = ejs.render(gitlabTemplate, { projectName });
+        const gitlabContent = ejs.render(gitlabTemplate, { ...config });
         await fs.writeFile(path.join(targetDir, '.gitlab-ci.yml'), gitlabContent);
     }
 };
 
-export const renderTestSample = async (templatesDir, targetDir, language) => {
+export const renderTestSample = async (templatesDir, targetDir, config) => {
     await fs.ensureDir(path.join(targetDir, 'tests'));
-    const healthTestTemplate = await fs.readFile(path.join(templatesDir, 'common', 'tests', 'health.test.ts.ejs'), 'utf-8');
-    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);
+    if (config.language === 'TypeScript') {
+        const testsTsConfig = {
+            "extends": "../tsconfig.json",
+            "compilerOptions": {
+                "types": ["jest", "node"],
+                "rootDir": "../tests",
+                "noEmit": true
+            },
+            "include": ["**/*.ts"]
+        };
+        await fs.writeFile(path.join(targetDir, 'tests', 'tsconfig.json'), JSON.stringify(testsTsConfig, null, 4));
+    }
 };
 
 export const renderEnvExample = async (templatesDir, targetDir, config) => {
-    const { database, dbName, communication, projectName, caching } = config;
     const envExamplePath = path.join(targetDir, '.env.example');
     const envPath = path.join(targetDir, '.env');
     const envTemplate = await fs.readFile(path.join(templatesDir, 'common', '.env.example.ejs'), 'utf-8');
     
-    const envContent = ejs.render(envTemplate, {
-        database,
-        dbName,
-        communication,
-        projectName,
-        caching
-    });
+    const envContent = ejs.render(envTemplate, { ...config });
     
     await fs.writeFile(envExamplePath, envContent);
     await fs.writeFile(envPath, envContent);