nodejs-quickstart-structure 1.12.0 → 1.14.0

package/templates/mvc/js/src/controllers/userController.spec.js.ejs

@@ -0,0 +1,170 @@
+<% if (communication !== 'GraphQL') { -%>
+const HTTP_STATUS = require('@/utils/httpCodes');
+<% } -%>
+const { getUsers, createUser } = require('@/controllers/userController');
+const User = require('@/models/User');
+<%_ if (caching === 'Redis') { -%>
+const cacheService = require('@/config/redisClient');
+<%_ } else if (caching === 'Memory Cache') { -%>
+const cacheService = require('@/config/memoryCache');
+<%_ } -%>
+
+// Mock dependencies
+jest.mock('@/models/User');
+<%_ if (caching === 'Redis') { -%>
+jest.mock('@/config/redisClient', () => ({
+    getOrSet: jest.fn(),
+    del: jest.fn()
+}));
+<%_ } else if (caching === 'Memory Cache') { -%>
+jest.mock('@/config/memoryCache', () => ({
+    getOrSet: jest.fn(),
+    del: jest.fn()
+}));
+<%_ } -%>
+jest.mock('@/utils/logger');
+
+describe('UserController', () => {
+<% if (communication !== 'GraphQL') { -%>
+    let mockRequest;
+    let mockResponse;
+    let mockNext;
+<% } -%>
+
+    beforeEach(() => {
+<% if (communication !== 'GraphQL') { -%>
+        mockRequest = {};
+        mockResponse = {
+            json: jest.fn(),
+            status: jest.fn().mockReturnThis(),
+        };
+        mockNext = jest.fn();
+<% } -%>
+    });
+
+    afterEach(() => {
+        jest.clearAllMocks();
+    });
+
+    describe('getUsers', () => {
+        it('should return successfully (Happy Path)', async () => {
+            // Arrange
+            const usersMock = [{ id: '1', name: 'Test', email: 'test@example.com' }];
+<%_ if (caching === 'Redis' || caching === 'Memory Cache') { -%>
+            cacheService.getOrSet.mockResolvedValue(usersMock);
+<%_ } else { -%>
+<%_ if (database === 'MongoDB' || database === 'None') { -%>
+            User.find.mockResolvedValue(usersMock);
+<%_ } else { -%>
+            User.findAll.mockResolvedValue(usersMock);
+<%_ } -%>
+<%_ } -%>
+
+            // Act
+<% if (communication === 'GraphQL') { -%>
+            const result = await getUsers();
+
+            // Assert
+            expect(result).toEqual(usersMock);
+<% } else { -%>
+            await getUsers(mockRequest, mockResponse, mockNext);
+
+            // Assert
+            expect(mockResponse.json).toHaveBeenCalledWith(usersMock);
+<% } -%>
+        });
+
+        it('should handle errors correctly (Error Handling)', async () => {
+            // Arrange
+            const error = new Error('Database Error');
+<%_ if (caching === 'Redis' || caching === 'Memory Cache') { -%>
+            cacheService.getOrSet.mockRejectedValue(error);
+<%_ } else { -%>
+<%_ if (database === 'MongoDB' || database === 'None') { -%>
+            User.find.mockRejectedValue(error);
+<%_ } else { -%>
+            User.findAll.mockRejectedValue(error);
+<%_ } -%>
+<%_ } -%>
+
+            // Act & Assert
+<% if (communication === 'GraphQL') { -%>
+            await expect(getUsers()).rejects.toThrow(error);
+<% } else { -%>
+            await getUsers(mockRequest, mockResponse, mockNext);
+            expect(mockNext).toHaveBeenCalledWith(error);
+<% } -%>
+        });
+    });
+
+    describe('createUser', () => {
+        it('should successfully create a new user (Happy Path)', async () => {
+            // Arrange
+            const payload = { name: 'Alice', email: 'alice@example.com' };
+<% if (communication === 'GraphQL') { -%>
+            const dataArg = payload;
+<% } else { -%>
+            mockRequest.body = payload;
+<% } -%>
+            
+            const expectedUser = { id: '1', ...payload };
+<%_ if (database === 'MongoDB' || database === 'None') { -%>
+            User.create.mockResolvedValue(expectedUser);
+            <%_ if (database === 'None') { -%>User.mockData = [expectedUser];<%_ } -%>
+<%_ } else { -%>
+            User.create.mockResolvedValue(expectedUser);
+<%_ } -%>
+
+            // Act
+<% if (communication === 'GraphQL') { -%>
+            const result = await createUser(dataArg);
+
+            // Assert
+<%_ if (database === 'None') { -%>
+            expect(result.name).toBe(payload.name);
+            expect(result.email).toBe(payload.email);
+            expect(User.mockData.length).toBe(1);
+<%_ } else { -%>
+            expect(result).toEqual(expectedUser);
+            expect(User.create).toHaveBeenCalledWith(payload);
+<%_ } -%>
+<% } else { -%>
+            await createUser(mockRequest, mockResponse, mockNext);
+
+            // Assert
+            expect(mockResponse.status).toHaveBeenCalledWith(HTTP_STATUS.CREATED);
+<%_ if (database === 'None') { -%>
+            expect(mockResponse.json).toHaveBeenCalled();
+            expect(User.mockData.length).toBe(1);
+<%_ } else { -%>
+            expect(mockResponse.json).toHaveBeenCalledWith(expectedUser);
+            expect(User.create).toHaveBeenCalledWith(payload);
+<%_ } -%>
+<% } -%>
+<%_ if (caching === 'Redis' || caching === 'Memory Cache') { -%>
+            expect(cacheService.del).toHaveBeenCalledWith('users:all');
+<%_ } -%>
+        });
+
+        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' };
+<% if (communication === 'GraphQL') { -%>
+            const dataArg = payload;
+<% } else { -%>
+            mockRequest.body = payload;
+<% } -%>
+
+            User.create.mockRejectedValue(error);
+
+            // Act & Assert
+<% if (communication === 'GraphQL') { -%>
+            await expect(createUser(dataArg)).rejects.toThrow(error);
+<% } else { -%>
+            await createUser(mockRequest, mockResponse, mockNext);
+            expect(mockNext).toHaveBeenCalledWith(error);
+<% } -%>
+        });
+    });
+});

