nodejs-quickstart-structure 1.13.0 → 1.15.1

package/CHANGELOG.md

@@ -5,6 +5,38 @@ 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.15.1] - 2026-03-12
+
+### Added
+- **Magic AI Scaffolding**: Automated AI context generation ( `.cursorrules`, `prompts/`) by intelligently inferring project goals from the project name, removing the need for manual business domain prompts.
+- **Enhanced README**: Added specialized guidance for AI-native development with Cursor and LLMs.
+
+### Fixed
+- **GitHub Actions Compliance**: Fully resolved Node.js 20 deprecation warnings by moving `FORCE_JAVASCRIPT_ACTIONS_TO_NODE24` to global workflow scope.
+- **CI Modernization**: Upgraded daily audit and GitLab CI runners to Node.js 22.
+- **CI Enforcement**: Updated all CI/CD templates (GitHub, GitLab, Jenkins) to strictly enforce the >70% test coverage gate.
+
+## [1.15.0] - 2026-03-12
+### Added
+- **AI-Native Scaffolding & Agent Skill Templates:**
+  - Added a new CLI prompt for `businessDomain` to inject custom domain knowledge into generated templates.
+  - Generates a `.cursorrules` file at the root to enforce >70% Test coverage and Architecture patterns automatically for AI Code Editors.
+  - Scaffolds a `prompts/` directory with specialized Agent Skill templates (`project-context.md`, `add-feature.md`, `troubleshoot.md`) designed to provide deep structural understanding to LLMs like ChatGPT or Claude.
+  - Added an "AI-Native Development" section to the generated `README.md` and prominent print messages in the CLI upon successful completion.
+
+## [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:**

package/README.md

@@ -31,14 +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:
 
@@ -46,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/bin/index.js

@@ -1,81 +1,85 @@
 #!/usr/bin/env node
