nodejs-structure-cli 1.0.0

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

@@ -0,0 +1,208 @@
+import { ERROR_MESSAGES } from '@/utils/errorMessages';
+<% if (communication !== 'GraphQL') { -%>
+import { Request, Response, NextFunction } from 'express';
+import { HTTP_STATUS } from '@/utils/httpCodes';
+<% } -%>
+import { UserRepository } from '@/infrastructure/repositories/UserRepository';
+import CreateUser from '@/usecases/createUser';
+import GetAllUsers from '@/usecases/getAllUsers';
+import UpdateUser from '@/usecases/updateUser';
+import DeleteUser from '@/usecases/deleteUser';
+import logger from '@/infrastructure/log/logger';
+import { kafkaService } from '@/infrastructure/messaging/kafkaClient';
+import { KAFKA_ACTIONS } from '@/utils/kafkaEvents';
+<%_ } -%>
+<%_ if (auth && auth !== 'None') { _%>
+import * as bcrypt from 'bcryptjs';
+<%_ } _%>
+
+export class UserController {
+    private createUserUseCase: CreateUser;
+    private getAllUsersUseCase: GetAllUsers;
+    private updateUserUseCase: UpdateUser;
+    private deleteUserUseCase: DeleteUser;
+
+    constructor() {
+        const userRepository = new UserRepository();
+        this.createUserUseCase = new CreateUser(userRepository);
+        this.getAllUsersUseCase = new GetAllUsers(userRepository);
+        this.updateUserUseCase = new UpdateUser(userRepository);
+        this.deleteUserUseCase = new DeleteUser(userRepository);
+    }
+
+<% if (communication === 'GraphQL') { -%>
+    async createUser(data: { name: string, email: string, password?: string, imageUrl?: string }) {
+        try {
+            const { name, email, password, imageUrl } = data;
+            let hashedPassword = password;
+            <% if (auth && auth !== 'None') { %>
+            if (password) {
+                hashedPassword = await bcrypt.hash(password, 10);
+            }
+            <% } %>
+
+            const user = await this.createUserUseCase.execute(name, email<% if (auth && auth !== 'None') { %>, hashedPassword <% } %> <% if (includeMulter) { %>, imageUrl<% } %>);
+<%_ if (communication === 'Kafka') { -%>
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const userId = (user as any).id || (user as any)._id;
+            await kafkaService.sendMessage('user-topic', JSON.stringify({
+                action: KAFKA_ACTIONS.USER_CREATED,
+                payload: { id: userId, email: user.email }
+            }), userId?.toString() || '');
+<%_ } -%>
+            return user;
+        } catch (error: unknown) {
+            const message = error instanceof Error ? error.message : 'Unknown error';
+            logger.error(`${ERROR_MESSAGES.CREATE_USER_ERROR}:`, message);
+            throw error;
+        }
+    }
+
+    async getUsers() {
+        try {
+            const users = await this.getAllUsersUseCase.execute();
+            return users;
+        } catch (error: unknown) {
+            const message = error instanceof Error ? error.message : 'Unknown error';
+            logger.error(`${ERROR_MESSAGES.FETCH_USERS_ERROR}:`, message);
+            throw error;
+        }
+    }
+
+    async updateUser(id: string, data: { name?: string, email?: string }) {
+        try {
+            const user = await this.updateUserUseCase.execute(id, data);
+            if (!user) throw new Error(ERROR_MESSAGES.USER_NOT_FOUND);
+<%_ if (communication === 'Kafka') { -%>
+            await kafkaService.sendMessage('user-topic', JSON.stringify({
+                action: KAFKA_ACTIONS.USER_UPDATED,
+                payload: { id, email: user.email }
+            }), id);
+<%_ } -%>
+            return user;
+        } catch (error: unknown) {
+            const message = error instanceof Error ? error.message : 'Unknown error';
+            logger.error(`${ERROR_MESSAGES.UPDATE_USER_ERROR}:`, message);
+            throw error;
+        }
+    }
+
+    async deleteUser(id: string) {
+        try {
+            const deleted = await this.deleteUserUseCase.execute(id);
+            if (!deleted) throw new Error(ERROR_MESSAGES.USER_NOT_FOUND);
+<%_ if (communication === 'Kafka') { -%>
+            await kafkaService.sendMessage('user-topic', JSON.stringify({
+                action: KAFKA_ACTIONS.USER_DELETED,
+                payload: { id }
+            }), id);
+<%_ } -%>
+            return true;
+        } catch (error: unknown) {
+            const message = error instanceof Error ? error.message : 'Unknown error';
+            logger.error(`${ERROR_MESSAGES.DELETE_USER_ERROR}:`, message);
+            throw error;
+        }
+    }
+<% } else { -%>
+    async createUser(req: Request, res: Response, next: NextFunction) {
+        try {
+            const { name, email, password } = req.body || {};
+            let hashedPassword = password;
+            <% if (auth && auth !== 'None') { %>
+            if (password) {
+                hashedPassword = await bcrypt.hash(password, 10);
+            }
+            <% } %>
+            let imageUrl: string | undefined = undefined;
+            <% if (includeMulter) { %>
+            if (req.file) {
+                imageUrl = `/uploads/${req.file.filename}`;
+            }
+            <% } %>
+
+            const user = await this.createUserUseCase.execute(name, email <% if (auth && auth !== 'None') { %>, hashedPassword <% } %> <% if (includeMulter) { %>, imageUrl<% } %>);
+<%_ if (communication === 'Kafka') { -%>
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const userId = (user as any).id || (user as any)._id;
+            await kafkaService.sendMessage('user-topic', JSON.stringify({
+                action: KAFKA_ACTIONS.USER_CREATED,
+                payload: { id: userId, email: user.email }
+            }), userId?.toString() || '');
+<%_ } -%>
+            res.status(HTTP_STATUS.CREATED).json(user);
+        } catch (error: unknown) {
+            const message = error instanceof Error ? error.message : 'Unknown error';
+            logger.error(`${ERROR_MESSAGES.CREATE_USER_ERROR}:`, message);
+            next(error);
+        }
+    }
+
+    async getUsers(req: Request, res: Response, next: NextFunction) {
+        try {
+            const users = await this.getAllUsersUseCase.execute();
+            res.json(users);
+        } catch (error: unknown) {
+            const message = error instanceof Error ? error.message : 'Unknown error';
+            logger.error(`${ERROR_MESSAGES.FETCH_USERS_ERROR}:`, message);
+            next(error);
+        }
+    }
+
+    async updateUser(req: Request, res: Response, next: NextFunction) {
+        try {
+            const { id } = req.params;
+            const { name, email, password } = req.body || {};
+            const updateData: any = { name, email };
+            <% if (auth && auth !== 'None') { %>
+            if (password) {
+                updateData.password = await bcrypt.hash(password, 10);
+            }
+            <% } %>
+
+            <% if (includeMulter) { %>
+            if (req.file) {
+                updateData.imageUrl = `/uploads/${req.file.filename}`;
+            }
+            <% } %>
+
+            const user = await this.updateUserUseCase.execute(id, updateData);
+            if (!user) {
+                return res.status(HTTP_STATUS.NOT_FOUND).json({ error: ERROR_MESSAGES.USER_NOT_FOUND });
+            }
+<%_ if (communication === 'Kafka') { -%>
+            await kafkaService.sendMessage('user-topic', JSON.stringify({
+                action: KAFKA_ACTIONS.USER_UPDATED,
+                payload: { id, email: user.email }
+            }), id);
+<%_ } -%>
+            res.json(user);
+        } catch (error: unknown) {
+            const message = error instanceof Error ? error.message : 'Unknown error';
+            logger.error(`${ERROR_MESSAGES.UPDATE_USER_ERROR}:`, message);
+            next(error);
+        }
+    }
+
+    async deleteUser(req: Request, res: Response, next: NextFunction) {
+        try {
+            const { id } = req.params;
+            const deleted = await this.deleteUserUseCase.execute(id);
+            if (!deleted) {
+                return res.status(HTTP_STATUS.NOT_FOUND).json({ error: ERROR_MESSAGES.USER_NOT_FOUND });
+            }
+<%_ if (communication === 'Kafka') { -%>
+            await kafkaService.sendMessage('user-topic', JSON.stringify({
+                action: KAFKA_ACTIONS.USER_DELETED,
+                payload: { id }
+            }), id);
+<%_ } -%>
+            res.status(HTTP_STATUS.OK).json({ message: 'User deleted successfully' });
+        } catch (error: unknown) {
+            const message = error instanceof Error ? error.message : 'Unknown error';
+            logger.error(`${ERROR_MESSAGES.DELETE_USER_ERROR}:`, message);
+            next(error);
+        }
+    }
+<% } -%>
+}

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