package/templates/mvc/js/src/errors/BadRequestError.js

@@ -1,5 +1,5 @@
 const { ApiError } = require('./ApiError');
-const { HTTP_STATUS } = require('../utils/httpCodes');
+const HTTP_STATUS = require('../utils/httpCodes');
 
 class BadRequestError extends ApiError {
   constructor(message = 'Bad request') {

package/templates/mvc/js/src/errors/BadRequestError.spec.js.ejs

@@ -0,0 +1,21 @@
+const { BadRequestError } = require('@/errors/BadRequestError');
+const { ApiError } = require('@/errors/ApiError');
+const HTTP_STATUS = require('@/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/mvc/js/src/errors/NotFoundError.js

@@ -1,5 +1,5 @@
 const { ApiError } = require('./ApiError');
-const { HTTP_STATUS } = require('../utils/httpCodes');
+const HTTP_STATUS = require('../utils/httpCodes');
 
 class NotFoundError extends ApiError {
   constructor(message = 'Resource not found') {

package/templates/mvc/js/src/errors/NotFoundError.spec.js.ejs

@@ -0,0 +1,21 @@
+const { NotFoundError } = require('@/errors/NotFoundError');
+const { ApiError } = require('@/errors/ApiError');
+const HTTP_STATUS = require('@/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/mvc/js/src/graphql/context.spec.js.ejs

@@ -0,0 +1,29 @@
+const { gqlContext } = require('@/graphql/context');
+const { resolvers } = require('@/graphql/resolvers');
+const { typeDefs } = require('@/graphql/typeDefs');
+
+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).toEqual({ token: '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).toEqual({ token: '' });
+  });
+});

package/templates/mvc/js/src/graphql/resolvers/user.resolvers.spec.js.ejs

@@ -0,0 +1,47 @@
+const { userResolvers } = require('@/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('@/controllers/userController', () => ({
+  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/mvc/js/src/index.js.ejs

@@ -1,6 +1,7 @@
 const express = require('express');
 const cors = require('cors');
-<%_ if (communication === 'REST APIs') { -%>const apiRoutes = require('./routes/api');<%_ } -%>
+<%_ if (communication === 'REST APIs') { -%>const apiRoutes = require('./routes/api');<%_ } %>
+const healthRoutes = require('./routes/healthRoute');
 <%_ if (communication === 'Kafka') { -%>const { connectKafka, sendMessage } = require('./services/kafkaService');<%_ } -%>
 <%_ if (communication === 'GraphQL') { -%>
 const { ApolloServer } = require('@apollo/server');
@@ -21,7 +22,7 @@ const app = express();
 const PORT = env.PORT;
 const logger = require('./utils/logger');
 const morgan = require('morgan');
-const { errorMiddleware } = require('./utils/error.middleware');
+const { errorMiddleware } = require('./utils/errorMiddleware');
 
 app.use(cors());
 app.use(express.json());
@@ -48,15 +49,13 @@ app.get('/', (req, res) => {
   });
 });
 <% } -%>
-app.get('/health', (req, res) => {
-  res.json({ status: 'UP' });
-});
+app.use('/health', healthRoutes);
 
 // Start Server Logic
 const startServer = async () => {
 <%_ if (communication === 'GraphQL') { -%>
     // GraphQL Setup
-    const server = new ApolloServer({
+    const apolloServer = new ApolloServer({
       typeDefs,
       resolvers,
       plugins: [ApolloServerPluginLandingPageLocalDefault({ embed: true })],
@@ -80,11 +79,11 @@ 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, () => {
+    const server = app.listen(PORT, () => {
         logger.info(`Server running on port ${PORT}`);
 <%_ if (communication === 'Kafka') { -%>
         connectKafka().then(() => {
@@ -95,6 +94,9 @@ const startServer = async () => {
         });
 <%_ } -%>
     });
+
+    const setupGracefulShutdown = require('./utils/gracefulShutdown');
+    setupGracefulShutdown(server);
 };
 
 <%_ if (database !== 'None') { -%>

package/templates/mvc/js/src/routes/api.spec.js.ejs

@@ -0,0 +1,36 @@
+const request = require('supertest');
+const express = require('express');
+const router = require('@/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('@/controllers/userController', () => ({
+  getUsers: (...args) => mockGetUsers(...args),
+  createUser: (...args) => mockCreateUser(...args)
+}));
+
+describe('ApiRoutes', () => {
+    let app;
+
+    beforeEach(() => {
+        app = express();
+        app.use(express.json());
+        app.use('/api', router);
+    });
+
+    it('GET /api/users should call controller.getUsers', async () => {
+        await request(app)
+            .get('/api/users');
+
+        expect(mockGetUsers).toHaveBeenCalledTimes(1);
+    });
+
+    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);
+    });
+});

package/templates/mvc/js/src/utils/logger.spec.js.ejs

@@ -0,0 +1,63 @@
+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') { -%>
+const logger = require('@/utils/logger');
+<% } else { -%>
+const logger = require('@/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';
+        require('@/utils/logger');
+        expect(winston.format.json).toHaveBeenCalled();
+        process.env.NODE_ENV = 'test';
+    });
+});

package/templates/mvc/ts/src/controllers/userController.spec.ts.ejs

@@ -0,0 +1,185 @@
+<% if (communication !== 'GraphQL') { -%>
+import { Request, Response, NextFunction } from 'express';
+import { HTTP_STATUS } from '@/utils/httpCodes';
+<% } -%>
+import { UserController } from '@/controllers/userController';
+import User from '@/models/User';
+<%_ if (caching === 'Redis') { -%>
+import cacheService from '@/config/redisClient';
+<%_ } else if (caching === 'Memory Cache') { -%>
+import cacheService from '@/config/memoryCache';
+<%_ } -%>
+
+// Mock dependencies
+jest.mock('@/models/User');
+<%_ if (caching === 'Redis') { -%>
+jest.mock('@/config/redisClient', () => ({
+    getOrSet: jest.fn(),
+    del: jest.fn()
+}));
+<%_ } else if (caching === 'Memory Cache') { -%>
+jest.mock('@/config/memoryCache', () => ({
+    getOrSet: jest.fn(),
+    del: jest.fn()
+}));
+<%_ } -%>
+jest.mock('@/utils/logger');
+
+describe('UserController', () => {
+    let userController: UserController;
+<% if (communication !== 'GraphQL') { -%>
+    let mockRequest: Partial<Request>;
+    let mockResponse: Partial<Response>;
+    let mockNext: NextFunction;
+<% } -%>
+
+    beforeEach(() => {
+        userController = new UserController();
+<% if (communication !== 'GraphQL') { -%>
+        mockRequest = {};
+        mockResponse = {
+            json: jest.fn(),
+            status: jest.fn().mockReturnThis(),
+        };
+        mockNext = jest.fn();
+<% } -%>
+    });
+
+    afterEach(() => {
+        jest.clearAllMocks();
+    });
+
+    describe('getUsers', () => {
+        it('should return successfully (Happy Path)', async () => {
+            // Arrange
+            const usersMock = [{ id: '1', name: 'Test', email: 'test@example.com' }];
+<%_ if (caching === 'Redis' || caching === 'Memory Cache') { -%>
+            (cacheService.getOrSet as jest.Mock).mockResolvedValue(usersMock);
+<%_ } else { -%>
+<%_ if (database === 'MongoDB' || database === 'None') { -%>
+            (User.find as jest.Mock).mockResolvedValue(usersMock);
+<%_ } else { -%>
+            (User.findAll as jest.Mock).mockResolvedValue(usersMock);
+<%_ } -%>
+<%_ } -%>
+
+            // Act
+<% if (communication === 'GraphQL') { -%>
+            const result = await userController.getUsers();
+
+            // Assert
+            expect(result).toEqual(usersMock);
+<% } else { -%>
+            await userController.getUsers(mockRequest as Request, mockResponse as Response, mockNext);
+
+            // Assert
+            expect(mockResponse.json).toHaveBeenCalledWith(usersMock);
+<% } -%>
+<%_ if (caching === 'Redis' || caching === 'Memory Cache') { -%>
+            expect(cacheService.getOrSet).toHaveBeenCalled();
+<%_ } else { -%>
+<%_ if (database === 'MongoDB') { -%>
+            expect(User.find).toHaveBeenCalled();
+<%_ } else if (database === 'None') { -%>
+            // No DB mock logic
+<%_ } else { -%>
+            expect(User.findAll).toHaveBeenCalled();
+<%_ } -%>
+<%_ } -%>
+        });
+
+        it('should handle errors correctly (Error Handling)', async () => {
+            // Arrange
+            const error = new Error('Database Error');
+<%_ if (caching === 'Redis' || caching === 'Memory Cache') { -%>
+            (cacheService.getOrSet as jest.Mock).mockRejectedValue(error);
+<%_ } else { -%>
+<%_ if (database === 'MongoDB' || database === 'None') { -%>
+            (User.find as jest.Mock).mockRejectedValue(error);
+<%_ } else { -%>
+            (User.findAll as jest.Mock).mockRejectedValue(error);
+<%_ } -%>
+<%_ } -%>
+
+            // Act & Assert
+<% if (communication === 'GraphQL') { -%>
+            await expect(userController.getUsers()).rejects.toThrow(error);
+<% } else { -%>
+            await userController.getUsers(mockRequest as Request, mockResponse as Response, mockNext);
+            expect(mockNext).toHaveBeenCalledWith(error);
+<% } -%>
+        });
+    });
+
+    describe('createUser', () => {
+        it('should successfully create a new user (Happy Path)', async () => {
+            // Arrange
+            const payload = { name: 'Alice', email: 'alice@example.com' };
+<% if (communication === 'GraphQL') { -%>
+            const dataArg = payload;
+<% } else { -%>
+            mockRequest.body = payload;
+<% } -%>
+            
+<%_ if (database === 'MongoDB' || database === 'None') { -%>
+            const expectedUser = { id: '1', ...payload };
+            (User.create as jest.Mock).mockResolvedValue(expectedUser);
+            <%_ if (database === 'None') { -%>User.mockData = [expectedUser];<%_ } -%>
+<%_ } else { -%>
+            const expectedUser = { id: '1', ...payload };
+            (User.create as jest.Mock).mockResolvedValue(expectedUser);
+<%_ } -%>
+
+            // Act
+<% if (communication === 'GraphQL') { -%>
+            const result = await userController.createUser(dataArg);
+
+            // Assert
+<%_ if (database === 'None') { -%>
+            expect(result.name).toBe(payload.name);
+            expect(result.email).toBe(payload.email);
+            expect(User.mockData.length).toBe(1);
+<%_ } else { -%>
+            expect(result).toEqual(expectedUser);
+            expect(User.create).toHaveBeenCalledWith(payload);
+<%_ } -%>
+<% } else { -%>
+            await userController.createUser(mockRequest as Request, mockResponse as Response, mockNext);
+
+            // Assert
+            expect(mockResponse.status).toHaveBeenCalledWith(HTTP_STATUS.CREATED);
+<%_ if (database === 'None') { -%>
+            expect(mockResponse.json).toHaveBeenCalled();
+            expect(User.mockData.length).toBe(1);
+<%_ } else { -%>
+            expect(mockResponse.json).toHaveBeenCalledWith(expectedUser);
+            expect(User.create).toHaveBeenCalledWith(payload);
+<%_ } -%>
+<% } -%>
+<%_ if (caching === 'Redis' || caching === 'Memory Cache') { -%>
+            expect(cacheService.del).toHaveBeenCalledWith('users:all');
+<%_ } -%>
+        });
+
+        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' };
+<% if (communication === 'GraphQL') { -%>
+            const dataArg = payload;
+<% } else { -%>
+            mockRequest.body = payload;
+<% } -%>
+
+            (User.create as jest.Mock).mockRejectedValue(error);
+
+            // Act & Assert
+<% if (communication === 'GraphQL') { -%>
+            await expect(userController.createUser(dataArg)).rejects.toThrow(error);
+<% } else { -%>
+            await userController.createUser(mockRequest as Request, mockResponse as Response, mockNext);
+            expect(mockNext).toHaveBeenCalledWith(error);
+<% } -%>
+        });
+    });
+});