nodejs-quickstart-structure 1.12.0 → 1.14.0

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

@@ -0,0 +1,31 @@
+const { gqlContext } = require('@/interfaces/graphql/context');
+const { resolvers } = require('@/interfaces/graphql/resolvers');
+const { typeDefs } = require('@/interfaces/graphql/typeDefs');
+
+jest.mock('@/infrastructure/repositories/UserRepository');
+
+describe('GraphQL Context', () => {
+    it('should exercise GraphQL index entry points', () => {
+        expect(resolvers).toBeDefined();
+        expect(typeDefs).toBeDefined();
+    });
+  it('should return context with token when authorization header is present', async () => {
+    const mockRequest = {
+      headers: {
+        authorization: 'Bearer token123',
+      },
+    };
+
+    const context = await gqlContext({ req: mockRequest });
+    expect(context.token).toBe('Bearer token123');
+  });
+
+  it('should return context with empty token when authorization header is missing', async () => {
+    const mockRequest = {
+      headers: {},
+    };
+
+    const context = await gqlContext({ req: mockRequest });
+    expect(context.token).toBe('');
+  });
+});

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

@@ -0,0 +1,49 @@
+const { userResolvers } = require('@/interfaces/graphql/resolvers/user.resolvers');
+
+const mockGetUsers = jest.fn().mockResolvedValue([{ id: '1', name: 'John Doe', email: 'john@example.com' }]);
+const mockCreateUser = jest.fn().mockResolvedValue({ id: '1', name: 'Jane', email: 'jane@example.com' });
+
+jest.mock('@/interfaces/controllers/userController', () => {
+  return jest.fn().mockImplementation(() => ({
+    getUsers: (...args) => mockGetUsers(...args),
+    createUser: (...args) => mockCreateUser(...args)
+  }));
+});
+
+describe('User Resolvers', () => {
+  afterEach(() => {
+    jest.clearAllMocks();
+  });
+
+  describe('Query.getAllUsers', () => {
+    it('should return all users', async () => {
+      const result = await userResolvers.Query.getAllUsers();
+      expect(result).toEqual([{ id: '1', name: 'John Doe', email: 'john@example.com' }]);
+      expect(mockGetUsers).toHaveBeenCalledTimes(1);
+    });
+  });
+
+  describe('Mutation.createUser', () => {
+    it('should create and return a new user', async () => {
+      const result = await userResolvers.Mutation.createUser(null, { name: 'Jane', email: 'jane@example.com' });
+      expect(result).toEqual({ id: '1', name: 'Jane', email: 'jane@example.com' });
+      expect(mockCreateUser).toHaveBeenCalledWith({ name: 'Jane', email: 'jane@example.com' });
+      expect(mockCreateUser).toHaveBeenCalledTimes(1);
+    });
+  });
+<%_ if (database === 'MongoDB') { -%>
+  describe('User.id', () => {
+    it('should return parent.id if available', () => {
+      const parent = { id: '123' };
+      const result = userResolvers.User.id(parent);
+      expect(result).toBe('123');
+    });
+
+    it('should fallback to parent._id if id is not available', () => {
+      const parent = { _id: '456' };
+      const result = userResolvers.User.id(parent);
+      expect(result).toBe('456');
+    });
+  });
+<%_ } -%>
+});

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

@@ -0,0 +1,38 @@
+const request = require('supertest');
+const express = require('express');
+const router = require('@/interfaces/routes/api');
+
+const mockGetUsers = jest.fn().mockImplementation((req, res) => res.status(200).json([{ id: '1', name: 'John Doe' }]));
+const mockCreateUser = jest.fn().mockImplementation((req, res) => res.status(201).json({ id: '1', name: 'Test' }));
+
+jest.mock('@/interfaces/controllers/userController', () => {
+  return jest.fn().mockImplementation(() => ({
+    getUsers: (...args) => mockGetUsers(...args),
+    createUser: (...args) => mockCreateUser(...args)
+  }));
+});
+
+describe('ApiRoutes', () => {
+    let app;
+
+    beforeEach(() => {
+        app = express();
+        app.use(express.json());
+        app.use('/api', router);
+    });
+
+    it('POST /api/users should call controller.createUser', async () => {
+        await request(app)
+            .post('/api/users')
+            .send({ name: 'Test', email: 'test@example.com' });
+
+        expect(mockCreateUser).toHaveBeenCalledTimes(1);
+    });
+
+    it('GET /api/users should call controller.getUsers', async () => {
+        await request(app)
+            .get('/api/users');
+
+        expect(mockGetUsers).toHaveBeenCalledTimes(1);
+    });
+});

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