@@ -0,0 +1,32 @@
+import { gqlContext } from '@/interfaces/graphql/context';
+import { Request } from 'express';
+import { resolvers } from '@/interfaces/graphql/resolvers';
+import { typeDefs } from '@/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',
+      },
+    } as Request;
+
+    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: {},
+    } as Request;
+
+    const context = await gqlContext({ req: mockRequest });
+    expect(context.token).toBe('');
+  });
+});

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

@@ -0,0 +1,17 @@
+import { Request } from 'express';
+import { UserRepository } from '@/infrastructure/repositories/UserRepository';
+
+export interface MyContext {
+  token?: string;
+  userRepository: UserRepository;
+}
+
+export const gqlContext = async ({ req }: { req: Request }): Promise<MyContext> => {
+  const token = req.headers.authorization || '';
+  const userRepository = new UserRepository();
+  
+  return { 
+    token, 
+    userRepository 
+  };
+};

package/templates/clean-architecture/ts/src/interfaces/graphql/index.ts.ejs

@@ -0,0 +1,3 @@
+export { typeDefs } from '@/interfaces/graphql/typeDefs';
+export { resolvers } from '@/interfaces/graphql/resolvers';
+export { gqlContext, MyContext } from '@/interfaces/graphql/context';

package/templates/clean-architecture/ts/src/interfaces/graphql/resolvers/index.ts.ejs

