nodejs-quickstart-structure 1.13.0 → 1.15.1

package/lib/modules/config-files.js

@@ -3,127 +3,115 @@ 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 renderAiNativeFiles = async (templatesDir, targetDir, config) => {
+    // 1. .cursorrules
+    const cursorRulesPath = path.join(targetDir, '.cursorrules');
+    const cursorRulesTemplate = await fs.readFile(path.join(templatesDir, 'common', '.cursorrules.ejs'), 'utf-8');
+    const cursorRulesContent = ejs.render(cursorRulesTemplate, { ...config });
+    await fs.writeFile(cursorRulesPath, cursorRulesContent);
+
+    // 2. prompts/
+    const promptsDirTarget = path.join(targetDir, 'prompts');
+    await fs.ensureDir(promptsDirTarget);
+    
+    const promptsSourceDir = path.join(templatesDir, 'common', 'prompts');
+    const promptFiles = await fs.readdir(promptsSourceDir);
+    
+    for (const file of promptFiles) {
+        if (file.endsWith('.ejs')) {
+            const templatePath = path.join(promptsSourceDir, file);
+            const targetFilePath = path.join(promptsDirTarget, file.replace('.ejs', ''));
+            const templateContent = await fs.readFile(templatePath, 'utf-8');
+            const renderedContent = ejs.render(templateContent, { ...config });
+            await fs.writeFile(targetFilePath, renderedContent);
+        }
+    }
+};
+
 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);
         }
     }
 };

package/lib/modules/kafka-setup.js