@@ -0,0 +1,51 @@
+const CreateUser = require('@/usecases/CreateUser');
+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');
+<%_ if (caching !== 'None') { -%>
+jest.mock('<% if (caching === "Redis") { %>@/infrastructure/caching/redisClient<% } else { %>@/infrastructure/caching/memoryCache<% } %>', () => ({
+    get: jest.fn(),
+    set: jest.fn(),
+    del: jest.fn()
+}));
+<%_ } -%>
+
+describe('CreateUser UseCase', () => {
+    let createUser;
+    let mockUserRepository;
+
+    beforeEach(() => {
+        mockUserRepository = new UserRepository();
+        createUser = new CreateUser(mockUserRepository);
+        jest.clearAllMocks();
+    });
+
+    it('should create and save a new user', async () => {
+        const name = 'Test User';
+        const email = 'test@example.com';
+        const expectedResult = { id: 1, name, email };
+
+        mockUserRepository.save.mockResolvedValue(expectedResult);
+
+        const result = await createUser.execute(name, email);
+
+        expect(mockUserRepository.save).toHaveBeenCalledTimes(1);
+        const savedUser = mockUserRepository.save.mock.calls[0][0];
+        expect(savedUser.name).toBe(name);
+        expect(savedUser.email).toBe(email);
+        expect(result).toEqual(expectedResult);
+<%_ if (caching !== 'None') { -%>
+        expect(cacheService.del).toHaveBeenCalledWith('users:all');
+<%_ } -%>
+    });
+
+    it('should throw an error if repository fails', async () => {
+        const error = new Error('Database error');
+        mockUserRepository.save.mockRejectedValue(error);
+
+        await expect(createUser.execute('Test', 'test@test.com')).rejects.toThrow(error);
+    });
+});

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

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

package/templates/clean-architecture/ts/src/errors/BadRequestError.spec.ts.ejs

@@ -0,0 +1,21 @@
+import { BadRequestError } from '@/errors/BadRequestError';
+import { ApiError } from '@/errors/ApiError';
+import { HTTP_STATUS } from '@/utils/httpCodes';
+
+describe('BadRequestError', () => {
+    it('should extend ApiError', () => {
+        const error = new BadRequestError();
+        expect(error).toBeInstanceOf(ApiError);
+    });
+
+    it('should have default message "Bad request"', () => {
+        const error = new BadRequestError();
+        expect(error.message).toBe('Bad request');
+        expect(error.statusCode).toBe(HTTP_STATUS.BAD_REQUEST);
+    });
+
+    it('should accept a custom message', () => {
+        const error = new BadRequestError('Custom bad request');
+        expect(error.message).toBe('Custom bad request');
+    });
+});

package/templates/clean-architecture/ts/src/errors/BadRequestError.ts

