nodejs-quickstart-structure 1.13.0 → 1.14.0

package/CHANGELOG.md

@@ -5,6 +5,19 @@ 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:**

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/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

@@ -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);
+            }
         }
     }
 };

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);

package/lib/modules/database-setup.js

@@ -10,7 +10,7 @@ export const setupDatabase = async (templatesDir, targetDir, config) => {
     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 });
+        const migrateConfigContent = ejs.render(migrateConfigTemplate, { ...config });
         await fs.writeFile(path.join(targetDir, 'migrate-mongo-config.js'), migrateConfigContent);
 
         // Setup migrations directory
@@ -58,8 +58,19 @@ export const setupDatabase = async (templatesDir, targetDir, config) => {
 
         if (await fs.pathExists(dbConfigTemplateSource)) {
             const dbTemplate = await fs.readFile(dbConfigTemplateSource, 'utf-8');
-            const dbContent = ejs.render(dbTemplate, { database, dbName, architecture });
+            const dbContent = ejs.render(dbTemplate, { ...config });
             await fs.writeFile(dbConfigTarget, dbContent);
+
+            // Render Spec
+            const specTemplateName = dbConfigFileName.replace(`.${langExt}`, `.spec.${langExt}.ejs`);
+            const specTemplateSource = path.join(templatesDir, 'common', 'database', langExt, specTemplateName);
+            if (await fs.pathExists(specTemplateSource)) {
+                const specTemplate = await fs.readFile(specTemplateSource, 'utf-8');
+                const specContent = ejs.render(specTemplate, { ...config });
+                const specTarget = dbConfigTarget.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);
+            }
         }
     } else if (architecture === 'MVC') {
          // Even if DB is None, MVC needs src/config for other things (like swagger or general config)
@@ -75,37 +86,31 @@ export const generateModels = async (templatesDir, targetDir, config) => {
     const langExt = language === 'TypeScript' ? 'ts' : 'js';
     const modelFileName = language === 'TypeScript' ? 'User.ts' : 'User.js';
 
-    if (database !== 'None') {
-        const sourceModelName = database === 'MongoDB' ? `${modelFileName}.mongoose.ejs` : `${modelFileName}.ejs`;
-        const modelTemplateSource = path.join(templatesDir, 'common', 'database', langExt, 'models', sourceModelName);
-        let modelTarget;
-
-        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);
-        }
+    const sourceModelName = database === 'MongoDB' ? `${modelFileName}.mongoose.ejs` : `${modelFileName}.ejs`;
+    const modelTemplateSource = path.join(templatesDir, 'common', 'database', langExt, 'models', sourceModelName);
+    let modelTarget;
 
-        if (await fs.pathExists(modelTemplateSource)) {
-            const modelTemplate = await fs.readFile(modelTemplateSource, 'utf-8');
-            const modelContent = ejs.render(modelTemplate, { architecture });
-            await fs.writeFile(modelTarget, modelContent);
-        }
+    if (architecture === 'MVC') {
+        await fs.ensureDir(path.join(targetDir, 'src/models'));
+        modelTarget = path.join(targetDir, 'src/models', modelFileName);
     } else {
-        // Mock Models for None DB
-        const mockModelContent = language === 'TypeScript' 
-            ? `export interface User { id: string; name: string; email: string; }\n\nexport default class UserModel {\n  static mockData: User[] = [];\n}`
-            : `class UserModel {\n  static mockData = [];\n}\n\nmodule.exports = UserModel;`;
+        await fs.ensureDir(path.join(targetDir, 'src/infrastructure/database/models'));
+        modelTarget = path.join(targetDir, 'src/infrastructure/database/models', modelFileName);
+    }
 
-        if (architecture === 'MVC') {
-             await fs.ensureDir(path.join(targetDir, 'src/models'));
-             await fs.writeFile(path.join(targetDir, 'src/models', modelFileName), mockModelContent);
-        } else {
-            // Clean Arch
-            await fs.ensureDir(path.join(targetDir, 'src/infrastructure/database/models'));
-            await fs.writeFile(path.join(targetDir, 'src/infrastructure/database/models', modelFileName), mockModelContent);
+    if (await fs.pathExists(modelTemplateSource)) {
+        const modelTemplate = await fs.readFile(modelTemplateSource, 'utf-8');
+        const modelContent = ejs.render(modelTemplate, { ...config });
+        await fs.writeFile(modelTarget, modelContent);
+
+        // Render Spec
+        const modelSpecTemplateSource = path.join(templatesDir, 'common', 'database', langExt, 'models', `User.spec.${langExt}.ejs`);
+        if (await fs.pathExists(modelSpecTemplateSource)) {
+            const modelSpecTemplate = await fs.readFile(modelSpecTemplateSource, 'utf-8');
+            const modelSpecContent = ejs.render(modelSpecTemplate, { ...config });
+            const modelSpecTarget = modelTarget.replace(`${path.sep}src${path.sep}`, `${path.sep}tests${path.sep}`).replace(`.${langExt}`, `.spec.${langExt}`);
+            await fs.ensureDir(path.dirname(modelSpecTarget));
+            await fs.writeFile(modelSpecTarget, modelSpecContent);
         }
     }
 };