nodejs-quickstart-structure 2.0.1 → 2.1.1

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

@@ -2,7 +2,22 @@ import { UserRepository } from '@/infrastructure/repositories/UserRepository';
 import UserModel from '@/infrastructure/database/models/User';
 
 // Mock DB Model Database Layer
-jest.mock('@/infrastructure/database/models/User');
+jest.mock('@/infrastructure/database/models/User', () => {
+  return {
+    __esModule: true,
+    default: {
+      create: jest.fn(),
+      findAll: jest.fn(),
+      findByPk: jest.fn(),
+      update: jest.fn(),
+      destroy: jest.fn(),
+      find: jest.fn(),
+      findById: jest.fn(),
+      findByIdAndUpdate: jest.fn(),
+      findByIdAndDelete: jest.fn(),
+    }
+  };
+});
 
 describe('UserRepository', () => {
     let userRepository: UserRepository;
@@ -15,7 +30,7 @@ describe('UserRepository', () => {
     describe('save', () => {
         it('should save and return a newly created user (Happy Path)', async () => {
             // Arrange
-            const payload = { id: '', name: 'TestUser', email: 'test@example.com' };
+            const payload = { id: '', name: 'TestUser', email: 'test@example.com', password: 'password123' };
 <%_ if (database === 'MongoDB') { -%>
             const mockDbRecord = { _id: { toString: () => '1' }, name: 'TestUser', email: 'test@example.com' };
             (UserModel.create as jest.Mock).mockResolvedValue(mockDbRecord);
@@ -34,7 +49,11 @@ describe('UserRepository', () => {
             expect(result.name).toEqual(payload.name)
 <%_ } else { -%>
             expect(result).toEqual({ id: '1', name: 'TestUser', email: 'test@example.com' });
-            expect(UserModel.create).toHaveBeenCalledWith({ name: payload.name, email: payload.email });
+            expect(UserModel.create).toHaveBeenCalledWith({ 
+                name: payload.name, 
+                email: payload.email,
+                <% if (auth.includes('JWT')) { %>password: payload.password<% } %>
+            });
 <%_ } -%>
         });
 
@@ -43,7 +62,7 @@ describe('UserRepository', () => {
             // Mocks do not naturally fail 
 <%_ } else { -%>
             // Arrange
-            const payload = { id: '', name: 'FailUser', email: 'fail@example.com' };
+            const payload = { id: '', name: 'FailUser', email: 'fail@example.com', password: 'password123' };
             const error = new Error('DB Connection Refused');
             (UserModel.create as jest.Mock).mockRejectedValue(error);
 
@@ -53,6 +72,49 @@ describe('UserRepository', () => {
         });
     });
 
+    describe('findById', () => {
+        it('should find and return a user by id (Happy Path)', async () => {
+            // Arrange
+            const id = '1';
+<%_ if (database === 'MongoDB') { -%>
+            const mockDbRecord = { _id: { toString: () => '1' }, name: 'TestUser', email: 'test@example.com' };
+            (UserModel.findById as jest.Mock).mockResolvedValue(mockDbRecord);
+<%_ } else if (database === 'None') { -%>
+            const mockDbRecord = { id: '1', name: 'TestUser', email: 'test@example.com' };
+            (UserModel.findByPk as jest.Mock).mockResolvedValue(mockDbRecord);
+<%_ } else { -%>
+            const mockDbRecord = { id: '1', name: 'TestUser', email: 'test@example.com' };
+            (UserModel.findByPk as jest.Mock).mockResolvedValue(mockDbRecord);
+<%_ } -%>
+
+            // Act
+            const result = await userRepository.findById(id);
+
+            // Assert
+            expect(result).toEqual({ id: '1', name: 'TestUser', email: 'test@example.com' });
+<%_ if (database === 'MongoDB') { -%>
+            expect(UserModel.findById).toHaveBeenCalledWith(id);
+<%_ } else { -%>
+            expect(UserModel.findByPk).toHaveBeenCalledWith(id);
+<%_ } -%>
+        });
+
+        it('should return null if user not found', async () => {
+            // Arrange
+<%_ if (database === 'MongoDB') { -%>
+            (UserModel.findById as jest.Mock).mockResolvedValue(null);
+<%_ } else { -%>
+            (UserModel.findByPk as jest.Mock).mockResolvedValue(null);
+<%_ } -%>
+
+            // Act
+            const result = await userRepository.findById('999');
+
+            // Assert
+            expect(result).toBeNull();
+        });
+    });
+
     describe('getUsers', () => {
         it('should return a list of mapped UserEntities (Happy Path)', async () => {
             // Arrange
@@ -88,17 +150,16 @@ describe('UserRepository', () => {
             // Arrange
             const id = '1';
             const data = { name: 'Updated' };
-            const expectedUser = { id: '1', name: 'Updated', email: 'test@example.com' };
-
 <%_ if (database === 'MongoDB') { -%>
             const mockDbRecord = { _id: { toString: () => '1' }, name: 'Updated', email: 'test@example.com' };
             (UserModel.findByIdAndUpdate as jest.Mock).mockResolvedValue(mockDbRecord);
-<%_ } else if (database === 'None') { -%>
-            (UserModel.update as jest.Mock).mockResolvedValue(expectedUser);
-<%_ } else { -%>
+<% } else if (database === 'None') { -%>
+            const mockDbRecord = { id: '1', name: 'Updated', email: 'test@example.com' };
+            (UserModel.update as jest.Mock).mockResolvedValue(mockDbRecord);
+<% } else { -%>
             const mockDbRecord = { id: '1', name: 'Updated', email: 'test@example.com', update: jest.fn().mockResolvedValue(true) };
             (UserModel.findByPk as jest.Mock).mockResolvedValue(mockDbRecord);
-<%_ } -%>
+<% } -%>
 
             // Act
             const result = await userRepository.update(id, data);

package/templates/clean-architecture/ts/src/infrastructure/repositories/userRepository.ts.ejs

@@ -4,17 +4,46 @@ import UserModel from '@/infrastructure/database/models/User';
 export class UserRepository {
     async save(user: UserEntity): Promise<UserEntity> {
 <%_ if (database === 'MongoDB') { -%>
-        const newUser = await UserModel.create({ name: user.name, email: user.email });
+        const newUser = await UserModel.create({ 
+            name: user.name, 
+            email: user.email, 
+            <% if (auth.includes('JWT')) { %>password: user.password<% } %> 
+        });
         return { id: newUser._id.toString(), name: newUser.name, email: newUser.email };
 <%_ } else if (database === 'None') { -%>
-        const newUser = await UserModel.create({ name: user.name, email: user.email });
+        const newUser = await UserModel.create({ 
+            name: user.name, 
+            email: user.email,
+            <% if (auth.includes('JWT')) { %>password: user.password<% } %>
+        });
         return { id: newUser.id, name: newUser.name, email: newUser.email };
 <%_ } else { -%>
-        const newUser = await UserModel.create({ name: user.name, email: user.email });
+        const newUser = await UserModel.create({ 
+            name: user.name, 
+            email: user.email,
+            <% if (auth.includes('JWT')) { %>password: user.password<% } %>
+        });
         return { id: newUser.id, name: newUser.name, email: newUser.email };
 <%_ } -%>
     }
 
+    async findById(id: number | string): Promise<UserEntity | null> {
+<%_ if (database === 'MongoDB') { -%>
+        const user = await UserModel.findById(id);
+        if (!user) return null;
+        return { id: user._id.toString(), name: user.name, email: user.email };
+<%_ } else if (database === 'None') { -%>
+        const user = await UserModel.findByPk(id);
+        if (!user) return null;
+        return { id: user.id, name: user.name, email: user.email };
+<%_ } else { -%>
+        const user = await UserModel.findByPk(id);
+        if (!user) return null;
+        return { id: user.id, name: user.name, email: user.email };
+<%_ } -%>
+    }
+
+
     async getUsers(): Promise<UserEntity[]> {
 <%_ if (database === 'MongoDB') { -%>
         const users = await UserModel.find();

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

@@ -2,7 +2,9 @@
 import { Request, Response, NextFunction } from 'express';
 import { HTTP_STATUS } from '@/utils/httpCodes';
 <% } -%>
+<% if (communication === 'GraphQL') { -%>
 import { ERROR_MESSAGES } from '@/utils/errorMessages';
+<% } -%>
 import { UserController } from '@/interfaces/controllers/userController';
 import CreateUser from '@/usecases/createUser';
 import GetAllUsers from '@/usecases/getAllUsers';
@@ -10,12 +12,26 @@ import UpdateUser from '@/usecases/updateUser';
 import DeleteUser from '@/usecases/deleteUser';
 
 // Mock dependencies
-jest.mock('@/infrastructure/repositories/UserRepository');
+jest.mock('@/infrastructure/repositories/UserRepository', () => ({
+    UserRepository: jest.fn().mockImplementation(() => ({
+        save: jest.fn(),
+        findById: jest.fn(),
+        getUsers: jest.fn(),
+        update: jest.fn(),
+        delete: jest.fn()
+    }))
+}));
 jest.mock('@/usecases/createUser');
 jest.mock('@/usecases/getAllUsers');
 jest.mock('@/usecases/updateUser');
 jest.mock('@/usecases/deleteUser');
-jest.mock('@/infrastructure/log/logger');
+jest.mock('@/usecases/getUserById');
+jest.mock('@/infrastructure/log/logger', () => ({
+    info: jest.fn(),
+    error: jest.fn(),
+    warn: jest.fn(),
+    debug: jest.fn()
+}));
 <%_ if (communication === 'Kafka') { -%>
 jest.mock('@/infrastructure/messaging/kafkaClient', () => ({
     kafkaService: {
@@ -43,7 +59,7 @@ describe('UserController (Clean Architecture)', () => {
 
     beforeEach(() => {
         // Clear all mocks
-        jest.resetAllMocks();
+        jest.clearAllMocks();
 
         userController = new UserController();
 
@@ -118,7 +134,7 @@ describe('UserController (Clean Architecture)', () => {
     describe('createUser', () => {
         it('should successfully create a new user (Happy Path)', async () => {
             // Arrange
-            const payload = { name: 'Alice', email: 'alice@example.com' };
+            const payload = { name: 'Alice', email: 'alice@example.com'<% if (auth.includes('JWT')) { %>, password: 'password123'<% } %> };
 <% if (communication === 'GraphQL') { -%>
             const dataArg = payload;
 <% } else { -%>
@@ -146,13 +162,31 @@ describe('UserController (Clean Architecture)', () => {
 
             expect(mockResponse.json).toHaveBeenCalledWith(expectedUser);
 <% } -%>
-            expect(mockCreateUserUseCase.execute).toHaveBeenCalledWith(payload.name, payload.email);
+<% if (auth.includes('JWT')) { -%>
+            expect(mockCreateUserUseCase.execute).toHaveBeenCalledWith(payload.name, payload.email, payload.password);
+<% } else { -%>
+            expect(mockCreateUserUseCase.execute).toHaveBeenCalledWith(payload.name, payload.email, undefined);
+<% } -%>
+        });
+
+<% if (auth.includes('JWT')) { %>
+        it('should fail to create a user when password is missing and JWT is enabled', async () => {
+            const payload = { name: 'Alice', email: 'alice@example.com' };
+<% if (communication === 'GraphQL') { -%>
+            await expect(userController.createUser(payload)).rejects.toThrow('Password is required');
+<% } else { -%>
+            mockRequest.body = payload;
+            await userController.createUser(mockRequest as Request, mockResponse as Response, mockNext);
+            expect(mockResponse.status).toHaveBeenCalledWith(HTTP_STATUS.BAD_REQUEST);
+            expect(mockResponse.json).toHaveBeenCalledWith({ error: 'Password is required' });
+<% } -%>
         });
+<% } %>
 
         it('should handle errors when creation fails (Error Handling)', async () => {
             // Arrange
             const error = new Error('Creation Error');
-            const payload = { name: 'Bob', email: 'bob@example.com' };
+            const payload = { name: 'Bob', email: 'bob@example.com'<% if (auth.includes('JWT')) { %>, password: 'password123'<% } %> };
 <% if (communication === 'GraphQL') { -%>
             const dataArg = payload;
 <% } else { -%>
@@ -173,7 +207,7 @@ describe('UserController (Clean Architecture)', () => {
         it('should handle non-Error objects in catch block when creation fails', async () => {
             // Arrange
             const error = 'Creation String Error';
-            const payload = { name: 'Bob', email: 'bob@example.com' };
+            const payload = { name: 'Bob', email: 'bob@example.com'<% if (auth.includes('JWT')) { %>, password: 'password123'<% } %> };
 <% if (communication === 'GraphQL') { -%>
             const dataArg = payload;
 <% } else { -%>
@@ -320,9 +354,9 @@ describe('UserController (Clean Architecture)', () => {
             const error = new Error('Database Error');
             mockCreateUserUseCase.execute.mockRejectedValue(error);
 <%_ if (communication === 'GraphQL') { -%>
-            await expect(userController.createUser({ name: 'Alice', email: 'alice@example.com' })).rejects.toThrow(error);
+            await expect(userController.createUser({ name: 'Alice', email: 'alice@example.com'<% if (auth.includes('JWT')) { %>, password: 'password123'<% } %> })).rejects.toThrow(error);
 <%_ } else { -%>
-            mockRequest.body = { name: 'Alice', email: 'alice@example.com' };
+            mockRequest.body = { name: 'Alice', email: 'alice@example.com'<% if (auth.includes('JWT')) { %>, password: 'password123'<% } %> };
             await userController.createUser(mockRequest as Request, mockResponse as Response, mockNext);
             expect(mockNext).toHaveBeenCalledWith(error);
 <%_ } -%>

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

@@ -6,17 +6,18 @@ import { HTTP_STATUS } from '@/utils/httpCodes';
 import { UserRepository } from '@/infrastructure/repositories/UserRepository';
 import CreateUser from '@/usecases/createUser';
 import GetAllUsers from '@/usecases/getAllUsers';
+import GetUserById from '@/usecases/getUserById';
 import UpdateUser from '@/usecases/updateUser';
 import DeleteUser from '@/usecases/deleteUser';
 import logger from '@/infrastructure/log/logger';
 <%_ if (communication === 'Kafka') { -%>
 import { kafkaService } from '@/infrastructure/messaging/kafkaClient';
 import { KAFKA_ACTIONS } from '@/utils/kafkaEvents';
-<%_ } -%>
-
+<%_ } %>
 export class UserController {
     private createUserUseCase: CreateUser;
     private getAllUsersUseCase: GetAllUsers;
+    private getUserByIdUseCase: GetUserById;
     private updateUserUseCase: UpdateUser;
     private deleteUserUseCase: DeleteUser;
 
@@ -24,24 +25,31 @@ export class UserController {
         const userRepository = new UserRepository();
         this.createUserUseCase = new CreateUser(userRepository);
         this.getAllUsersUseCase = new GetAllUsers(userRepository);
+        this.getUserByIdUseCase = new GetUserById(userRepository);
         this.updateUserUseCase = new UpdateUser(userRepository);
         this.deleteUserUseCase = new DeleteUser(userRepository);
     }
 
 <% if (communication === 'GraphQL') { -%>
-    async createUser(data: { name: string, email: string }) {
+    async createUser(data: { name: string, email: string, password?: string }) {
         try {
-            const { name, email } = data;
-            const user = await this.createUserUseCase.execute(name, email);
+            const { name, email, password } = data;
+            <% if (auth.includes('JWT')) { -%>
+            if (!password) {
+                throw new Error('Password is required');
+            }
+            <% } -%>
+            const user = await this.createUserUseCase.execute(name, email, password);
 <%_ if (communication === 'Kafka') { -%>
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            const userId = (user as any).id || (user as any)._id;
+            const rawUserForKafka = user as unknown as { id?: string | number; _id?: string | number; email: string };
+            const userId = rawUserForKafka.id || rawUserForKafka._id;
             await kafkaService.sendMessage('user-topic', JSON.stringify({
                 action: KAFKA_ACTIONS.USER_CREATED,
-                payload: { id: userId, email: user.email }
+                payload: { id: userId, email: rawUserForKafka.email }
             }), userId?.toString() || '');
 <%_ } -%>
-            return user;
+            const rawUser = user as unknown as { toJSON?: () => Record<string, unknown> };
+            return typeof rawUser.toJSON === 'function' ? rawUser.toJSON() : (user as unknown as Record<string, unknown>);
         } catch (error: unknown) {
             const message = error instanceof Error ? error.message : 'Unknown error';
             logger.error(`${ERROR_MESSAGES.CREATE_USER_ERROR}:`, message);
@@ -49,6 +57,18 @@ export class UserController {
         }
     }
 
+    async getUserById(id: string) {
+        try {
+            const user = await this.getUserByIdUseCase.execute(id);
+            if (!user) throw new Error(ERROR_MESSAGES.USER_NOT_FOUND);
+            return user;
+        } catch (error: unknown) {
+            const message = error instanceof Error ? error.message : 'Unknown error';
+            logger.error(`${ERROR_MESSAGES.FETCH_USER_ERROR}:`, message);
+            throw error;
+        }
+    }
+
     async getUsers() {
         try {
             const users = await this.getAllUsersUseCase.execute();
@@ -98,17 +118,24 @@ export class UserController {
 <% } else { -%>
     async createUser(req: Request, res: Response, next: NextFunction) {
         try {
-            const { name, email } = req.body || {};
-            const user = await this.createUserUseCase.execute(name, email);
+            const { name, email, password } = req.body || {};
+<% if (auth.includes('JWT')) { -%>
+            if (!password) {
+                return res.status(HTTP_STATUS.BAD_REQUEST).json({ error: 'Password is required' });
+            }
+<% } -%>
+            const user = await this.createUserUseCase.execute(name, email, password);
 <%_ if (communication === 'Kafka') { -%>
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            const userId = (user as any).id || (user as any)._id;
+            const rawUserForKafka = user as unknown as { id?: string | number; _id?: string | number; email: string };
+            const userId = rawUserForKafka.id || rawUserForKafka._id;
             await kafkaService.sendMessage('user-topic', JSON.stringify({
                 action: KAFKA_ACTIONS.USER_CREATED,
-                payload: { id: userId, email: user.email }
+                payload: { id: userId, email: rawUserForKafka.email }
             }), userId?.toString() || '');
 <%_ } -%>
-            res.status(HTTP_STATUS.CREATED).json(user);
+            const rawUser = user as unknown as { toJSON?: () => Record<string, unknown> };
+            const userJson = typeof rawUser.toJSON === 'function' ? rawUser.toJSON() : (user as unknown as Record<string, unknown>);
+            res.status(HTTP_STATUS.CREATED).json(userJson);
         } catch (error: unknown) {
             const message = error instanceof Error ? error.message : 'Unknown error';
             logger.error(`${ERROR_MESSAGES.CREATE_USER_ERROR}:`, message);
@@ -116,6 +143,21 @@ export class UserController {
         }
     }
 
+    async getUserById(req: Request, res: Response, next: NextFunction) {
+        try {
+            const { id } = req.params;
+            const user = await this.getUserByIdUseCase.execute(id);
+            if (!user) {
+                return res.status(HTTP_STATUS.NOT_FOUND).json({ error: ERROR_MESSAGES.USER_NOT_FOUND });
+            }
+            res.json(user);
+        } catch (error: unknown) {
+            const message = error instanceof Error ? error.message : 'Unknown error';
+            logger.error(`${ERROR_MESSAGES.FETCH_USER_ERROR}:`, message);
+            next(error);
+        }
+    }
+
     async getUsers(req: Request, res: Response, next: NextFunction) {
         try {
             const users = await this.getAllUsersUseCase.execute();

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

@@ -1,32 +1,65 @@
-import { gqlContext } from '@/interfaces/graphql/context';
 import { Request } from 'express';
-import { resolvers } from '@/interfaces/graphql/resolvers';
-import { typeDefs } from '@/interfaces/graphql/typeDefs';
+<% if (auth.includes('JWT')) { %>
+import { JwtService } from '@/infrastructure/auth/jwtService';
+jest.mock('@/infrastructure/auth/jwtService', () => ({
+    JwtService: {
+        generateToken: jest.fn(),
+        verifyToken: jest.fn(),
+        generateRefreshToken: jest.fn(),
+        verifyRefreshToken: jest.fn(),
+        decodeToken: jest.fn(),
+    }
+}));
+<% } %>
+import { gqlContext } from '@/interfaces/graphql/context';
 
-jest.mock('@/infrastructure/repositories/UserRepository');
+jest.mock('@/infrastructure/repositories/UserRepository', () => ({
+    UserRepository: jest.fn().mockImplementation(() => ({
+        save: jest.fn(),
+        findById: jest.fn(),
+        getUsers: jest.fn(),
+        update: jest.fn(),
+        delete: jest.fn()
+    }))
+}));
 
 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;
+    afterEach(() => {
+        jest.clearAllMocks();
+    });
+
+    it('should return context with user when authorization header is present and valid', async () => {
+        <% if (auth.includes('JWT')) { %>
+        const mockUser = { id: '1', email: 'test@test.com' };
+        (JwtService.verifyToken as jest.Mock).mockReturnValue(mockUser);
+        const mockRequest = {
+            headers: {
+                authorization: 'Bearer valid-token',
+            },
+        } as Request;
 
-    const context = await gqlContext({ req: mockRequest });
-    expect(context.token).toBe('Bearer token123');
-  });
+        const context = await gqlContext({ req: mockRequest });
+        expect(context.user).toEqual(mockUser);
+        expect(JwtService.verifyToken).toHaveBeenCalledWith('valid-token');
+        <% } else { %>
+        const mockRequest = {
+            headers: {
+                authorization: 'Bearer token123',
+            },
+        } as Request;
+        const context = await gqlContext({ req: mockRequest });
+        expect(context.user).toBeUndefined();
+        <% } %>
+        expect(context.userRepository).toBeDefined();
+    });
 
-  it('should return context with empty token when authorization header is missing', async () => {
-    const mockRequest = {
-      headers: {},
-    } as Request;
+    it('should return context without user when authorization header is missing', async () => {
+        const mockRequest = {
+            headers: {},
+        } as Request;
 
-    const context = await gqlContext({ req: mockRequest });
-    expect(context.token).toBe('');
-  });
+        const context = await gqlContext({ req: mockRequest });
+        expect(context.user).toBeUndefined();
+        expect(context.userRepository).toBeDefined();
+    });
 });

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

@@ -1,17 +1,23 @@
 import { Request } from 'express';
 import { UserRepository } from '@/infrastructure/repositories/UserRepository';
+<% if (auth.includes('JWT')) { %>import { JwtService } from '@/infrastructure/auth/jwtService';<% } %>
 
 export interface MyContext {
-  token?: string;
   userRepository: UserRepository;
+  user?: unknown;
 }
 
-export const gqlContext = async ({ req }: { req: Request }): Promise<MyContext> => {
-  const token = req.headers.authorization || '';
+export const gqlContext = async ({ req: <% if (auth.includes('JWT')) { %>req<% } else { %>_req<% } %> }: { req: Request }): Promise<MyContext> => {
   const userRepository = new UserRepository();
-  
-  return { 
-    token, 
-    userRepository 
-  };
+  const context: MyContext = { userRepository };
+  <% if (auth.includes('JWT')) { %>
+  const authHeader = req.headers.authorization || '';
+  if (authHeader.startsWith('Bearer ')) {
+    const token = authHeader.split(' ')[1];
+    const user = JwtService.verifyToken(token);
+    if (user) {
+      context.user = user;
+    }
+  }<% } %>
+  return context;
 };

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

@@ -15,40 +15,63 @@ jest.mock('@/interfaces/controllers/userController', () => {
 });
 
 describe('User Resolvers', () => {
+  const mockContext = { 
+    userRepository: {} as any,
+    <% if (auth.includes('JWT')) { %>user: { id: 'admin', email: 'admin@test.com' }<% } %>
+  };
+
   afterEach(() => {
     jest.clearAllMocks();
   });
 
   describe('Query.getAllUsers', () => {
-    it('should return all users', async () => {
-      const result = await userResolvers.Query.getAllUsers();
+    it('should return all users when authorized', async () => {
+      const result = await userResolvers.Query.getAllUsers(null, null, mockContext as any);
       expect(result).toEqual([{ id: '1', name: 'John Doe', email: 'john@example.com' }]);
       expect(mockGetUsers).toHaveBeenCalledTimes(1);
     });
+
+    <% if (auth.includes('JWT')) { %>
+    it('should throw error when unauthorized', async () => {
+      await expect(userResolvers.Query.getAllUsers(null, null, { userRepository: {} } as any)).rejects.toThrow('Unauthorized');
+    });
+    <% } %>
   });
 
   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' });
+    it('should create and return a new user (Public)', async () => {
+      const payload = { name: 'Jane', email: 'jane@example.com'<% if (auth.some(a => a !=='None')) { %>, password: 'password123'<% } %> };
+      const result = await userResolvers.Mutation.createUser(null, payload);
       expect(result).toEqual({ id: '1', name: 'Jane', email: 'jane@example.com' });
-      expect(mockCreateUser).toHaveBeenCalledWith({ name: 'Jane', email: 'jane@example.com' });
-      expect(mockCreateUser).toHaveBeenCalledTimes(1);
+      expect(mockCreateUser).toHaveBeenCalledWith(payload);
     });
   });
 
   describe('Mutation.updateUser', () => {
-    it('should update and return the user', async () => {
+    it('should update and return the user when authorized', async () => {
       const payload = { name: 'Updated' };
-      const result = await userResolvers.Mutation.updateUser(null, { id: '1', ...payload });
+      const result = await userResolvers.Mutation.updateUser(null, { id: '1', ...payload }, mockContext as any);
       expect(result).toMatchObject(payload);
     });
+
+    <% if (auth.includes('JWT')) { %>
+    it('should throw error when unauthorized', async () => {
+      await expect(userResolvers.Mutation.updateUser(null, { id: '1', name: 'N' }, { userRepository: {} } as any)).rejects.toThrow('Unauthorized');
+    });
+    <% } %>
   });
 
   describe('Mutation.deleteUser', () => {
-    it('should delete and return true', async () => {
-      const result = await userResolvers.Mutation.deleteUser(null, { id: '1' });
+    it('should delete and return true when authorized', async () => {
+      const result = await userResolvers.Mutation.deleteUser(null, { id: '1' }, mockContext as any);
       expect(result).toBe(true);
     });
+
+    <% if (auth.includes('JWT')) { %>
+    it('should throw error when unauthorized', async () => {
+      await expect(userResolvers.Mutation.deleteUser(null, { id: '1' }, { userRepository: {} } as any)).rejects.toThrow('Unauthorized');
+    });
+    <% } %>
   });
 <%_ if (database === 'MongoDB') { -%>
   describe('User.id', () => {

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

@@ -1,24 +1,34 @@
 import { UserController } from '@/interfaces/controllers/userController';
+import { MyContext } from '@/interfaces/graphql/context';
 
 const userController = new UserController();
 
 export const userResolvers = {
   Query: {
-    getAllUsers: async () => {
+    getAllUsers: async (_: unknown, __: unknown, <% if (auth.includes('JWT')) { %>context<% } else { %>_context<% } %>: MyContext) => {
+      <%_ if (auth.includes('JWT')) { -%>
+      if (!context.user) throw new Error('Unauthorized');
+      <% } %>
       const users = await userController.getUsers();
       return users;
     }
   },
   Mutation: {
-    createUser: async (_: unknown, { name, email }: { name: string, email: string }) => {
-      const user = await userController.createUser({ name, email });
+    createUser: async (_: unknown, { name, email<% if (auth.some(a => a !=='None')) { %>, password<% } %> }: { name: string, email: string<% if (auth.some(a => a !=='None')) { %>, password: string<% } %> }) => {
+      const user = await userController.createUser({ name, email<% if (auth.some(a => a !=='None')) { %>, password<% } %> });
       return user;
     },
-    updateUser: async (_: unknown, { id, name, email }: { id: string, name?: string, email?: string }) => {
+    updateUser: async (_: unknown, { id, name, email }: { id: string, name?: string, email?: string }, <% if (auth.includes('JWT')) { %>context<% } else { %>_context<% } %>: MyContext) => {
+      <%_ if (auth.includes('JWT')) { -%>
+      if (!context.user) throw new Error('Unauthorized');
+      <% } %>
       const user = await userController.updateUser(id, { name, email });
       return user;
     },
-    deleteUser: async (_: unknown, { id }: { id: string }) => {
+    deleteUser: async (_: unknown, { id }: { id: string }, <% if (auth.includes('JWT')) { %>context<% } else { %>_context<% } %>: MyContext) => {
+      <%_ if (auth.includes('JWT')) { -%>
+      if (!context.user) throw new Error('Unauthorized');
+      <% } %>
       const result = await userController.deleteUser(id);
       return result;
     }