@@ -0,0 +1,4 @@
+import { mergeResolvers } from '@graphql-tools/merge';
+import { userResolvers } from '@/interfaces/graphql/resolvers/user.resolvers';
+
+export const resolvers = mergeResolvers([userResolvers]);

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

@@ -0,0 +1,68 @@
+import { userResolvers } from '@/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 {
+    UserController: jest.fn().mockImplementation(() => ({
+      getUsers: (...args: unknown[]) => mockGetUsers(...args),
+      createUser: (...args: unknown[]) => mockCreateUser(...args),
+      updateUser: jest.fn().mockImplementation((id, data) => Promise.resolve({ id, ...data })),
+      deleteUser: jest.fn().mockImplementation(() => Promise.resolve(true))
+    }))
+  };
+});
+
+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);
+    });
+  });
+
+  describe('Mutation.updateUser', () => {
+    it('should update and return the user', async () => {
+      const payload = { name: 'Updated' };
+      const result = await userResolvers.Mutation.updateUser(null, { id: '1', ...payload });
+      expect(result).toMatchObject(payload);
+    });
+  });
+
+  describe('Mutation.deleteUser', () => {
+    it('should delete and return true', async () => {
+      const result = await userResolvers.Mutation.deleteUser(null, { id: '1' });
+      expect(result).toBe(true);
+    });
+  });
+<%_ if (database === 'MongoDB') { -%>
+  describe('User.id', () => {
+    it('should return parent.id if available', () => {
+      const parent = { id: '123' };
+      const result = userResolvers.User.id(parent as { id?: string; _id?: unknown });
+      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 as { id?: string; _id?: unknown });
+      expect(result).toBe('456');
+    });
+  });
+<%_ } -%>
+});

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

@@ -0,0 +1,29 @@
+import { UserController } from '@/interfaces/controllers/userController';
+
+const userController = new UserController();
+
+export const userResolvers = {
+  Query: {
+    getAllUsers: async () => {
+      const users = await userController.getUsers();
+      return users;
+    }
+  },
+  Mutation: {
+    createUser: async (_: unknown, { name, email }: { name: string, email: string }) => {
+      const user = await userController.createUser({ name, email });
+      return user;
+    },
+    updateUser: async (_: unknown, { id, name, email }: { id: string, name?: string, email?: string }) => {
+      const user = await userController.updateUser(id, { name, email });
+      return user;
+    },
+    deleteUser: async (_: unknown, { id }: { id: string }) => {
+      const result = await userController.deleteUser(id);
+      return result;
+    }
+  }<%_ if (database === 'MongoDB') { -%>,
+  User: {
+    id: (parent: { id?: string; _id?: unknown }) => parent.id || parent._id
+  }<%_ } %>
+};

package/templates/clean-architecture/ts/src/interfaces/graphql/typeDefs/index.ts.ejs

