nodejs-quickstart-structure 2.0.1 → 2.1.1

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

@@ -1,31 +1,64 @@
+<% if (auth.includes('JWT')) { %>
+const JwtService = require('@/infrastructure/auth/jwtService');
+jest.mock('@/infrastructure/auth/jwtService', () => ({
+    verifyToken: jest.fn(),
+    generateToken: jest.fn(),
+    generateRefreshToken: jest.fn(),
+    verifyRefreshToken: jest.fn(),
+    decodeToken: jest.fn(),
+}));
+<% } %>
 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');
+jest.mock('@/infrastructure/repositories/UserRepository', () => {
+    return 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();
+    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',
+            },
+        };
+
+        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 with empty token when authorization header is missing', async () => {
-    const mockRequest = {
-      headers: {},
-    };
+    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') { -%>,

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

@@ -13,40 +13,62 @@ jest.mock('@/interfaces/controllers/userController', () => {
 });
 
 describe('User Resolvers', () => {
+  const mockContext = { 
+    <% 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);
       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, {})).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);
       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' }, {})).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);
       expect(result).toBe(true);
     });
+
+    <% if (auth.includes('JWT')) { %>
+    it('should throw error when unauthorized', async () => {
+      await expect(userResolvers.Mutation.deleteUser(null, { id: '1' }, {})).rejects.toThrow('Unauthorized');
+    });
+    <% } %>
   });
 <%_ if (database === 'MongoDB') { -%>
   describe('User.id', () => {

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

@@ -10,7 +10,7 @@ const userTypes = `#graphql
   }
 
   type Mutation {
-    createUser(name: String!, email: String!): User
+    createUser(name: String!, email: String!<%_ if (auth.some(a => a !=='None')) { _%>, password: String!<%_ } _%>): User
     updateUser(id: ID!, name: String, email: String): User
     deleteUser(id: ID!): Boolean
   }

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

@@ -4,7 +4,15 @@ const UserRepository = require('@/infrastructure/repositories/UserRepository');
 const cacheService = require('<% if (caching === "Redis") { %>@/infrastructure/caching/redisClient<% } else { %>@/infrastructure/caching/memoryCache<% } %>');
 <%_ } -%>
 
-jest.mock('@/infrastructure/repositories/UserRepository');
+jest.mock('@/infrastructure/repositories/UserRepository', () => {
+    return jest.fn().mockImplementation(() => ({
+        save: jest.fn(),
+        findById: jest.fn(),
+        getUsers: jest.fn(),
+        update: jest.fn(),
+        delete: jest.fn()
+    }));
+});
 <%_ if (caching !== 'None') { -%>
 jest.mock('<% if (caching === "Redis") { %>@/infrastructure/caching/redisClient<% } else { %>@/infrastructure/caching/memoryCache<% } %>', () => ({
     get: jest.fn(),
@@ -26,11 +34,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 +55,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/DeleteUser.spec.js.ejs

@@ -4,7 +4,15 @@ const UserRepository = require('@/infrastructure/repositories/UserRepository');
 const cacheService = require('<% if (caching === "Redis") { %>@/infrastructure/caching/redisClient<% } else { %>@/infrastructure/caching/memoryCache<% } %>');
 <%_ } -%>
 
-jest.mock('@/infrastructure/repositories/UserRepository');
+jest.mock('@/infrastructure/repositories/UserRepository', () => {
+    return jest.fn().mockImplementation(() => ({
+        save: jest.fn(),
+        findById: jest.fn(),
+        getUsers: jest.fn(),
+        update: jest.fn(),
+        delete: jest.fn()
+    }));
+});
 <%_ if (caching !== 'None') { -%>
 jest.mock('<% if (caching === "Redis") { %>@/infrastructure/caching/redisClient<% } else { %>@/infrastructure/caching/memoryCache<% } %>', () => ({
     get: jest.fn(),

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,10 +1,32 @@
 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<% } %>');
 <%_ } -%>
 
-jest.mock('@/infrastructure/repositories/UserRepository');
+jest.mock('@/infrastructure/repositories/UserRepository', () => {
+    return jest.fn().mockImplementation(() => ({
+        save: jest.fn(),
+        findById: jest.fn(),
+        getUsers: jest.fn(),
+        update: jest.fn(),
+        delete: jest.fn()
+    }));
+});
 <%_ if (caching !== 'None') { -%>
 jest.mock('<% if (caching === "Redis") { %>@/infrastructure/caching/redisClient<% } else { %>@/infrastructure/caching/memoryCache<% } %>', () => ({
     get: jest.fn(),

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/usecases/UpdateUser.spec.js.ejs

@@ -4,7 +4,15 @@ const UserRepository = require('@/infrastructure/repositories/UserRepository');
 const cacheService = require('<% if (caching === "Redis") { %>@/infrastructure/caching/redisClient<% } else { %>@/infrastructure/caching/memoryCache<% } %>');
 <%_ } -%>
 
-jest.mock('@/infrastructure/repositories/UserRepository');
+jest.mock('@/infrastructure/repositories/UserRepository', () => {
+    return jest.fn().mockImplementation(() => ({
+        save: jest.fn(),
+        findById: jest.fn(),
+        getUsers: jest.fn(),
+        update: jest.fn(),
+        delete: jest.fn()
+    }));
+});
 <%_ if (caching !== 'None') { -%>
 jest.mock('<% if (caching === "Redis") { %>@/infrastructure/caching/redisClient<% } else { %>@/infrastructure/caching/memoryCache<% } %>', () => ({
     get: jest.fn(),

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));
 <%_ } -%>