@@ -1,4 +1,4 @@
-import { ApiError } from './ApiError';
+import { ApiError } from '@/errors/ApiError';
 import { HTTP_STATUS } from '@/utils/httpCodes';
 
 export class BadRequestError extends ApiError {

package/templates/clean-architecture/ts/src/errors/NotFoundError.spec.ts.ejs

@@ -0,0 +1,21 @@
+import { NotFoundError } from '@/errors/NotFoundError';
+import { ApiError } from '@/errors/ApiError';
+import { HTTP_STATUS } from '@/utils/httpCodes';
+
+describe('NotFoundError', () => {
+    it('should extend ApiError', () => {
+        const error = new NotFoundError();
+        expect(error).toBeInstanceOf(ApiError);
+    });
+
+    it('should have default message "Resource not found"', () => {
+        const error = new NotFoundError();
+        expect(error.message).toBe('Resource not found');
+        expect(error.statusCode).toBe(HTTP_STATUS.NOT_FOUND);
+    });
+
+    it('should accept a custom message', () => {
+        const error = new NotFoundError('User not found');
+        expect(error.message).toBe('User not found');
+    });
+});

package/templates/clean-architecture/ts/src/errors/NotFoundError.ts

@@ -1,4 +1,4 @@
-import { ApiError } from './ApiError';
+import { ApiError } from '@/errors/ApiError';
 import { HTTP_STATUS } from '@/utils/httpCodes';
 
 export class NotFoundError extends ApiError {

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

@@ -1,13 +1,15 @@
-import express, { Request, Response } from 'express';
+import express from 'express';
 import cors from 'cors';
 import helmet from 'helmet';
 import hpp from 'hpp';
 import rateLimit from 'express-rate-limit';
 import logger from '@/infrastructure/log/logger';
 import morgan from 'morgan';
-import { errorMiddleware } from '@/utils/error.middleware';
-<%_ if (communication === 'REST APIs') { -%>import userRoutes from '@/interfaces/routes/userRoutes';<%_ } -%>
+import { errorMiddleware } from '@/utils/errorMiddleware';
+import { setupGracefulShutdown } from '@/utils/gracefulShutdown';
+import healthRoutes from '@/interfaces/routes/healthRoute';
 <% if (communication === 'REST APIs') { -%>
+import userRoutes from '@/interfaces/routes/userRoutes';
 import swaggerUi from 'swagger-ui-express';
 import swaggerSpecs from '@/config/swagger';<% } -%>
 <%_ if (communication === 'Kafka') { -%>import { KafkaService } from '@/infrastructure/messaging/kafkaClient';<%_ } -%>
@@ -56,15 +58,13 @@ app.use('/api/users', userRoutes);
 <%_ if (communication === 'REST APIs') { -%>
 app.use('/api-docs', swaggerUi.serve, swaggerUi.setup(swaggerSpecs));
 <%_ } -%>
-app.get('/health', (req: Request, res: Response) => {
-  res.json({ status: 'UP' });
-});
+app.use('/health', healthRoutes);
 
 // Start Server Logic
 const startServer = async () => {
 <%_ if (communication === 'GraphQL') { -%>
     // GraphQL Setup
-    const server = new ApolloServer<MyContext>({
+    const apolloServer = new ApolloServer<MyContext>({
       typeDefs,
       resolvers,
       plugins: [ApolloServerPluginLandingPageLocalDefault({ embed: true })],
@@ -88,14 +88,16 @@ const startServer = async () => {
         return formattedError;
       },
     });
-    await server.start();
-    app.use('/graphql', expressMiddleware(server, { context: gqlContext }));
+    await apolloServer.start();
+    app.use('/graphql', expressMiddleware(apolloServer, { context: gqlContext }));
 <%_ } -%>
     app.use(errorMiddleware);
-    app.listen(port, () => {
+<%_ if (communication === 'Kafka') { -%>
+    const kafkaService = new KafkaService();
+<%_ } -%>
+    const server = app.listen(port, () => {
         logger.info(`Server running on port ${port}`);
 <%_ if (communication === 'Kafka') { -%>
-        const kafkaService = new KafkaService();
         kafkaService.connect().then(() => {
           logger.info('Kafka connected');
           kafkaService.sendMessage('test-topic', 'Hello Kafka from Clean Arch TS!');
@@ -104,6 +106,8 @@ const startServer = async () => {
         });
 <%_ } -%>
     });
+
+    setupGracefulShutdown(server<% if(communication === 'Kafka') { %>, kafkaService<% } %>);
 };
 
 <%_ if (database !== 'None') { -%>

package/templates/clean-architecture/ts/src/infrastructure/log/logger.spec.ts.ejs

@@ -0,0 +1,64 @@
+jest.mock('winston-daily-rotate-file');
+jest.mock('winston', () => {
+    const mockLogger = {
+        add: jest.fn(),
+        info: jest.fn(),
+        error: jest.fn(),
+        warn: jest.fn()
+    };
+    const format = {
+        combine: jest.fn(),
+        timestamp: jest.fn(),
+        json: jest.fn(),
+        simple: jest.fn()
+    };
+    const transports = {
+        Console: jest.fn(),
+        DailyRotateFile: jest.fn()
+    };
+    return {
+        format,
+        transports,
+        createLogger: jest.fn().mockReturnValue(mockLogger)
+    };
+});
+
+<% if (architecture === 'MVC') { -%>
+import logger from '@/utils/logger';
+<% } else { -%>
+import logger from '@/infrastructure/log/logger';
+<% } -%>
+
+describe('Logger', () => {
+    it('should export a logger instance', () => {
+        expect(logger).toBeDefined();
+    });
+
+    it('should have info method', () => {
+        expect(typeof logger.info).toBe('function');
+    });
+
+    it('should have error method', () => {
+        expect(typeof logger.error).toBe('function');
+    });
+
+    it('should call info', () => {
+        logger.info('test message');
+        expect(logger.info).toHaveBeenCalledWith('test message');
+    });
+
+    it('should call error', () => {
+        logger.error('test error');
+        expect(logger.error).toHaveBeenCalledWith('test error');
+    });
+
+    it('should use JSON format in production environment', () => {
+        const winston = require('winston');
+        jest.resetModules();
+        process.env.NODE_ENV = 'production';
+        // eslint-disable-next-line @typescript-eslint/no-require-imports
+        require('<% if (architecture === "MVC") { %>@/utils/logger<% } else { %>@/infrastructure/log/logger<% } %>');
+        expect(winston.format.json).toHaveBeenCalled();
+        process.env.NODE_ENV = 'test';
+    });
+});

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

@@ -0,0 +1,85 @@
+import { UserRepository } from '@/infrastructure/repositories/UserRepository';
+import UserModel from '@/infrastructure/database/models/User';
+
+// Mock DB Model Database Layer
+jest.mock('@/infrastructure/database/models/User');
+
+describe('UserRepository', () => {
+    let userRepository: UserRepository;
+
+    beforeEach(() => {
+        userRepository = new UserRepository();
+        jest.clearAllMocks();
+    });
+
+    describe('save', () => {
+        it('should save and return a newly created user (Happy Path)', async () => {
+            // Arrange
+            const payload = { id: '', name: 'TestUser', email: 'test@example.com' };
+<%_ if (database === 'MongoDB') { -%>
+            const mockDbRecord = { _id: { toString: () => '1' }, name: 'TestUser', email: 'test@example.com' };
+            (UserModel.create as jest.Mock).mockResolvedValue(mockDbRecord);
+<%_ } else if (database === 'None') { -%>
+            (UserModel.create as jest.Mock).mockResolvedValue(payload);
+<%_ } else { -%>
+            const mockDbRecord = { id: '1', name: 'TestUser', email: 'test@example.com' };
+            (UserModel.create as jest.Mock).mockResolvedValue(mockDbRecord);
+<%_ } -%>
+
+            // Act
+            const result = await userRepository.save(payload);
+
+            // Assert
+<%_ if (database === 'None') { -%>
+            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 });
+<%_ } -%>
+        });
+
+        it('should throw an error when DB fails explicitly (Edge Case)', async () => {
+<%_ if (database === 'None') { -%>
+            // Mocks do not naturally fail 
+<%_ } else { -%>
+            // Arrange
+            const payload = { id: '', name: 'FailUser', email: 'fail@example.com' };
+            const error = new Error('DB Connection Refused');
+            (UserModel.create as jest.Mock).mockRejectedValue(error);
+
+            // Act & Assert
+            await expect(userRepository.save(payload)).rejects.toThrow(error);
+<%_ } -%>
+        });
+    });
+
+    describe('getUsers', () => {
+        it('should return a list of mapped UserEntities (Happy Path)', async () => {
+            // Arrange
+<%_ if (database === 'MongoDB') { -%>
+            const mockDbRecords = [{ _id: { toString: () => '1' }, name: 'User1', email: 'user1@example.com' }];
+            (UserModel.find as jest.Mock).mockResolvedValue(mockDbRecords);
+<%_ } else if (database === 'None') { -%>
+            const mockData = [{ id: '1', name: 'User1', email: 'user1@example.com' }];
+            (UserModel.find as jest.Mock).mockResolvedValue(mockData);
+<%_ } else { -%>
+            const mockDbRecords = [{ id: '1', name: 'User1', email: 'user1@example.com' }];
+            (UserModel.findAll as jest.Mock).mockResolvedValue(mockDbRecords);
+<%_ } -%>
+
+            // Act
+            const result = await userRepository.getUsers();
+
+            // Assert
+            expect(result).toHaveLength(1);
+            expect(result[0]).toEqual({ id: '1', name: 'User1', email: 'user1@example.com' });
+<%_ if (database !== 'None') { -%>
+<%_ if (database === 'MongoDB') { -%>
+            expect(UserModel.find).toHaveBeenCalled();
+<%_ } else { -%>
+            expect(UserModel.findAll).toHaveBeenCalled();
+<%_ } -%>
+<%_ } -%>
+        });
+    });
+});

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

@@ -7,8 +7,7 @@ export class UserRepository {
         const newUser = await UserModel.create({ name: user.name, email: user.email });
         return { id: newUser._id.toString(), name: newUser.name, email: newUser.email };
 <%_ } else if (database === 'None') { -%>
-        const newUser = { id: String(UserModel.mockData.length + 1), name: user.name, email: user.email };
-        UserModel.mockData.push(newUser);
+        const newUser = await UserModel.create(user);
         return newUser;
 <%_ } else { -%>
         const newUser = await UserModel.create({ name: user.name, email: user.email });
@@ -25,7 +24,7 @@ export class UserRepository {
             email: user.email
         }));
 <%_ } else if (database === 'None') { -%>
-        return UserModel.mockData;
+        return await UserModel.find();
 <%_ } else { -%>
         const users = await UserModel.findAll();
         return users.map(user => ({