nodejs-quickstart-structure 1.13.0 → 1.14.0

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,6 +1,6 @@
 {
   "name": "nodejs-quickstart-structure",
-  "version": "1.13.0",
+  "version": "1.14.0",
   "type": "module",
   "description": "A CLI to scaffold Node.js microservices with MVC or Clean Architecture",
   "main": "bin/index.js",
@@ -44,7 +44,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 => ({

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

@@ -0,0 +1,81 @@
+const UserRepository = require('@/infrastructure/repositories/UserRepository');
+const UserModel = require('@/infrastructure/database/models/User');
+
+jest.mock('@/infrastructure/database/models/User');
+
+describe('UserRepository', () => {
+    let userRepository;
+
+    beforeEach(() => {
+        userRepository = new UserRepository();
+        jest.clearAllMocks();
+    });
+
+    describe('save', () => {
+        it('should save and return a newly created user (Happy Path)', async () => {
+            const userData = { name: 'New User', email: 'new@example.com' };
+<%_ if (database === 'MongoDB') { -%>
+            const savedData = { _id: 'mock-id', ...userData };
+            UserModel.create.mockResolvedValue(savedData);
+<%_ } else if (database === 'None') { -%>
+            UserModel.create.mockResolvedValue(userData);
+<%_ } else { -%>
+            const savedData = { <%= database === "MongoDB" ? "_id" : "id" %>: '<%= database === "MongoDB" ? "mock-id" : "1" %>', ...userData };
+            UserModel.create.mockResolvedValue(savedData);
+<%_ } -%>
+
+            const result = await userRepository.save(userData);
+
+<%_ if (database === 'None') { -%>
+            expect(result.name).toEqual(userData.name);
+<%_ } else { -%>
+            expect(UserModel.create).toHaveBeenCalledWith(userData);
+            expect(result).toEqual({ id: '<%= database === "MongoDB" ? "mock-id" : "1" %>', ...userData });
+<%_ } -%>
+        });
+
+        it('should throw an error when DB fails explicitly (Edge Case)', async () => {
+<%_ if (database === 'None') { -%>
+            // mock data logic doesn't throw naturally
+<%_ } else { -%>
+            const error = new Error('DB Error');
+            UserModel.create.mockRejectedValue(error);
+
+            await expect(userRepository.save({})).rejects.toThrow('DB Error');
+<%_ } -%>
+        });
+    });
+
+    describe('getUsers', () => {
+        it('should return a list of mapped UserEntities (Happy Path)', async () => {
+<%_ if (database === 'MongoDB') { -%>
+            const mockUsers = [
+                { _id: '1', name: 'User 1', email: 'u1@test.com' },
+                { _id: '2', name: 'User 2', email: 'u2@test.com' }
+            ];
+            UserModel.find.mockResolvedValue(mockUsers);
+<%_ } else if (database === 'None') { -%>
+            const mockUsers = [{ id: '1', name: 'User 1', email: 'u1@test.com' }];
+            UserModel.find.mockResolvedValue(mockUsers);
+<%_ } else { -%>
+            const mockUsers = [
+                { <%= database === "MongoDB" ? "_id" : "id" %>: '1', name: 'User 1', email: 'u1@test.com' },
+                { <%= database === "MongoDB" ? "_id" : "id" %>: '2', name: 'User 2', email: 'u2@test.com' }
+            ];
+            UserModel.<%= database === "MongoDB" ? "find" : "findAll" %>.mockResolvedValue(mockUsers);
+<%_ } -%>
+            
+            const result = await userRepository.getUsers();
+
+<%_ if (database !== 'None') { -%>
+            expect(UserModel.<%= database === 'MongoDB' ? 'find' : 'findAll' %>).toHaveBeenCalled();
+<%_ } -%>
+            expect(result).toEqual([
+                { id: '1', name: 'User 1', email: 'u1@test.com' }
+<%_ if (database !== 'None') { -%>
+                , { id: '2', name: 'User 2', email: 'u2@test.com' }
+<%_ } -%>
+            ]);
+        });
+    });
+});

package/templates/clean-architecture/js/src/interfaces/controllers/userController.js.ejs

@@ -33,10 +33,14 @@ class UserController {
         }
     }
 <% } else { -%>
-    getUsers(req, res, next) {
-        this.getAllUsersUseCase.execute()
-            .then(users => res.json(users))
-            .catch(next);
+    async getUsers(req, res, next) {
+      try {
+        const users = await this.getAllUsersUseCase.execute();
+        res.json(users);
+      } catch (error) {
+        logger.error('Error getting users:', error);
+        next(error);
+      }
     }
 
     async createUser(req, res, next) {

package/templates/clean-architecture/js/src/interfaces/controllers/userController.spec.js.ejs

@@ -0,0 +1,102 @@
+const UserController = require('@/interfaces/controllers/userController');
+const CreateUser = require('@/usecases/CreateUser');
+const GetAllUsers = require('@/usecases/GetAllUsers');
+
+jest.mock('@/usecases/CreateUser');
+jest.mock('@/usecases/GetAllUsers');
+
+describe('UserController (Clean Architecture)', () => {
+    let userController;
+    let mockCreateUserUseCase;
+    let mockGetAllUsersUseCase;
+<%_ if (communication !== 'GraphQL') { -%>
+    let mockRequest;
+    let mockResponse;
+    let mockNext;
+<%_ } -%>
+
+    beforeEach(() => {
+        jest.clearAllMocks();
+
+        userController = new UserController();
+
+        // Retrieve the mocked instances created inside UserController constructor
+        mockCreateUserUseCase = CreateUser.mock.instances[0];
+        mockGetAllUsersUseCase = GetAllUsers.mock.instances[0];
+
+<%_ if (communication !== 'GraphQL') { -%>
+        mockRequest = {
+            body: {}
+        };
+        mockResponse = {
+            status: jest.fn().mockReturnThis(),
+            json: jest.fn()
+        };
+        mockNext = jest.fn();
+<%_ } -%>
+    });
+
+    describe('getUsers', () => {
+        it('should return successfully (Happy Path)', async () => {
+            const usersMock = [{ id: '1', name: 'Test', email: 'test@example.com' }];
+            mockGetAllUsersUseCase.execute.mockResolvedValue(usersMock);
+
+<%_ if (communication === 'GraphQL') { -%>
+            const result = await userController.getUsers();
+            expect(result).toEqual(usersMock);
+<%_ } else { -%>
+            await userController.getUsers(mockRequest, mockResponse, mockNext);
+            expect(mockResponse.json).toHaveBeenCalledWith(usersMock);
+<%_ } -%>
+            expect(mockGetAllUsersUseCase.execute).toHaveBeenCalled();
+        });
+
+        it('should handle errors correctly (Error Handling)', async () => {
+            const error = new Error('UseCase Error');
+            mockGetAllUsersUseCase.execute.mockRejectedValue(error);
+
+<%_ if (communication === 'GraphQL') { -%>
+            await expect(userController.getUsers()).rejects.toThrow(error);
+<%_ } else { -%>
+            await userController.getUsers(mockRequest, mockResponse, mockNext);
+            expect(mockNext).toHaveBeenCalledWith(error);
+<%_ } -%>
+        });
+    });
+
+    describe('createUser', () => {
+        it('should successfully create a new user (Happy Path)', async () => {
+            const payload = { name: 'Alice', email: 'alice@example.com' };
+<%_ if (communication === 'GraphQL') { -%>
+            const dataArg = payload;
+<%_ } else { -%>
+            mockRequest.body = payload;
+<%_ } -%>
+            const expectedUser = { id: '1', ...payload };
+            
+            mockCreateUserUseCase.execute.mockResolvedValue(expectedUser);
+
+<%_ if (communication === 'GraphQL') { -%>
+            const result = await userController.createUser(dataArg);
+            expect(result).toEqual(expectedUser);
+<%_ } else { -%>
+            await userController.createUser(mockRequest, mockResponse, mockNext);
+            expect(mockResponse.status).toHaveBeenCalledWith(201);
+            expect(mockResponse.json).toHaveBeenCalledWith(expectedUser);
+<%_ } -%>
+            expect(mockCreateUserUseCase.execute).toHaveBeenCalledWith(payload.name, payload.email);
+        });
+
+        it('should handle errors when creation fails (Error Handling)', async () => {
+            const error = new Error('Creation Error');
+            mockCreateUserUseCase.execute.mockRejectedValue(error);
+
+<%_ if (communication === 'GraphQL') { -%>
+            await expect(userController.createUser({ name: 'Bob', email: 'bob@example.com' })).rejects.toThrow(error);
+<%_ } else { -%>
+            await userController.createUser(mockRequest, mockResponse, mockNext);
+            expect(mockNext).toHaveBeenCalledWith(error);
+<%_ } -%>
+        });
+    });
+});

package/templates/clean-architecture/js/src/interfaces/graphql/context.spec.js.ejs

@@ -0,0 +1,31 @@
+const { gqlContext } = require('@/interfaces/graphql/context');
+const { resolvers } = require('@/interfaces/graphql/resolvers');
+const { typeDefs } = require('@/interfaces/graphql/typeDefs');
+
+jest.mock('@/infrastructure/repositories/UserRepository');
+
+describe('GraphQL Context', () => {
+    it('should exercise GraphQL index entry points', () => {
+        expect(resolvers).toBeDefined();
+        expect(typeDefs).toBeDefined();
+    });
+  it('should return context with token when authorization header is present', async () => {
+    const mockRequest = {
+      headers: {
+        authorization: 'Bearer token123',
+      },
+    };
+
+    const context = await gqlContext({ req: mockRequest });
+    expect(context.token).toBe('Bearer token123');
+  });
+
+  it('should return context with empty token when authorization header is missing', async () => {
+    const mockRequest = {
+      headers: {},
+    };
+
+    const context = await gqlContext({ req: mockRequest });
+    expect(context.token).toBe('');
+  });
+});

package/templates/clean-architecture/js/src/interfaces/graphql/resolvers/user.resolvers.spec.js.ejs

@@ -0,0 +1,49 @@
+const { userResolvers } = require('@/interfaces/graphql/resolvers/user.resolvers');
+
+const mockGetUsers = jest.fn().mockResolvedValue([{ id: '1', name: 'John Doe', email: 'john@example.com' }]);
+const mockCreateUser = jest.fn().mockResolvedValue({ id: '1', name: 'Jane', email: 'jane@example.com' });
+
+jest.mock('@/interfaces/controllers/userController', () => {
+  return jest.fn().mockImplementation(() => ({
+    getUsers: (...args) => mockGetUsers(...args),
+    createUser: (...args) => mockCreateUser(...args)
+  }));
+});
+
+describe('User Resolvers', () => {
+  afterEach(() => {
+    jest.clearAllMocks();
+  });
+
+  describe('Query.getAllUsers', () => {
+    it('should return all users', async () => {
+      const result = await userResolvers.Query.getAllUsers();
+      expect(result).toEqual([{ id: '1', name: 'John Doe', email: 'john@example.com' }]);
+      expect(mockGetUsers).toHaveBeenCalledTimes(1);
+    });
+  });
+
+  describe('Mutation.createUser', () => {
+    it('should create and return a new user', async () => {
+      const result = await userResolvers.Mutation.createUser(null, { name: 'Jane', email: 'jane@example.com' });
+      expect(result).toEqual({ id: '1', name: 'Jane', email: 'jane@example.com' });
+      expect(mockCreateUser).toHaveBeenCalledWith({ name: 'Jane', email: 'jane@example.com' });
+      expect(mockCreateUser).toHaveBeenCalledTimes(1);
+    });
+  });
+<%_ if (database === 'MongoDB') { -%>
+  describe('User.id', () => {
+    it('should return parent.id if available', () => {
+      const parent = { id: '123' };
+      const result = userResolvers.User.id(parent);
+      expect(result).toBe('123');
+    });
+
+    it('should fallback to parent._id if id is not available', () => {
+      const parent = { _id: '456' };
+      const result = userResolvers.User.id(parent);
+      expect(result).toBe('456');
+    });
+  });
+<%_ } -%>
+});

package/templates/clean-architecture/js/src/interfaces/routes/api.spec.js.ejs

@@ -0,0 +1,38 @@
+const request = require('supertest');
+const express = require('express');
+const router = require('@/interfaces/routes/api');
+
+const mockGetUsers = jest.fn().mockImplementation((req, res) => res.status(200).json([{ id: '1', name: 'John Doe' }]));
+const mockCreateUser = jest.fn().mockImplementation((req, res) => res.status(201).json({ id: '1', name: 'Test' }));
+
+jest.mock('@/interfaces/controllers/userController', () => {
+  return jest.fn().mockImplementation(() => ({
+    getUsers: (...args) => mockGetUsers(...args),
+    createUser: (...args) => mockCreateUser(...args)
+  }));
+});
+
+describe('ApiRoutes', () => {
+    let app;
+
+    beforeEach(() => {
+        app = express();
+        app.use(express.json());
+        app.use('/api', router);
+    });
+
+    it('POST /api/users should call controller.createUser', async () => {
+        await request(app)
+            .post('/api/users')
+            .send({ name: 'Test', email: 'test@example.com' });
+
+        expect(mockCreateUser).toHaveBeenCalledTimes(1);
+    });
+
+    it('GET /api/users should call controller.getUsers', async () => {
+        await request(app)
+            .get('/api/users');
+
+        expect(mockGetUsers).toHaveBeenCalledTimes(1);
+    });
+});

package/templates/clean-architecture/js/src/usecases/CreateUser.spec.js.ejs

@@ -0,0 +1,51 @@
+const CreateUser = require('@/usecases/CreateUser');
+const UserRepository = require('@/infrastructure/repositories/UserRepository');
+<%_ if (caching !== 'None') { -%>
+const cacheService = require('<% if (caching === "Redis") { %>@/infrastructure/caching/redisClient<% } else { %>@/infrastructure/caching/memoryCache<% } %>');
+<%_ } -%>
+
+jest.mock('@/infrastructure/repositories/UserRepository');
+<%_ if (caching !== 'None') { -%>
+jest.mock('<% if (caching === "Redis") { %>@/infrastructure/caching/redisClient<% } else { %>@/infrastructure/caching/memoryCache<% } %>', () => ({
+    get: jest.fn(),
+    set: jest.fn(),
+    del: jest.fn()
+}));
+<%_ } -%>
+
+describe('CreateUser UseCase', () => {
+    let createUser;
+    let mockUserRepository;
+
+    beforeEach(() => {
+        mockUserRepository = new UserRepository();
+        createUser = new CreateUser(mockUserRepository);
+        jest.clearAllMocks();
+    });
+
+    it('should create and save a new user', async () => {
+        const name = 'Test User';
+        const email = 'test@example.com';
+        const expectedResult = { id: 1, name, email };
+
+        mockUserRepository.save.mockResolvedValue(expectedResult);
+
+        const result = await createUser.execute(name, email);
+
+        expect(mockUserRepository.save).toHaveBeenCalledTimes(1);
+        const savedUser = mockUserRepository.save.mock.calls[0][0];
+        expect(savedUser.name).toBe(name);
+        expect(savedUser.email).toBe(email);
+        expect(result).toEqual(expectedResult);
+<%_ if (caching !== 'None') { -%>
+        expect(cacheService.del).toHaveBeenCalledWith('users:all');
+<%_ } -%>
+    });
+
+    it('should throw an error if repository fails', async () => {
+        const error = new Error('Database error');
+        mockUserRepository.save.mockRejectedValue(error);
+
+        await expect(createUser.execute('Test', 'test@test.com')).rejects.toThrow(error);
+    });
+});