nodejs-quickstart-structure 2.0.0 → 2.1.0

package/lib/prompts.js

@@ -74,7 +74,7 @@ export const getProjectDetails = async (options = {}) => {
             type: 'select',
             name: 'ciProvider',
             message: 'Select CI/CD Provider:',
-            choices: ['None', 'GitHub Actions', 'Jenkins', 'GitLab CI'],
+            choices: ['None', 'GitHub Actions', 'Jenkins', 'GitLab CI', 'CircleCI', 'Bitbucket Pipelines'],
             default: 'None',
             when: !options.ciProvider
         },
@@ -85,6 +85,25 @@ export const getProjectDetails = async (options = {}) => {
             choices: ['No', 'Yes'],
             default: "No",
             when: (answers) => options.includeSecurity === undefined && (options.ciProvider || answers.ciProvider) !== 'None'
+        },
+        {
+            type: 'select',
+            name: 'advancedOptions',
+            message: 'Enable Advanced Options (Authentication, etc.)?',
+            choices: ['No', 'Yes'],
+            default: 'No',
+            when: options.advancedOptions === undefined
+        },
+        {
+            type: 'select',
+            name: 'auth',
+            message: 'Select Authentication Mode:',
+            choices: ['None', 'JWT'],
+            default: 'None',
+            when: (answers) => {
+                const advanced = options.advancedOptions !== undefined ? options.advancedOptions : answers.advancedOptions;
+                return (advanced === 'Yes' || advanced === true) && !options.auth;
+            }
         }
     ];
 
@@ -96,5 +115,25 @@ export const getProjectDetails = async (options = {}) => {
         result.includeSecurity = result.includeSecurity === 'Yes';
     }
 
+    if (typeof result.advancedOptions === 'string') {
+        result.advancedOptions = result.advancedOptions === 'Yes';
+    }
+
+    // Normalize auth to array if it's a string from the list prompt
+    if (typeof result.auth === 'string') {
+        result.auth = [result.auth];
+    }
+
+    // Default auth if not provided
+    if (!result.auth) {
+        result.auth = ['None'];
+    }
+
+    // Filter out 'None' if 'JWT' is selected
+    if (result.auth.includes('JWT')) {
+        result.auth = result.auth.filter(a => a !== 'None');
+    }
+
     return result;
 };
+

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nodejs-quickstart-structure",
-  "version": "2.0.0",
+  "version": "2.1.0",
   "type": "module",
   "description": "The ultimate nodejs quickstart structure CLI to scaffold Node.js microservices with MVC or Clean Architecture",
   "main": "bin/index.js",
@@ -63,11 +63,12 @@
     "inquirer": "^13.3.2"
   },
   "overrides": {
-    "esbuild": "^0.25.0"
+    "esbuild": "^0.25.0",
+    "vite": "^6.4.2"
   },
   "devDependencies": {
     "snyk": "^1.1303.2",
-    "vitepress": "^1.0.0-rc.45"
+    "vitepress": "^1.6.4"
   },
   "files": [
     "bin",
@@ -76,4 +77,4 @@
     "README.md",
     "CHANGELOG.md"
   ]
-}
+}

package/templates/clean-architecture/js/src/domain/models/User.js