@@ -0,0 +1,4 @@
+import { mergeTypeDefs } from '@graphql-tools/merge';
+import { userTypes } from './user.types';
+
+export const typeDefs = mergeTypeDefs([userTypes]);

package/templates/clean-architecture/ts/src/interfaces/graphql/typeDefs/user.types.ts.ejs

@@ -0,0 +1,17 @@
+export const userTypes = `#graphql
+  type User {
+    id: ID!
+    name: String!
+    email: String!
+  }
+
+  type Query {
+    getAllUsers: [User]
+  }
+
+  type Mutation {
+    createUser(name: String!, email: String!): User
+    updateUser(id: ID!, name: String, email: String): User
+    deleteUser(id: ID!): Boolean
+  }
+`;

package/templates/clean-architecture/ts/src/interfaces/routes/userRoutes.spec.ts.ejs

@@ -0,0 +1,40 @@
+import request from 'supertest';
+import express, { Express } from 'express';
+import router from '@/interfaces/routes/userRoutes';
+
+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 {
+    UserController: jest.fn().mockImplementation(() => ({
+      getUsers: (...args: unknown[]) => mockGetUsers(...args),
+      createUser: (...args: unknown[]) => mockCreateUser(...args)
+    }))
+  };
+});
+
+describe('UserRoutes', () => {
+    let app: Express;
+
+    beforeEach(() => {
+        app = express();
+        app.use(express.json());
+        app.use('/users', router);
+    });
+
+    it('POST /users should call controller.createUser', async () => {
+        await request(app)
+            .post('/users')
+            .send({ name: 'Test', email: 'test@example.com' });
+
+        expect(mockCreateUser).toHaveBeenCalledTimes(1);
+    });
+
+    it('GET /users should call controller.getUsers', async () => {
+        await request(app)
+            .get('/users');
+
+        expect(mockGetUsers).toHaveBeenCalledTimes(1);
+    });
+});

package/templates/clean-architecture/ts/src/interfaces/routes/userRoutes.ts.ejs

@@ -0,0 +1,18 @@
+import { Router, Request, Response, NextFunction } from 'express';
+import { UserController } from '@/interfaces/controllers/userController';
+<% if (auth && auth !== 'None') { %>import { authMiddleware } from '@/middleware/auth';<% } %>
+<% if (includeMulter) { %>import { upload } from '@/middleware/upload';<% } %>
+<% if (auth && auth !== 'None') { %>import authRoutes from './authRoutes';<% } %>
+
+const router = Router();
+const userController = new UserController();
+
+<% if (auth && auth !== 'None') { %>router.use('/auth', authRoutes);<% } %>
+
+router.get('/', (req: Request, res: Response, next: NextFunction) => userController.getUsers(req, res, next));
+router.post('/', <% if (includeMulter) { %>upload.single('image'), <% } %>(req: Request, res: Response, next: NextFunction) => userController.createUser(req, res, next));
+router.patch('/:id', <% if (includeMulter) { %>upload.single('image'), <% } %>(req: Request, res: Response, next: NextFunction) => userController.updateUser(req, res, next));
+router.delete('/:id', (req: Request, res: Response, next: NextFunction) => userController.deleteUser(req, res, next));
+
+export default router;
+

package/templates/clean-architecture/ts/src/usecases/createUser.spec.ts.ejs

@@ -0,0 +1,51 @@
+import CreateUser from '@/usecases/createUser';
+import { UserRepository } from '@/infrastructure/repositories/UserRepository';
+<%_ if (caching !== 'None') { -%>
+import cacheService from '<% 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: CreateUser;
+    let mockUserRepository: jest.Mocked<UserRepository>;
+
+    beforeEach(() => {
+        mockUserRepository = new UserRepository() as jest.Mocked<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 as any);
+
+        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);
+    });
+});

package/templates/clean-architecture/ts/src/usecases/createUser.ts.ejs

@@ -0,0 +1,11 @@
+import User from '../domain/user';
+import { UserRepository } from '../infrastructure/repositories/UserRepository';
+
+export default class CreateUser {
+    constructor(private userRepository: UserRepository) {}
+
+    async execute(name: string, email: string<% if (auth && auth !== 'None') { %>, password?: string<% } %><% if (includeMulter) { %>, imageUrl?: string<% } %>): Promise<User> {
+        const user = new User(null, name, email<% if (auth && auth !== 'None') { %>, password<% } %><% if (includeMulter) { %>, imageUrl<% } %>);
+        return await this.userRepository.save(user);
+    }
+}

