nodejs-quickstart-structure 2.0.1 → 2.1.0

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

@@ -0,0 +1,15 @@
+const express = require('express');
+const UserController = require('../controllers/userController');
+<%_ if (auth.includes('JWT')) { _%>
+const authMiddleware = require('../../infrastructure/webserver/middleware/authMiddleware');
+<%_ } _%>
+const router = express.Router();
+const userController = new UserController();
+
+router.get('/users', <% if (auth.includes('JWT')) { %>authMiddleware, <% } %>(req, res, next) => userController.getUsers(req, res, next));
+router.get('/users/:id', <% if (auth.includes('JWT')) { %>authMiddleware, <% } %>(req, res, next) => userController.getUserById(req, res, next));
+router.post('/users', (req, res, next) => userController.createUser(req, res, next));
+router.patch('/users/:id', <% if (auth.includes('JWT')) { %>authMiddleware, <% } %>(req, res, next) => userController.updateUser(req, res, next));
+router.delete('/users/:id', <% if (auth.includes('JWT')) { %>authMiddleware, <% } %>(req, res, next) => userController.deleteUser(req, res, next));
+
+module.exports = router;

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

@@ -12,6 +12,10 @@ jest.mock('@/interfaces/controllers/userController', () => {
   }));
 });
 
+<% if (auth.includes('JWT')) { %>
+jest.mock('@/infrastructure/webserver/middleware/authMiddleware', () => (req, res, next) => next());
+<% } %>
+
 describe('ApiRoutes', () => {
     let app;
 

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

@@ -0,0 +1,34 @@
+const User = require('../domain/models/User');
+<%_ if (auth.includes('JWT')) { _%>
+const bcrypt = require('bcryptjs');
+<%_ } _%>
+<%_ if (caching !== 'None') { _%>
+const cacheService = require('<% if (caching === "Redis") { %>../infrastructure/caching/redisClient<% } else { %>../infrastructure/caching/memoryCache<% } %>');
+const logger = require('../infrastructure/log/logger');
+<%_ } _%>
+
+class CreateUser {
+    constructor(userRepository) {
+        this.userRepository = userRepository;
+    }
+
+    async execute(name, email, password) {
+        let finalPassword = password;
+        <%_ if (auth.includes('JWT')) { -%>
+        if (password) {
+            finalPassword = await bcrypt.hash(password, 10);
+        }<%_ } -%>
+        const user = new User(null, name, email, finalPassword);
+        const savedUser = await this.userRepository.save(user);
+        <%_ if (caching !== 'None') { -%>
+        try {
+            await cacheService.del('users:all');
+            logger.info('Invalidated users:all cache');
+        } catch (error) {
+            logger.error('Cache error (del):', error);
+        }<%_ } _%>
+        return savedUser;
+    }
+}
+
+module.exports = CreateUser;

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

@@ -26,11 +26,12 @@ describe('CreateUser UseCase', () => {
     it('should create and save a new user', async () => {
         const name = 'Test User';
         const email = 'test@example.com';
+        const password = 'password123';
         const expectedResult = { id: 1, name, email };
 
         mockUserRepository.save.mockResolvedValue(expectedResult);
 
-        const result = await createUser.execute(name, email);
+        const result = await createUser.execute(name, email, password);
 
         expect(mockUserRepository.save).toHaveBeenCalledTimes(1);
         const savedUser = mockUserRepository.save.mock.calls[0][0];
@@ -46,6 +47,6 @@ describe('CreateUser UseCase', () => {
         const error = new Error('Database error');
         mockUserRepository.save.mockRejectedValue(error);
 
-        await expect(createUser.execute('Test', 'test@test.com')).rejects.toThrow(error);
+        await expect(createUser.execute('Test', 'test@test.com', 'pwd')).rejects.toThrow(error);
     });
 });

package/templates/clean-architecture/js/src/usecases/DeleteUser.js.ejs

@@ -0,0 +1,27 @@
+<%_ if (caching !== 'None') { _%>
+const cacheService = require('<% if (caching === "Redis") { %>../infrastructure/caching/redisClient<% } else { %>../infrastructure/caching/memoryCache<% } %>');
+const logger = require('../infrastructure/log/logger');
+<%_ } _%>
+
+class DeleteUser {
+  constructor(userRepository) {
+    this.userRepository = userRepository;
+  }
+
+  async execute(id) {
+    const result = await this.userRepository.delete(id);
+    <%_ if (caching !== 'None') { -%>
+    if (result) {
+        try {
+            await cacheService.del('users:all');
+            await cacheService.del(`user:${id}`);
+            logger.info(`Invalidated cache for user ${id}`);
+        } catch (error) {
+            logger.error('Cache error (del):', error);
+        }
+    }<%_ } -%>
+    return result;
+  }
+}
+
+module.exports = DeleteUser;

package/templates/clean-architecture/js/src/usecases/GetAllUsers.js.ejs

@@ -0,0 +1,36 @@
+<%_ if (caching !== 'None') { _%>
+const cacheService = require('<% if (caching === "Redis") { %>../infrastructure/caching/redisClient<% } else { %>../infrastructure/caching/memoryCache<% } %>');
+const logger = require('../infrastructure/log/logger');
+<%_ } _%>
+
+class GetAllUsers {
+    constructor(userRepository) {
+        this.userRepository = userRepository;
+    }
+
+    async execute() {
+        <%_ if (caching !== 'None') { -%>
+        const cacheKey = 'users:all';
+        try {
+            const cachedUsers = await cacheService.get(cacheKey);
+            if (cachedUsers) {
+                logger.info('Serving users from cache');
+                return cachedUsers;
+            }
+        } catch (error) {
+            logger.error('Cache error (get):', error);
+        }<%_ } -%>
+        const users = await this.userRepository.getUsers();
+        <%_ if (caching !== 'None') { -%>
+        if (users) {
+            try {
+                await cacheService.set(cacheKey, users, 3600); // Cache for 1 hour
+            } catch (error) {
+                logger.error('Cache error (set):', error);
+            }
+        }<%_ } -%>
+        return users;
+    }
+}
+
+module.exports = GetAllUsers;

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

@@ -1,4 +1,18 @@
 const GetAllUsers = require('@/usecases/GetAllUsers');
+
+<% if (caching === 'Redis') { -%>
+jest.mock('@/infrastructure/caching/redisClient', () => ({
+    get: jest.fn(),
+    set: jest.fn(),
+    del: jest.fn()
+}));
+<% } else if (caching === 'Memory Cache') { -%>
+jest.mock('@/infrastructure/caching/memoryCache', () => ({
+    get: jest.fn(),
+    set: jest.fn(),
+    del: jest.fn()
+}));
+<% } -%>
 const UserRepository = require('@/infrastructure/repositories/UserRepository');
 <%_ if (caching !== 'None') { -%>
 const cacheService = require('<% if (caching === "Redis") { %>@/infrastructure/caching/redisClient<% } else { %>@/infrastructure/caching/memoryCache<% } %>');

package/templates/clean-architecture/js/src/usecases/GetUserById.js.ejs

@@ -0,0 +1,36 @@
+<%_ if (caching !== 'None') { _%>
+const cacheService = require('<% if (caching === "Redis") { %>../infrastructure/caching/redisClient<% } else { %>../infrastructure/caching/memoryCache<% } %>');
+const logger = require('../infrastructure/log/logger');
+<%_ } _%>
+
+class GetUserById {
+  constructor(userRepository) {
+    this.userRepository = userRepository;
+  }
+
+  async execute(id) {
+    <%_ if (caching !== 'None') { -%>
+    const cacheKey = `user:${id}`;
+    try {
+      const cachedUser = await cacheService.get(cacheKey);
+      if (cachedUser) {
+        logger.info(`Serving user ${id} from cache`);
+        return cachedUser;
+      }
+    } catch (error) {
+      logger.error('Cache error (get):', error);
+    }<%_ } -%>
+    const user = await this.userRepository.findById(id);
+    <%_ if (caching !== 'None') { -%>
+    if (user) {
+      try {
+        await cacheService.set(cacheKey, user, 3600); // Cache for 1 hour
+      } catch (error) {
+        logger.error('Cache error (set):', error);
+      }
+    }<%_ } -%>
+    return user;
+  }
+}
+
+module.exports = GetUserById;

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

@@ -0,0 +1,48 @@
+const GetUserById = require('@/usecases/GetUserById');
+
+<% if (caching === 'Redis') { -%>
+jest.mock('@/infrastructure/caching/redisClient', () => ({
+    get: jest.fn(),
+    set: jest.fn(),
+    del: jest.fn()
+}));
+<% } else if (caching === 'Memory Cache') { -%>
+jest.mock('@/infrastructure/caching/memoryCache', () => ({
+    get: jest.fn(),
+    set: jest.fn(),
+    del: jest.fn()
+}));
+<% } -%>
+
+describe('GetUserById Use Case', () => {
+  let userRepository;
+  let getUserById;
+
+  beforeEach(() => {
+    userRepository = {
+      findById: jest.fn(),
+    };
+    getUserById = new GetUserById(userRepository);
+  });
+
+  it('should return a user if found (Happy Path)', async () => {
+    const id = '1';
+    const user = { id, name: 'Test User', email: 'test@example.com' };
+    userRepository.findById.mockResolvedValue(user);
+
+    const result = await getUserById.execute(id);
+
+    expect(result).toEqual(user);
+    expect(userRepository.findById).toHaveBeenCalledWith(id);
+  });
+
+  it('should return null if user not found (Error Handling)', async () => {
+    const id = '999';
+    userRepository.findById.mockResolvedValue(null);
+
+    const result = await getUserById.execute(id);
+
+    expect(result).toBeNull();
+    expect(userRepository.findById).toHaveBeenCalledWith(id);
+  });
+});

package/templates/clean-architecture/js/src/usecases/UpdateUser.js.ejs

@@ -0,0 +1,28 @@
+<%_ if (caching !== 'None') { _%>
+const cacheService = require('<% if (caching === "Redis") { %>../infrastructure/caching/redisClient<% } else { %>../infrastructure/caching/memoryCache<% } %>');
+const logger = require('../infrastructure/log/logger');
+<%_ } _%>
+
+class UpdateUser {
+  constructor(userRepository) {
+    this.userRepository = userRepository;
+  }
+
+  async execute(id, data) {
+    const user = await this.userRepository.update(id, data);
+    <%_ if (caching !== 'None') { -%>
+    if (user) {
+        try {
+            await cacheService.del('users:all');
+            await cacheService.del(`user:${id}`);
+            logger.info(`Invalidated cache for user ${id}`);
+        } catch (error) {
+            logger.error('Cache error (del):', error);
+        }
+    }
+    <%_ } -%>
+    return user;
+  }
+}
+
+module.exports = UpdateUser;

package/templates/clean-architecture/js/src/utils/errorMessages.js

@@ -5,6 +5,7 @@ const ERROR_MESSAGES = {
     INTERNAL_SERVER_ERROR: 'Internal Server Error',
     BAD_REQUEST: 'Bad Request',
     FETCH_USERS_ERROR: 'Error fetching users',
+    FETCH_USER_ERROR: 'Error fetching user',
     CREATE_USER_ERROR: 'Error creating user',
     UPDATE_USER_ERROR: 'Error updating user',
     DELETE_USER_ERROR: 'Error deleting user',

package/templates/clean-architecture/js/src/utils/httpCodes.js

@@ -2,6 +2,8 @@ const HTTP_STATUS = {
     OK: 200,
     CREATED: 201,
     BAD_REQUEST: 400,
+    UNAUTHORIZED: 401,
+    FORBIDDEN: 403,
     NOT_FOUND: 404,
     INTERNAL_SERVER_ERROR: 500
 };

package/templates/clean-architecture/ts/src/config/env.ts.ejs

@@ -34,13 +34,22 @@ 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.');
 }
 
-export const env = _env.data;
+export const env = (_env.success ? _env.data : process.env) as unknown as z.infer<typeof envSchema>;

package/templates/clean-architecture/ts/src/domain/user.ts

@@ -2,6 +2,8 @@ export class User {
     constructor(
         public id: number | string | null,
         public name: string,
-        public email: string
+        public email: string,
+        public password?: string
     ) { }
+
 }

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

@@ -13,6 +13,8 @@ import healthRoutes from '@/interfaces/routes/healthRoute';
 import userRoutes from '@/interfaces/routes/userRoutes';
 import swaggerUi from 'swagger-ui-express';
 import swaggerSpecs from '@/config/swagger';<% } %>
+<%_ if (auth.includes('JWT')) { -%>import authRoutes from '@/interfaces/routes/authRoutes';<%_ } -%>
+
 <%_ if (communication === 'Kafka') { -%>import { kafkaService } from '@/infrastructure/messaging/kafkaClient';<%_ } -%>
 <%_ if (communication === 'GraphQL') { -%>
 import { ApolloServer } from '@apollo/server';
@@ -54,6 +56,8 @@ app.use(morgan('combined', { stream: { write: (message) => logger.info(message.t
 <%_ if (communication === 'REST APIs' || communication === 'Kafka') { -%>
 app.use('/api/users', userRoutes);
 <%_ } -%>
+<%_ 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/ts/src/infrastructure/repositories/UserRepository.spec.ts.ejs

@@ -15,7 +15,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 +34,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 +47,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 +57,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 +135,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';
@@ -118,7 +120,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 +148,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 +193,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 +340,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);
 <%_ } -%>