@@ -1,9 +1,11 @@
 class User {
-    constructor(id, name, email) {
+    constructor(id, name, email, password) {
         this.id = id;
         this.name = name;
         this.email = email;
+        this.password = password;
     }
+
 }
 
 module.exports = User;

package/templates/clean-architecture/js/src/index.js.ejs

@@ -1,5 +1,7 @@
 const startServer = require('./infrastructure/webserver/server');
+<% if (database !== 'None' || communication === 'Kafka') { -%>
 const logger = require('./infrastructure/log/logger');
+<% } -%>
 <% if (communication === 'Kafka') { -%>
 const { connectKafka } = require('./infrastructure/messaging/kafkaClient');
 <% } -%>

package/templates/clean-architecture/js/src/infrastructure/config/env.js.ejs

@@ -33,15 +33,24 @@ const envSchema = z.object({
 <%_ if (communication === 'Kafka') { -%>
   KAFKA_BROKER: z.string(),
 <%_ } -%>
+<%_ if (auth.includes('JWT')) { -%>
+  JWT_SECRET: z.string(),
+  JWT_EXPIRES_IN: z.string().default('15m'),
+  JWT_REFRESH_SECRET: z.string().default('your-secret-refresh-key'),
+  JWT_REFRESH_EXPIRES_IN: z.string().default('7d'),
+<%_ } -%>
 });
 
 const _env = envSchema.safeParse(process.env);
 
 if (!_env.success) {
-  logger.error('❌ Invalid environment variables:', _env.error.format());
-  process.exit(1);
+  if (process.env.NODE_ENV !== 'test') {
+    logger.error('❌ Invalid environment variables:', _env.error.format());
+    process.exit(1);
+  }
+  logger.warn('⚠️ Environment validation failed. Continuing in test mode.');
 }
 
-const env = _env.data;
+const env = _env.success ? _env.data : process.env;
 
 module.exports = { env };

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

@@ -6,8 +6,17 @@ class UserRepository {
     const newUser = await UserModel.create(user);
     return newUser;
 <%_ } else { -%>
-    const newUser = await UserModel.create({ name: user.name, email: user.email });
-<%_ if (database === 'MongoDB') { -%>
+    const newUser = await UserModel.create({ 
+      name: user.name, 
+      email: user.email,
+      <% if (auth.includes('JWT')) { %>password: user.password<% } %>
+    });
+<%_ if (auth.includes('JWT')) { -%>
+    // Ensure password is not returned in the save result
+    const result = { ...user, id: newUser.id || newUser._id.toString() };
+    delete result.password;
+    return result;
+<%_ } else if (database === 'MongoDB') { -%>
     return { ...user, id: newUser._id.toString() };
 <%_ } else { -%>
     return { ...user, id: newUser.id };
@@ -15,6 +24,20 @@ class UserRepository {
 <%_ } -%>
   }
 
+  async findById(id) {
+<%_ if (database === 'None') { -%>
+    return await UserModel.findByPk(id);
+<%_ } else 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 { -%>
+    const user = await UserModel.findByPk(id);
+    if (!user) return null;
+    return { id: user.id || 0, name: user.name, email: user.email };
+<%_ } -%>
+  }
+
   async getUsers() {
 <%_ if (database === 'None') { -%>
     return await UserModel.find();

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

@@ -46,6 +46,33 @@ describe('UserRepository', () => {
         });
     });
 
+    describe('findById', () => {
+        it('should return a user if found (Happy Path)', async () => {
+            const id = '1';
+            const userData = { id, name: 'Test User', email: 'test@example.com' };
+<%_ if (database === 'MongoDB') { -%>
+            UserModel.findById.mockResolvedValue({ _id: id, ...userData });
+<%_ } else if (database === 'None') { -%>
+            UserModel.findByPk.mockResolvedValue(userData);
+<%_ } else { -%>
+            UserModel.findByPk.mockResolvedValue(userData);
+<%_ } -%>
+            const result = await userRepository.findById(id);
+            expect(result).toEqual(userData);
+        });
+
+        it('should return null if user not found (Error Handling)', async () => {
+            const id = '999';
+<%_ if (database === 'MongoDB') { -%>
+            UserModel.findById.mockResolvedValue(null);
+<%_ } else { -%>
+            UserModel.findByPk.mockResolvedValue(null);
+<%_ } -%>
+            const result = await userRepository.findById(id);
+            expect(result).toBeNull();
+        });
+    });
+
     describe('getUsers', () => {
         it('should return a list of mapped UserEntities (Happy Path)', async () => {
 <%_ if (database === 'MongoDB') { -%>

package/templates/clean-architecture/js/src/infrastructure/webserver/server.js.ejs

@@ -10,6 +10,8 @@ const apiRoutes = require('../../interfaces/routes/api');
 const swaggerUi = require('swagger-ui-express');
 const swaggerSpecs = require('./swagger');
 <%_ } -%>
+<%_ if (auth.includes('JWT')) { -%>const authRoutes = require('../../interfaces/routes/authRoutes');<%_ } -%>
+
 <%_ if (communication === 'GraphQL') { -%>
 const { ApolloServer } = require('@apollo/server');
 const { expressMiddleware } = require('@as-integrations/express4');
@@ -33,6 +35,7 @@ const startServer = async () => {
     <%_ if (communication === 'REST APIs' || communication === 'Kafka') { -%>
     app.use('/api', apiRoutes);
     <%_ } -%>
+    <%_ if (auth.includes('JWT')) { -%>app.use('/api/auth', authRoutes);<%_ } -%>
     <%_ if (communication === 'REST APIs' || communication === 'Kafka') { -%>
     app.use('/api-docs', swaggerUi.serve, swaggerUi.setup(swaggerSpecs));
     <%_ } -%>

package/templates/clean-architecture/js/src/infrastructure/webserver/server.spec.js.ejs

@@ -0,0 +1,49 @@
+const startServer = require('@/infrastructure/webserver/server');
+const express = require('express');
+const logger = require('@/infrastructure/log/logger');
+
+jest.mock('express', () => {
+    const mRouter = {
+        get: jest.fn(),
+        post: jest.fn(),
+        patch: jest.fn(),
+        delete: jest.fn(),
+        use: jest.fn(),
+    };
+    const mApp = {
+        use: jest.fn(),
+        listen: jest.fn((port, cb) => {
+            if (cb) cb();
+            return { close: jest.fn() };
+        }),
+    };
+    const mExpress = jest.fn(() => mApp);
+    mExpress.Router = jest.fn(() => mRouter);
+    mExpress.json = jest.fn(() => (req, res, next) => next());
+    mExpress.static = jest.fn(() => (req, res, next) => next());
+    mExpress.urlencoded = jest.fn(() => (req, res, next) => next());
+    return mExpress;
+});
+
+jest.mock('@/infrastructure/log/logger', () => ({
+    info: jest.fn(),
+    error: jest.fn(),
+}));
+
+jest.mock('@/utils/gracefulShutdown', () => jest.fn());
+
+// Mock standard middlewares as pass-through
+jest.mock('cors', () => () => (req, res, next) => next());
+jest.mock('helmet', () => () => (req, res, next) => next());
+jest.mock('hpp', () => () => (req, res, next) => next());
+jest.mock('express-rate-limit', () => () => (req, res, next) => next());
+jest.mock('morgan', () => () => (req, res, next) => next());
+
+describe('Server initialization', () => {
+    it('should start the server successfully', async () => {
+        await expect(startServer()).resolves.not.toThrow();
+        const app = express();
+        expect(app.listen).toHaveBeenCalled();
+        expect(logger.info).toHaveBeenCalledWith(expect.stringContaining('Server running on port'));
+    });
+});

package/templates/clean-architecture/js/src/infrastructure/webserver/swagger.spec.js.ejs

@@ -0,0 +1,14 @@
+<% if (communication === 'REST APIs' || communication === 'Kafka') { -%>
+const swaggerDocument = require('@/infrastructure/webserver/swagger');
+
+jest.mock('yamljs', () => ({
+    load: jest.fn().mockReturnValue({ swagger: '2.0', info: { title: 'Test API' } }),
+}));
+
+describe('Swagger Documentation', () => {
+    it('should load the swagger document', () => {
+        expect(swaggerDocument).toBeDefined();
+        expect(swaggerDocument.swagger).toBe('2.0');
+    });
+});
+<% } -%>

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

@@ -2,6 +2,7 @@ const CreateUser = require('../../usecases/CreateUser');
 const GetAllUsers = require('../../usecases/GetAllUsers');
 const UpdateUser = require('../../usecases/UpdateUser');
 const DeleteUser = require('../../usecases/DeleteUser');
+const GetUserById = require('../../usecases/GetUserById');
 const UserRepository = require('../../infrastructure/repositories/UserRepository');
 const ERROR_MESSAGES = require('../../utils/errorMessages');
 <% if (communication !== 'GraphQL') { -%>
@@ -20,6 +21,7 @@ class UserController {
         this.getAllUsersUseCase = new GetAllUsers(this.userRepository);
         this.updateUserUseCase = new UpdateUser(this.userRepository);
         this.deleteUserUseCase = new DeleteUser(this.userRepository);
+        this.getUserByIdUseCase = new GetUserById(this.userRepository);
     }
 
 <% if (communication === 'GraphQL') { -%>
@@ -33,9 +35,14 @@ class UserController {
     }
 
     async createUser(data) {
-        const { name, email } = data;
+        const { name, email, password } = data;
         try {
-            const user = await this.createUserUseCase.execute(name, email);
+            <% if (auth.includes('JWT')) { %>
+            if (!password) {
+                throw new Error('Password is required');
+            }
+            <% } %>
+            const user = await this.createUserUseCase.execute(name, email, password);
 <%_ if (communication === 'Kafka') { -%>
             await sendMessage('user-topic', JSON.stringify({
                 action: KAFKA_ACTIONS.USER_CREATED,
@@ -49,6 +56,17 @@ class UserController {
         }
     }
 
+    async getUserById(id) {
+        try {
+            const user = await this.getUserByIdUseCase.execute(id);
+            if (!user) throw new Error(ERROR_MESSAGES.USER_NOT_FOUND);
+            return user;
+        } catch (error) {
+            logger.error(`${ERROR_MESSAGES.FETCH_USER_ERROR}:`, error);
+            throw error;
+        }
+    }
+
     async updateUser(id, data) {
         try {
             const user = await this.updateUserUseCase.execute(id, data);
@@ -94,9 +112,14 @@ class UserController {
     }
 
     async createUser(req, res, next) {
-        const { name, email } = req.body || {};
+        const { name, email, password } = req.body || {};
         try {
-            const user = await this.createUserUseCase.execute(name, email);
+<% 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') { -%>
             await sendMessage('user-topic', JSON.stringify({
                 action: KAFKA_ACTIONS.USER_CREATED,
@@ -150,6 +173,20 @@ class UserController {
             next(error);
         }
     }
+
+    async getUserById(req, res, next) {
+        const { id } = req.params;
+        try {
+            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) {
+            logger.error(`${ERROR_MESSAGES.FETCH_USER_ERROR}:`, error);
+            next(error);
+        }
+    }
 <% } -%>
 }
 

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

@@ -1,5 +1,7 @@
 const UserController = require('@/interfaces/controllers/userController');
+<% if (communication === 'GraphQL') { -%>
 const ERROR_MESSAGES = require('@/utils/errorMessages');
+<% } -%>
 const CreateUser = require('@/usecases/CreateUser');
 const GetAllUsers = require('@/usecases/GetAllUsers');
 const UpdateUser = require('@/usecases/UpdateUser');
@@ -9,6 +11,7 @@ jest.mock('@/usecases/CreateUser');
 jest.mock('@/usecases/GetAllUsers');
 jest.mock('@/usecases/UpdateUser');
 jest.mock('@/usecases/DeleteUser');
+jest.mock('@/usecases/GetUserById');
 <%_ if (communication === 'Kafka') { -%>
 jest.mock('@/infrastructure/messaging/kafkaClient', () => ({
     sendMessage: jest.fn().mockResolvedValue(undefined)
@@ -22,6 +25,7 @@ describe('UserController (Clean Architecture)', () => {
     let mockGetAllUsersUseCase;
     let mockUpdateUserUseCase;
     let mockDeleteUserUseCase;
+    let mockGetUserByIdUseCase;
 <%_ if (communication !== 'GraphQL') { -%>
     let mockRequest;
     let mockResponse;
@@ -38,6 +42,8 @@ describe('UserController (Clean Architecture)', () => {
         mockGetAllUsersUseCase = GetAllUsers.mock.instances[0];
         mockUpdateUserUseCase = UpdateUser.mock.instances[0];
         mockDeleteUserUseCase = DeleteUser.mock.instances[0];
+        const GetUserById = require('@/usecases/GetUserById');
+        mockGetUserByIdUseCase = GetUserById.mock.instances[0];
 
 <%_ if (communication !== 'GraphQL') { -%>
         mockRequest = {
@@ -82,13 +88,14 @@ describe('UserController (Clean Architecture)', () => {
 
     describe('createUser', () => {
         it('should successfully create a new user (Happy Path)', async () => {
-            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 { -%>
             mockRequest.body = payload;
 <%_ } -%>
             const expectedUser = { id: '1', ...payload };
+            if (expectedUser.password) delete expectedUser.password;
             
             mockCreateUserUseCase.execute.mockResolvedValue(expectedUser);
 
@@ -105,7 +112,51 @@ describe('UserController (Clean Architecture)', () => {
 
             expect(mockResponse.json).toHaveBeenCalledWith(expectedUser);
 <%_ } -%>
-            expect(mockCreateUserUseCase.execute).toHaveBeenCalledWith(payload.name, payload.email);
+            expect(mockCreateUserUseCase.execute).toHaveBeenCalledWith(payload.name, payload.email, payload.password);
+        });
+
+<% 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, mockResponse, mockNext);
+            expect(mockResponse.status).toHaveBeenCalledWith(400);
+            expect(mockResponse.json).toHaveBeenCalledWith({ error: 'Password is required' });
+<%_ } -%>
+        });
+<% } %>
+    });
+
+    describe('getUserById', () => {
+        it('should return a user if found (Happy Path)', async () => {
+            const id = '1';
+            const userMock = { id, name: 'Test', email: 'test@example.com' };
+            mockGetUserByIdUseCase.execute.mockResolvedValue(userMock);
+
+<%_ if (communication === 'GraphQL') { -%>
+            const result = await userController.getUserById(id);
+            expect(result).toEqual(userMock);
+<%_ } else { -%>
+            mockRequest.params = { id };
+            await userController.getUserById(mockRequest, mockResponse, mockNext);
+            expect(mockResponse.json).toHaveBeenCalledWith(userMock);
+<%_ } -%>
+        });
+
+        it('should return 404 if user not found (Error Handling)', async () => {
+            const id = '999';
+            mockGetUserByIdUseCase.execute.mockResolvedValue(null);
+
+<%_ if (communication === 'GraphQL') { -%>
+            await expect(userController.getUserById(id)).rejects.toThrow(ERROR_MESSAGES.USER_NOT_FOUND);
+<%_ } else { -%>
+            mockRequest.params = { id };
+            await userController.getUserById(mockRequest, mockResponse, mockNext);
+            expect(mockResponse.status).toHaveBeenCalledWith(404);
+<%_ } -%>
         });
     });
 
@@ -138,6 +189,19 @@ describe('UserController (Clean Architecture)', () => {
             expect(mockUpdateUserUseCase.execute).toHaveBeenCalledWith(id, payload);
         });
 
+        it('should return 404 if user to update is not found (Error Handling)', async () => {
+            const id = '999';
+            mockUpdateUserUseCase.execute.mockResolvedValue(null);
+
+<%_ if (communication === 'GraphQL') { -%>
+            await expect(userController.updateUser(id, { name: 'Fail' })).rejects.toThrow(ERROR_MESSAGES.USER_NOT_FOUND);
+<%_ } else { -%>
+            mockRequest.params = { id };
+            await userController.updateUser(mockRequest, mockResponse, mockNext);
+            expect(mockResponse.status).toHaveBeenCalledWith(404);
+<%_ } -%>
+        });
+
         it('should handle database errors during update (Error Handling)', async () => {
             const id = '1';
             const error = new Error('Database Error');
@@ -145,6 +209,7 @@ describe('UserController (Clean Architecture)', () => {
 <%_ if (communication === 'GraphQL') { -%>
             await expect(userController.updateUser(id, { name: 'Fail' })).rejects.toThrow(error);
 <%_ } else { -%>
+            mockRequest.params = { id };
             await userController.updateUser(mockRequest, mockResponse, mockNext);
             expect(mockNext).toHaveBeenCalledWith(error);
 <%_ } -%>
@@ -207,9 +272,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, mockResponse, mockNext);
             expect(mockNext).toHaveBeenCalledWith(error);
 <%_ } -%>

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

@@ -1,13 +1,20 @@
+<% if (auth.includes('JWT')) { %>const JwtService = require('../../infrastructure/auth/jwtService');<% } %>
 const UserRepository = require('../../infrastructure/repositories/UserRepository');
 
 const gqlContext = async ({ req }) => {
-  const token = req.headers.authorization || '';
-  const userRepository = new UserRepository();
-  
-  return { 
-    token, 
-    userRepository 
+  const context = {
+    userRepository: new 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;
 };
 
 module.exports = { gqlContext };

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

@@ -1,31 +1,48 @@
+<% if (auth.includes('JWT')) { %>const JwtService = require('@/infrastructure/auth/jwtService');
+jest.mock('@/infrastructure/auth/jwtService');<% } %>
 const { gqlContext } = require('@/interfaces/graphql/context');
-const { resolvers } = require('@/interfaces/graphql/resolvers');
-const { typeDefs } = require('@/interfaces/graphql/typeDefs');
+const { resolvers } = require('@/interfaces/graphql/index');
+const { typeDefs } = require('@/interfaces/graphql/typeDefs/index');
 
 jest.mock('@/infrastructure/repositories/UserRepository');
 
 describe('GraphQL Context', () => {
-    it('should exercise GraphQL index entry points', () => {
-        expect(resolvers).toBeDefined();
-        expect(typeDefs).toBeDefined();
+    afterEach(() => {
+        jest.clearAllMocks();
     });
-  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 user when authorization header is present and valid', async () => {
+        <% if (auth.includes('JWT')) { %>
+        const mockUser = { id: '1', email: 'test@test.com' };
+        JwtService.verifyToken.mockReturnValue(mockUser);
+        const mockRequest = {
+            headers: {
+                authorization: 'Bearer valid-token',
+            },
+        };
 
-  it('should return context with empty token when authorization header is missing', async () => {
-    const mockRequest = {
-      headers: {},
-    };
+        const context = await gqlContext({ req: mockRequest });
+        expect(context.user).toEqual(mockUser);
+        expect(JwtService.verifyToken).toHaveBeenCalledWith('valid-token');
+        <% } else { %>
+        const mockRequest = {
+            headers: {
+                authorization: 'Bearer token123',
+            },
+        };
+        const context = await gqlContext({ req: mockRequest });
+        expect(context.user).toBeUndefined();
+        <% } %>
+        expect(context.userRepository).toBeDefined();
+    });
+
+    it('should return context without user when authorization header is missing', async () => {
+        const mockRequest = {
+            headers: {},
+        };
 
-    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/js/src/interfaces/graphql/resolvers/user.resolvers.js.ejs

@@ -4,18 +4,23 @@ const userController = new UserController();
 
 const userResolvers = {
   Query: {
-    getAllUsers: async () => {
+    getAllUsers: async (_, __, <% if (auth.includes('JWT')) { %>{ user }<% } else { %>_context<% } %>) => {
+      <% if (auth.includes('JWT')) { %>if (!user) throw new Error('Unauthorized');<% } %>
       return await userController.getUsers();
     }
   },
   Mutation: {
-    createUser: async (_, { name, email }) => {
-      return await userController.createUser({ name, email });
+    createUser: async (_, { name, email<% if (auth.some(a => a !=='None')) { %>, password<% } %> }) => {
+      // Create user is typically public for registration
+      const user = await userController.createUser({ name, email<% if (auth.some(a => a !=='None')) { %>, password<% } %> });
+      return user;
     },
-    updateUser: async (_, { id, name, email }) => {
+    updateUser: async (_, { id, name, email }, <% if (auth.includes('JWT')) { %>{ user }<% } else { %>_context<% } %>) => {
+      <% if (auth.includes('JWT')) { %>if (!user) throw new Error('Unauthorized');<% } %>
       return await userController.updateUser(id, { name, email });
     },
-    deleteUser: async (_, { id }) => {
+    deleteUser: async (_, { id }, <% if (auth.includes('JWT')) { %>{ user }<% } else { %>_context<% } %>) => {
+      <% if (auth.includes('JWT')) { %>if (!user) throw new Error('Unauthorized');<% } %>
       return await userController.deleteUser(id);
     }
   }<%_ if (database === 'MongoDB') { -%>,