package/templates/clean-architecture/ts/src/usecases/deleteUser.spec.ts.ejs

@@ -0,0 +1,47 @@
+import DeleteUser from '@/usecases/deleteUser';
+import { UserRepository } from '@/infrastructure/repositories/UserRepository';
+<%_ if (caching !== 'None') { -%>
+import cacheService from '<% 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('DeleteUser UseCase', () => {
+    let deleteUser: DeleteUser;
+    let mockUserRepository: jest.Mocked<UserRepository>;
+
+    beforeEach(() => {
+        mockUserRepository = new UserRepository() as jest.Mocked<UserRepository>;
+        deleteUser = new DeleteUser(mockUserRepository);
+        jest.clearAllMocks();
+    });
+
+    it('should delete and return the user', async () => {
+        const id = 1;
+        const expectedResult = { id, name: 'Deleted User', email: 'test@test.com' };
+
+        mockUserRepository.delete.mockResolvedValue(expectedResult as any);
+
+        const result = await deleteUser.execute(id);
+
+        expect(mockUserRepository.delete).toHaveBeenCalledWith(id);
+        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.delete.mockRejectedValue(error);
+
+        await expect(deleteUser.execute(1)).rejects.toThrow(error);
+    });
+});

package/templates/clean-architecture/ts/src/usecases/deleteUser.ts

@@ -0,0 +1,9 @@
+import { UserRepository } from '@/infrastructure/repositories/UserRepository';
+
+export default class DeleteUser {
+    constructor(private userRepository: UserRepository) {}
+
+    async execute(id: number | string) {
+        return this.userRepository.delete(id);
+    }
+}

package/templates/clean-architecture/ts/src/usecases/getAllUsers.spec.ts.ejs

@@ -0,0 +1,63 @@
+import GetAllUsers from '@/usecases/getAllUsers';
+import { UserRepository } from '@/infrastructure/repositories/UserRepository';
+<%_ if (caching !== 'None') { -%>
+import cacheService from '<% 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('GetAllUsers UseCase', () => {
+    let getAllUsers: GetAllUsers;
+    let mockUserRepository: jest.Mocked<UserRepository>;
+
+    beforeEach(() => {
+        mockUserRepository = new UserRepository() as jest.Mocked<UserRepository>;
+        getAllUsers = new GetAllUsers(mockUserRepository);
+        jest.clearAllMocks();
+    });
+
+    it('should retrieve all users', async () => {
+        const expectedUsers = [{ id: 1, name: 'Alice', email: 'alice@example.com' }];
+        mockUserRepository.getUsers.mockResolvedValue(expectedUsers as any);
+<%_ if (caching !== 'None') { -%>
+        (cacheService.get as jest.Mock).mockResolvedValue(null);
+<%_ } %>
+
+        const result = await getAllUsers.execute();
+
+        expect(mockUserRepository.getUsers).toHaveBeenCalledTimes(1);
+        expect(result).toEqual(expectedUsers);
+<%_ if (caching !== 'None') { -%>
+        expect(cacheService.set).toHaveBeenCalled();
+<%_ } %>
+    });
+
+<%_ if (caching !== 'None') { -%>
+    it('should return from cache if available', async () => {
+        const cachedUsers = [{ id: 1, name: 'Cached', email: 'cached@example.com' }];
+        (cacheService.get as jest.Mock).mockResolvedValue(cachedUsers);
+
+        const result = await getAllUsers.execute();
+
+        expect(mockUserRepository.getUsers).not.toHaveBeenCalled();
+        expect(result).toEqual(cachedUsers);
+    });
+<%_ } -%>
+
+    it('should throw an error if repository fails', async () => {
+        const error = new Error('Database error');
+        mockUserRepository.getUsers.mockRejectedValue(error);
+<%_ if (caching !== 'None') { -%>
+        (cacheService.get as jest.Mock).mockResolvedValue(null);
+<%_ } -%>
+
+        await expect(getAllUsers.execute()).rejects.toThrow(error);
+    });
+});

package/templates/clean-architecture/ts/src/usecases/getAllUsers.ts

@@ -0,0 +1,10 @@
+import { UserRepository } from '@/infrastructure/repositories/UserRepository';
+
+export default class GetAllUsers {
+    constructor(private userRepository: UserRepository) {}
+
+    async execute() {
+        return this.userRepository.getUsers();
+    }
+}
+