@@ -13,24 +13,68 @@ export const setupKafka = async (templatesDir, targetDir, config) => {
     // Render Kafka Service with dynamic logger path
     const kafkaServiceFileName = `kafkaService.${langExt}`;
     const kafkaServiceTemplate = path.join(targetDir, 'src', 'services', `${kafkaServiceFileName}.ejs`);
-    
-    if (await fs.pathExists(kafkaServiceTemplate)) {
-        let loggerPath = architecture === 'Clean Architecture' ? '../log/logger' : '../utils/logger';
-        let configPath = '../config/kafka';
+    // Render Kafka Service Spec
+    const kafkaSpecFileName = `kafkaService.spec.${langExt}`;
+    const kafkaSpecTemplate = path.join(targetDir, 'src', 'services', `${kafkaSpecFileName}.ejs`);
 
+    if (await fs.pathExists(kafkaServiceTemplate)) {
+        let serviceLoggerPath, serviceConfigPath;
         if (language === 'TypeScript') {
-            loggerPath = architecture === 'Clean Architecture' ? '@/infrastructure/log/logger' : '@/utils/logger';
-            configPath = architecture === 'Clean Architecture' ? '@/infrastructure/config/kafka' : '@/config/kafka';
+            serviceLoggerPath = architecture === 'Clean Architecture' ? '@/infrastructure/log/logger' : '@/utils/logger';
+            serviceConfigPath = architecture === 'Clean Architecture' ? '@/infrastructure/config/kafka' : '@/config/kafka';
+        } else {
+            serviceLoggerPath = architecture === 'Clean Architecture' ? '../../infrastructure/log/logger' : '../utils/logger';
+            serviceConfigPath = architecture === 'Clean Architecture' ? '../../infrastructure/config/kafka' : '../config/kafka';
         }
         
-        const content = ejs.render(await fs.readFile(kafkaServiceTemplate, 'utf-8'), { loggerPath, configPath });
+        const content = ejs.render(await fs.readFile(kafkaServiceTemplate, 'utf-8'), { ...config, loggerPath: serviceLoggerPath, configPath: serviceConfigPath });
         await fs.writeFile(path.join(targetDir, 'src', 'services', kafkaServiceFileName), content);
         await fs.remove(kafkaServiceTemplate);
     }
 
+    if (await fs.pathExists(kafkaSpecTemplate)) {
+        let specLoggerPath, specConfigPath, specServicePath;
+        if (language === 'TypeScript') {
+            specLoggerPath = architecture === 'Clean Architecture' ? '@/infrastructure/log/logger' : '@/utils/logger';
+            specConfigPath = architecture === 'Clean Architecture' ? '@/infrastructure/config/kafka' : '@/config/kafka';
+            specServicePath = architecture === 'Clean Architecture' ? '@/infrastructure/messaging/kafkaClient' : '@/services/kafkaService';
+        } else {
+            // For JS tests, we use @/ to ensure resolution after move to tests/
+            specLoggerPath = architecture === 'Clean Architecture' ? '@/infrastructure/log/logger' : '@/utils/logger';
+            specConfigPath = architecture === 'Clean Architecture' ? '@/infrastructure/config/kafka' : '@/config/kafka';
+            specServicePath = architecture === 'Clean Architecture' ? '@/infrastructure/messaging/kafkaClient' : '@/services/kafkaService';
+        }
+
+        const specContent = ejs.render(await fs.readFile(kafkaSpecTemplate, 'utf-8'), { ...config, loggerPath: specLoggerPath, configPath: specConfigPath, servicePath: specServicePath });
+        await fs.writeFile(path.join(targetDir, 'src', 'services', kafkaSpecFileName), specContent);
+        await fs.remove(kafkaSpecTemplate);
+    }
+
+    // Render Kafka Config Spec
+    const kafkaConfigSpecFileName = `kafka.spec.${langExt}`;
+    const kafkaConfigSpecTemplate = path.join(templatesDir, 'common', 'kafka', langExt, 'config', `${kafkaConfigSpecFileName}.ejs`);
+    if (await fs.pathExists(kafkaConfigSpecTemplate)) {
+        const specContent = ejs.render(await fs.readFile(kafkaConfigSpecTemplate, 'utf-8'), { ...config });
+        let specTarget;
+        if (architecture === 'MVC') {
+            specTarget = path.join(targetDir, 'tests', 'config', kafkaConfigSpecFileName);
+        } else {
+            specTarget = path.join(targetDir, 'tests', 'infrastructure', 'config', kafkaConfigSpecFileName);
+        }
+        await fs.ensureDir(path.dirname(specTarget));
+        await fs.writeFile(specTarget, specContent);
+        
+        // Remove the template from src in targetDir to avoid double processing by processAllTests
+        const targetSpecTemplate = path.join(targetDir, 'src', 'config', `${kafkaConfigSpecFileName}.ejs`);
+        if (await fs.pathExists(targetSpecTemplate)) {
+            await fs.remove(targetSpecTemplate);
+        }
+    }
+
     if (architecture === 'Clean Architecture') {
         // Clean Architecture Restructuring
         await fs.ensureDir(path.join(targetDir, 'src/infrastructure/messaging'));
+        await fs.ensureDir(path.join(targetDir, 'tests/infrastructure/messaging'));
         await fs.ensureDir(path.join(targetDir, 'src/infrastructure/config'));
 
         const serviceExt = language === 'TypeScript' ? 'ts' : 'js';
@@ -42,6 +86,15 @@ export const setupKafka = async (templatesDir, targetDir, config) => {
             { overwrite: true }
         );
 
+        // Move Spec to Tests/Infrastructure/Messaging
+        if (await fs.pathExists(path.join(targetDir, `src/services/kafkaService.spec.${serviceExt}`))) {
+            await fs.move(
+                path.join(targetDir, `src/services/kafkaService.spec.${serviceExt}`),
+                path.join(targetDir, `tests/infrastructure/messaging/kafkaClient.spec.${serviceExt}`),
+                { overwrite: true }
+            );
+        }
+
         // Move Config to Infrastructure/Config
         // Note: Check if config path exists before moving, though copy above should have put it there
         if (await fs.pathExists(path.join(targetDir, `src/config/kafka.${serviceExt}`))) {
@@ -57,12 +110,27 @@ export const setupKafka = async (templatesDir, targetDir, config) => {
         
         // Remove REST-specific folders (Interfaces) - Note: routes is kept for health endpoint
         await fs.remove(path.join(targetDir, 'src/interfaces/controllers'));
+        await fs.remove(path.join(targetDir, 'tests/interfaces/controllers'));
         
         // Original logic removed src/config entirely, but now we use it for Zod env validation in TS.
         // We will no longer delete it.
-    } else if (architecture === 'MVC' && (!config.viewEngine || config.viewEngine === 'None')) {
-        // MVC Cleanup for Kafka Worker (No views) - Note: routes is kept for health endpoint
-        await fs.remove(path.join(targetDir, 'src/controllers'));
+    } else if (architecture === 'MVC') {
+        const serviceExt = language === 'TypeScript' ? 'ts' : 'js';
+        // Move Spec to Tests/Services
+        if (await fs.pathExists(path.join(targetDir, `src/services/kafkaService.spec.${serviceExt}`))) {
+            await fs.ensureDir(path.join(targetDir, 'tests/services'));
+            await fs.move(
+                path.join(targetDir, `src/services/kafkaService.spec.${serviceExt}`),
+                path.join(targetDir, `tests/services/kafkaService.spec.${serviceExt}`),
+                { overwrite: true }
+            );
+        }
+
+        if (!config.viewEngine || config.viewEngine === 'None') {
+            // MVC Cleanup for Kafka Worker (No views) - Note: routes is kept for health endpoint
+            await fs.remove(path.join(targetDir, 'src/controllers'));
+            await fs.remove(path.join(targetDir, 'tests/controllers'));
+        }
     }
 };
 

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "nodejs-quickstart-structure",
-  "version": "1.13.0",
+  "version": "1.15.1",
   "type": "module",
-  "description": "A CLI to scaffold Node.js microservices with MVC or Clean Architecture",
+  "description": "The ultimate nodejs quickstart structure CLI to scaffold Node.js microservices with MVC or Clean Architecture",
   "main": "bin/index.js",
   "bin": {
     "nodejs-quickstart": "./bin/index.js"
@@ -16,12 +16,17 @@
   },
   "keywords": [
     "nodejs",
+    "node",
+    "quickstart",
+    "structure",
     "cli",
     "scaffold",
     "mvc",
     "clean-architecture",
     "microservices",
-    "backend"
+    "backend",
+    "generator",
+    "boilerplate"
   ],
   "author": "Pau Dang <[EMAIL_ADDRESS]>",
   "repository": {
@@ -44,7 +49,6 @@
     "bin",
     "lib",
     "templates",
-    "docs",
     "README.md",
     "CHANGELOG.md"
   ]

package/templates/clean-architecture/js/src/errors/BadRequestError.js

@@ -1,5 +1,5 @@
 const { ApiError } = require('./ApiError');
-const { HTTP_STATUS } = require('../utils/httpCodes');
+const HTTP_STATUS = require('../utils/httpCodes');
 
 class BadRequestError extends ApiError {
   constructor(message = 'Bad request') {

package/templates/clean-architecture/js/src/errors/BadRequestError.spec.js.ejs

@@ -0,0 +1,21 @@
+const { BadRequestError } = require('@/errors/BadRequestError');
+const { ApiError } = require('@/errors/ApiError');
+const HTTP_STATUS = require('@/utils/httpCodes');
+
+describe('BadRequestError', () => {
+    it('should extend ApiError', () => {
+        const error = new BadRequestError();
+        expect(error).toBeInstanceOf(ApiError);
+    });
+
+    it('should have default message "Bad request"', () => {
+        const error = new BadRequestError();
+        expect(error.message).toBe('Bad request');
+        expect(error.statusCode).toBe(HTTP_STATUS.BAD_REQUEST);
+    });
+
+    it('should accept a custom message', () => {
+        const error = new BadRequestError('Custom bad request');
+        expect(error.message).toBe('Custom bad request');
+    });
+});

package/templates/clean-architecture/js/src/errors/NotFoundError.js

@@ -1,5 +1,5 @@
 const { ApiError } = require('./ApiError');
-const { HTTP_STATUS } = require('../utils/httpCodes');
+const HTTP_STATUS = require('../utils/httpCodes');
 
 class NotFoundError extends ApiError {
   constructor(message = 'Resource not found') {

package/templates/clean-architecture/js/src/errors/NotFoundError.spec.js.ejs

@@ -0,0 +1,21 @@
+const { NotFoundError } = require('@/errors/NotFoundError');
+const { ApiError } = require('@/errors/ApiError');
+const HTTP_STATUS = require('@/utils/httpCodes');
+
+describe('NotFoundError', () => {
+    it('should extend ApiError', () => {
+        const error = new NotFoundError();
+        expect(error).toBeInstanceOf(ApiError);
+    });
+
+    it('should have default message "Resource not found"', () => {
+        const error = new NotFoundError();
+        expect(error.message).toBe('Resource not found');
+        expect(error.statusCode).toBe(HTTP_STATUS.NOT_FOUND);
+    });
+
+    it('should accept a custom message', () => {
+        const error = new NotFoundError('User not found');
+        expect(error.message).toBe('User not found');
+    });
+});

package/templates/clean-architecture/js/src/infrastructure/log/logger.spec.js.ejs

@@ -0,0 +1,63 @@
+jest.mock('winston-daily-rotate-file');
+jest.mock('winston', () => {
+    const mockLogger = {
+        add: jest.fn(),
+        info: jest.fn(),
+        error: jest.fn(),
+        warn: jest.fn()
+    };
+    const format = {
+        combine: jest.fn(),
+        timestamp: jest.fn(),
+        json: jest.fn(),
+        simple: jest.fn()
+    };
+    const transports = {
+        Console: jest.fn(),
+        DailyRotateFile: jest.fn()
+    };
+    return {
+        format,
+        transports,
+        createLogger: jest.fn().mockReturnValue(mockLogger)
+    };
+});
+
+<% if (architecture === 'MVC') { -%>
+const logger = require('@/utils/logger');
+<% } else { -%>
+const logger = require('@/infrastructure/log/logger');
+<% } -%>
+
+describe('Logger', () => {
+    it('should export a logger instance', () => {
+        expect(logger).toBeDefined();
+    });
+
+    it('should have info method', () => {
+        expect(typeof logger.info).toBe('function');
+    });
+
+    it('should have error method', () => {
+        expect(typeof logger.error).toBe('function');
+    });
+
+    it('should call info', () => {
+        logger.info('test message');
+        expect(logger.info).toHaveBeenCalledWith('test message');
+    });
+
+    it('should call error', () => {
+        logger.error('test error');
+        expect(logger.error).toHaveBeenCalledWith('test error');
+    });
+
+    it('should use JSON format in production environment', () => {
+        const winston = require('winston');
+        jest.resetModules();
+        process.env.NODE_ENV = 'production';
+        require('@/infrastructure/log/logger');
+        expect(winston.format.json).toHaveBeenCalled();
+        process.env.NODE_ENV = 'test';
+    });
+});

package/templates/clean-architecture/js/src/infrastructure/repositories/UserRepository.js.ejs

@@ -3,8 +3,7 @@ const UserModel = require('../database/models/User');
 class UserRepository {
   async save(user) {
 <%_ if (database === 'None') { -%>
-    const newUser = { ...user, id: String(UserModel.mockData.length + 1) };
-    UserModel.mockData.push(newUser);
+    const newUser = await UserModel.create(user);
     return newUser;
 <%_ } else { -%>
     const newUser = await UserModel.create({ name: user.name, email: user.email });
@@ -18,7 +17,7 @@ class UserRepository {
 
   async getUsers() {
 <%_ if (database === 'None') { -%>
-    return UserModel.mockData;
+    return await UserModel.find();
 <%_ } else if (database === 'MongoDB') { -%>
     const users = await UserModel.find();
     return users.map(user => ({