-
-import { Command } from 'commander';
-import chalk from 'chalk';
-import { getProjectDetails } from '../lib/prompts.js';
-import { generateProject } from '../lib/generator.js';
-import { readFileSync } from 'fs';
-import { join, dirname } from 'path';
-import { fileURLToPath } from 'url';
-
-const __dirname = dirname(fileURLToPath(import.meta.url));
-const pkg = JSON.parse(readFileSync(join(__dirname, '../package.json'), 'utf-8'));
-
-const program = new Command();
-
-program
-    .name('nodejs-quickstart')
-    .description('🚀 CLI to scaffold production-ready Node.js microservices.\n\nGenerates projects with:\n- MVC or Clean Architecture\n- REST or Kafka\n- MySQL, PostgreSQL, or MongoDB\n- Docker, Flyway & Mongoose support')
-    .version(pkg.version, '-v, --version', 'Output the current version')
-    .addHelpText('after', `
-\n${chalk.yellow('Example:')}
-  $ nodejs-quickstart init   ${chalk.gray('# Start the interactive setup')}
-`);
-
-program
-    .command('init')
-    .description('Initialize a new Node.js project')
-    .option('-n, --project-name <name>', 'Project name')
-    .option('-l, --language <language>', 'Language (JavaScript, TypeScript)')
-    .option('-a, --architecture <architecture>', 'Architecture (MVC, Clean Architecture)')
-    .option('--view-engine <view>', 'View Engine (None, EJS, Pug) - MVC only')
-    .option('-d, --database <database>', 'Database (MySQL, PostgreSQL)')
-    .option('--db-name <name>', 'Database name')
-    .option('-c, --communication <communication>', 'Communication (REST APIs, GraphQL, Kafka)')
-    .option('--ci-provider <provider>', 'CI/CD Provider (None, GitHub Actions, Jenkins)')
-    .option('--caching <type>', 'Caching Layer (None/Redis)')
-    .action(async (options) => {
-        // Fix for Commander camelCase conversion
-        if (options.ciProvider) {
-            options.ciProvider = options.ciProvider;
-        }
-
-        console.log(chalk.blue('Welcome to the Node.js Quickstart Generator!'));
-
-        try {
-            const answers = await getProjectDetails(options);
-            console.log(chalk.green('\nConfiguration received:'));
-            console.log(JSON.stringify(answers, null, 2));
-
-            console.log(chalk.yellow('\nGenerating project...'));
-            await generateProject(answers);
-
-            console.log(chalk.green('\n✔ Project generated successfully!'));
-            
-            let manualStartInstructions = `\n${chalk.yellow('Development:')}\n  cd ${answers.projectName}\n  npm install`;
-            
-            const needsInfrastructure = answers.database !== 'None' || answers.caching === 'Redis' || answers.communication === 'Kafka';
-            
-            if (needsInfrastructure) {
-                let servicesToStart = '';
-                if (answers.database !== 'None') servicesToStart += ' db';
-                if (answers.caching === 'Redis') servicesToStart += ' redis';
-                if (answers.communication === 'Kafka') servicesToStart += ' zookeeper kafka';
-                
-                manualStartInstructions += `\n  docker-compose up -d${servicesToStart}  # Start infrastructure first\n  npm run dev`;
-            } else {
-                manualStartInstructions += `\n  npm run dev`;
-            }
-            
-            console.log(chalk.cyan(`\nNext steps:\n  cd ${answers.projectName}\n  npm install\n  docker-compose up\n-----------------------${manualStartInstructions}\n\n${chalk.yellow('Production (PM2):')}\n  npm run build\n  npm run deploy\n  npx pm2 logs`));
-
-        } catch (error) {
-            console.error(chalk.red('Error generating project:'), error);
-            process.exit(1);
-        }
-    });
-program.parse(process.argv);
-
-if (!process.argv.slice(2).length) {
-    program.outputHelp();
-}
+
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { getProjectDetails } from '../lib/prompts.js';
+import { generateProject } from '../lib/generator.js';
+import { readFileSync } from 'fs';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const pkg = JSON.parse(readFileSync(join(__dirname, '../package.json'), 'utf-8'));
+
+const program = new Command();
+
+program
+    .name('nodejs-quickstart')
+    .description('🚀 CLI to scaffold production-ready Node.js microservices.\n\nGenerates projects with:\n- MVC or Clean Architecture\n- REST or Kafka\n- MySQL, PostgreSQL, or MongoDB\n- Docker, Flyway & Mongoose support')
+    .version(pkg.version, '-v, --version', 'Output the current version')
+    .addHelpText('after', `\n${chalk.yellow('Example:')}\n  $ nodejs-quickstart init   ${chalk.gray('# Start the interactive setup')}\n`);
+
+program
+    .command('init')
+    .description('Initialize a new Node.js project')
+    .option('-n, --project-name <name>', 'Project name')
+    .option('-l, --language <language>', 'Language (JavaScript, TypeScript)')
+    .option('-a, --architecture <architecture>', 'Architecture (MVC, Clean Architecture)')
+    .option('--view-engine <view>', 'View Engine (None, EJS, Pug) - MVC only')
+    .option('-d, --database <database>', 'Database (MySQL, PostgreSQL)')
+    .option('--db-name <name>', 'Database name')
+    .option('-c, --communication <communication>', 'Communication (REST APIs, GraphQL, Kafka)')
+    .option('--ci-provider <provider>', 'CI/CD Provider (None, GitHub Actions, Jenkins)')
+    .option('--caching <type>', 'Caching Layer (None/Redis)')
+    .action(async (options) => {
+        // Fix for Commander camelCase conversion
+        if (options.ciProvider) {
+            options.ciProvider = options.ciProvider;
+        }
+
+        console.log(chalk.blue('Welcome to the Node.js Quickstart Generator!'));
+
+        try {
+            const answers = await getProjectDetails(options);
+            console.log(chalk.green('\nConfiguration received:'));
+            console.log(JSON.stringify(answers, null, 2));
+
+            console.log(chalk.yellow('\nGenerating project...'));
+            await generateProject(answers);
+
+            console.log(chalk.green('\n✔ Project generated successfully!'));
+            
+            console.log(chalk.magenta('\n🚀 Project is AI-Ready!'));
+            console.log(chalk.magenta('-----------------------------------------'));
+            console.log(chalk.magenta('🤖 We detected you are using AI tools.'));
+            console.log(chalk.magenta(`📍 Use Cursor? We've configured '.cursorrules' for you.`));
+            console.log(chalk.magenta(`📍 Use ChatGPT/Gemini? Check the 'prompts/' folder for Agent Skills.`));
+            console.log(chalk.magenta('-----------------------------------------'));
+
+            let manualStartInstructions = `\n${chalk.yellow('Development:')}\n  cd ${answers.projectName}\n  npm install`;
+            
+            const needsInfrastructure = answers.database !== 'None' || answers.caching === 'Redis' || answers.communication === 'Kafka';
+            
+            if (needsInfrastructure) {
+                let servicesToStart = '';
+                if (answers.database !== 'None') servicesToStart += ' db';
+                if (answers.caching === 'Redis') servicesToStart += ' redis';
+                if (answers.communication === 'Kafka') servicesToStart += ' zookeeper kafka';
+                
+                manualStartInstructions += `\n  docker-compose up -d${servicesToStart}  # Start infrastructure first\n  npm run dev`;
+            } else {
+                manualStartInstructions += `\n  npm run dev`;
+            }
+            
+            console.log(chalk.cyan(`\nNext steps:\n  cd ${answers.projectName}\n  npm install\n  docker-compose up\n-----------------------${manualStartInstructions}\n\n${chalk.yellow('Production (PM2):')}\n  npm run build\n  npm run deploy\n  npx pm2 logs`));
+
+        } catch (error) {
+            console.error(chalk.red('Error generating project:'), error);
+            process.exit(1);
+        }
+    });
+program.parse(process.argv);
+
+if (!process.argv.slice(2).length) {
+    program.outputHelp();
+}

package/lib/generator.js

@@ -1,8 +1,8 @@
 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 { renderPackageJson, renderDockerCompose, renderReadme, renderDockerfile, renderProfessionalConfig, setupCiCd, renderTestSample, renderEnvExample, renderPm2Config, renderAiNativeFiles } from './modules/config-files.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,11 @@ 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);
+
+    // 13.5 AI-Native Scaffolding
+    await renderAiNativeFiles(templatesDir, targetDir, config);
 
     // 14. CI/CD
     await setupCiCd(templatesDir, targetDir, config);
@@ -79,6 +93,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!
@@ -100,6 +117,13 @@ export const generateProject = async (config) => {
       ✅  Docker: Production-ready multi-stage build
       ${config.ciProvider !== 'None' ? `✅  CI/CD: ${config.ciProvider} Workflow ready` : '❌  CI/CD: Skipped (User preferred)'}
 
+      ----------------------------------------------------
+      🚀  Project is AI-Ready!
+      ----------------------------------------------------
+      🤖  We detected you are using AI tools. 
+      📍  Use Cursor? We've configured '.cursorrules' for you.
+      📍  Use ChatGPT/Gemini? Check the 'prompts/' folder for Agent Skills.
+
       ----------------------------------------------------
       👉  Next Steps:
       ----------------------------------------------------

package/lib/modules/app-setup.js

@@ -10,14 +10,7 @@ export const renderIndexFile = async (templatePath, targetDir, config) => {
 
     if (await fs.pathExists(indexTemplateSource)) {
         const indexTemplate = await fs.readFile(indexTemplateSource, 'utf-8');
-        const indexContent = ejs.render(indexTemplate, {
-            communication,
-            viewEngine,
-            database,
-            architecture,
-            projectName,
-            caching
-        });
+        const indexContent = ejs.render(indexTemplate, { ...config });
         await fs.writeFile(indexPath, indexContent);
         await fs.remove(path.join(targetDir, 'src', `${indexFileName}.ejs`));
     }
@@ -37,11 +30,7 @@ export const renderEnvConfig = async (templatePath, targetDir, config) => {
 
     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);
     }
@@ -79,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) => {
@@ -87,36 +86,71 @@ 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 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') {
@@ -125,7 +159,7 @@ export const renderDynamicComponents = async (templatePath, targetDir, config) =
         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, database, caching });
+            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`));
         }
@@ -151,8 +185,20 @@ export const renderDynamicComponents = async (templatePath, targetDir, config) =
         }
         await fs.ensureDir(routeDestDir);
 
-        const healthRouteContent = ejs.render(await fs.readFile(healthTemplatePath, 'utf-8'), { database, architecture });
+        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
@@ -163,8 +209,17 @@ export const renderDynamicComponents = async (templatePath, targetDir, config) =
         let utilsDestDir = path.join(targetDir, 'src', 'utils');
         await fs.ensureDir(utilsDestDir);
 
-        const shutdownContent = ejs.render(await fs.readFile(shutdownTemplatePath, 'utf-8'), { database, architecture, caching, communication: config.communication });
+        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
@@ -271,3 +326,40 @@ export const setupViews = async (templatesDir, targetDir, config) => {
         }
     }
 };
+
+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);
+            }
         }
     }
 };