nodejs-quickstart-structure 1.12.0 → 1.14.0

package/templates/common/shutdown/js/gracefulShutdown.spec.js.ejs

@@ -0,0 +1,160 @@
+<%_ 
+let loggerPath = '@/utils/logger';
+let dbPath = '@/config/database';
+let redisPath = '@/config/redisClient';
+let kafkaPath = '@/services/kafkaService';
+
+if (architecture === 'Clean Architecture') {
+    loggerPath = '@/infrastructure/log/logger';
+    dbPath = '@/infrastructure/database/database';
+    redisPath = '@/infrastructure/caching/redisClient';
+    kafkaPath = '@/infrastructure/messaging/kafkaClient';
+}
+_%>
+const setupGracefulShutdown = require('@/utils/gracefulShutdown');
+
+<%_ if (database === 'MongoDB') { -%>
+jest.mock('mongoose', () => {
+    return {
+        connection: {
+            close: jest.fn().mockResolvedValue(true)
+        }
+    };
+});
+<%_ } else if (database !== 'None') { -%>
+jest.mock('<%- dbPath %>', () => {
+    return {
+        close: jest.fn().mockResolvedValue(true)
+    };
+});
+<%_ } -%>
+
+<%_ if (caching === 'Redis') { -%>
+jest.mock('<%- redisPath %>', () => {
+    return {
+        quit: jest.fn().mockResolvedValue(true)
+    };
+});
+<%_ } -%>
+
+<%_ if (communication === 'Kafka') { -%>
+jest.mock('<%- kafkaPath %>', () => {
+    return {
+        disconnectKafka: jest.fn().mockResolvedValue(true)
+    };
+});
+<%_ } -%>
+
+const flushPromises = () => new Promise((resolve) => setImmediate(resolve));
+
+describe('Graceful Shutdown', () => {
+    let mockServer;
+    let mockExit;
+    let processListeners;
+
+    beforeEach(() => {
+        jest.useFakeTimers({ legacyFakeTimers: true });
+        jest.clearAllMocks();
+        processListeners = {};
+
+        mockServer = {
+            close: jest.fn().mockImplementation((cb) => {
+                if (cb) Promise.resolve().then(() => cb());
+                return mockServer;
+            })
+        };
+
+        mockExit = jest.spyOn(process, 'exit').mockImplementation(() => {});
+        jest.spyOn(process, 'on').mockImplementation((event, handler) => {
+            processListeners[event] = handler;
+            return process;
+        });
+    });
+
+    afterEach(() => {
+        jest.restoreAllMocks();
+        jest.useRealTimers();
+    });
+
+    it('should register SIGTERM and SIGINT events', () => {
+        setupGracefulShutdown(mockServer);
+        expect(processListeners['SIGTERM']).toBeDefined();
+        expect(processListeners['SIGINT']).toBeDefined();
+    });
+
+    it('should cleanly shutdown all connections and exit 0', async () => {
+        setupGracefulShutdown(mockServer);
+        
+        processListeners['SIGTERM']();
+        
+        await flushPromises();
+        await flushPromises();
+        await flushPromises();
+
+        expect(mockServer.close).toHaveBeenCalled();
+
+        <%_ if (database === 'MongoDB') { -%>
+        const mongoose = require('mongoose');
+        expect(mongoose.connection.close).toHaveBeenCalledWith(false);
+        <%_ } else if (database !== 'None') { -%>
+        const sequelize = require('<%- dbPath %>');
+        expect(sequelize.close).toHaveBeenCalled();
+        <%_ } -%>
+
+        <%_ if (caching === 'Redis') { -%>
+        const redisService = require('<%- redisPath %>');
+        expect(redisService.quit).toHaveBeenCalled();
+        <%_ } -%>
+
+        <%_ if (communication === 'Kafka') { -%>
+        const { disconnectKafka } = require('<%- kafkaPath %>');
+        expect(disconnectKafka).toHaveBeenCalled();
+        <%_ } -%>
+
+        expect(mockExit).toHaveBeenCalledWith(0);
+    });
+
+    it('should exit 0 on SIGINT', async () => {
+        setupGracefulShutdown(mockServer);
+        processListeners['SIGINT']();
+        await flushPromises();
+        await flushPromises();
+        expect(mockExit).toHaveBeenCalledWith(0);
+    });
+
+<%_ if (communication === 'Kafka' || database !== 'None' || caching === 'Redis') { _%>
+    it('should handle errors during shutdown and exit 1', async () => {
+        <%_ if (communication === 'Kafka') { _%>
+        const { disconnectKafka } = require('<%- kafkaPath %>');
+        disconnectKafka.mockRejectedValueOnce(new Error('Shutdown Error'));
+        <%_ } else if (database === 'MongoDB') { _%>
+        const mongoose = require('mongoose');
+        mongoose.connection.close = jest.fn().mockRejectedValueOnce(new Error('Shutdown Error'));
+        <%_ } else if (database !== 'None') { _%>
+        const sequelize = require('<%- dbPath %>');
+        sequelize.close = jest.fn().mockRejectedValueOnce(new Error('Shutdown Error'));
+        <%_ } else if (caching === 'Redis') { _%>
+        const redisService = require('<%- redisPath %>');
+        redisService.quit = jest.fn().mockRejectedValueOnce(new Error('Shutdown Error'));
+        <%_ } _%>
+
+        setupGracefulShutdown(mockServer);
+        processListeners['SIGTERM']();
+        
+        await flushPromises();
+        await flushPromises();
+        await flushPromises();
+
+        expect(mockExit).toHaveBeenCalledWith(1);
+    });
+
+    it('should forcefully shutdown if cleanup takes too long', async () => {
+        setupGracefulShutdown(mockServer);
+        processListeners['SIGTERM']();
+        
+        jest.advanceTimersByTime(15000);
+        
+        expect(mockExit).toHaveBeenCalledWith(1);
+    });
+<%_ } _%>
+});

package/templates/common/shutdown/ts/gracefulShutdown.spec.ts.ejs

@@ -0,0 +1,158 @@
+import { setupGracefulShutdown } from '@/utils/gracefulShutdown';
+import { Server } from 'http';
+<%_ if (database === 'MongoDB') { -%>
+import mongoose from 'mongoose';
+<%_ } else if (database !== 'None') { -%>
+import sequelize from '<% if (architecture === "MVC") { %>@/config/database<% } else { %>@/infrastructure/database/database<% } %>';
+<%_ } -%>
+<%_ if (caching === 'Redis') { -%>
+import redisService from '<% if (architecture === "MVC") { %>@/config/redisClient<% } else { %>@/infrastructure/caching/redisClient<% } %>';
+<%_ } -%>
+
+<%_ if (database === 'MongoDB') { -%>
+jest.mock('mongoose', () => {
+    return {
+        __esModule: true,
+        default: {
+            connection: {
+                close: jest.fn().mockResolvedValue(true)
+            }
+        }
+    };
+});
+<%_ } else if (database !== 'None') { -%>
+jest.mock('<% if (architecture === "MVC") { %>@/config/database<% } else { %>@/infrastructure/database/database<% } %>', () => {
+    return {
+        __esModule: true,
+        default: {
+            close: jest.fn().mockResolvedValue(true)
+        }
+    };
+});
+<%_ } -%>
+
+<%_ if (caching === 'Redis') { -%>
+jest.mock('<% if (architecture === "MVC") { %>@/config/redisClient<% } else { %>@/infrastructure/caching/redisClient<% } %>', () => {
+    return {
+        __esModule: true,
+        default: {
+            quit: jest.fn().mockResolvedValue(true)
+        }
+    };
+});
+<%_ } -%>
+
+const flushPromises = () => new Promise((resolve) => setImmediate(resolve));
+
+describe('Graceful Shutdown', () => {
+    let mockServer: Partial<Server>;
+    let mockExit: jest.SpyInstance;
+    let processListeners: Record<string, (...args: any[]) => void>;
+    <%_ if (communication === 'Kafka') { -%>
+    let mockKafkaService: { disconnect: jest.Mock };
+    <%_ } -%>
+
+    beforeEach(() => {
+        jest.useFakeTimers({ legacyFakeTimers: true });
+        jest.clearAllMocks();
+        processListeners = {};
+
+        mockServer = {
+            close: jest.fn().mockImplementation((cb?: (err?: Error) => void) => {
+                if (cb) Promise.resolve().then(() => cb());
+                return mockServer;
+            })
+        };
+
+        mockExit = jest.spyOn(process, 'exit').mockImplementation((() => {}) as any);
+        jest.spyOn(process, 'on').mockImplementation(((event: string, handler: (...args: any[]) => void) => {
+            processListeners[event] = handler;
+            return process;
+        }) as any);
+
+        <%_ if (communication === 'Kafka') { -%>
+        mockKafkaService = { disconnect: jest.fn().mockResolvedValue(true) };
+        <%_ } -%>
+    });
+
+    afterEach(() => {
+        jest.restoreAllMocks();
+        jest.useRealTimers();
+    });
+
+    it('should register SIGTERM and SIGINT events', () => {
+        setupGracefulShutdown(mockServer as Server<% if (communication === 'Kafka') { %>, mockKafkaService<% } %>);
+        expect(processListeners['SIGTERM']).toBeDefined();
+        expect(processListeners['SIGINT']).toBeDefined();
+    });
+
+    it('should cleanly shutdown all connections and exit 0 on SIGTERM', async () => {
+        setupGracefulShutdown(mockServer as Server<% if (communication === 'Kafka') { %>, mockKafkaService<% } %>);
+        
+        processListeners['SIGTERM']();
+        
+        // Flush microtask queue multiple times for nested async operations
+        await flushPromises();
+        await flushPromises();
+        await flushPromises();
+
+        expect(mockServer.close).toHaveBeenCalled();
+
+        <%_ if (database === 'MongoDB') { -%>
+        expect(mongoose.connection.close).toHaveBeenCalledWith(false);
+        <%_ } else if (database !== 'None') { -%>
+        expect(sequelize.close).toHaveBeenCalled();
+        <%_ } -%>
+
+        <%_ if (caching === 'Redis') { -%>
+        expect(redisService.quit).toHaveBeenCalled();
+        <%_ } -%>
+
+        <%_ if (communication === 'Kafka') { -%>
+        expect(mockKafkaService.disconnect).toHaveBeenCalled();
+        <%_ } -%>
+
+        expect(mockExit).toHaveBeenCalledWith(0);
+    });
+
+    it('should exit 0 on SIGINT', async () => {
+        setupGracefulShutdown(mockServer as Server<% if (communication === 'Kafka') { %>, mockKafkaService<% } %>);
+        processListeners['SIGINT']();
+        await flushPromises();
+        await flushPromises();
+        expect(mockExit).toHaveBeenCalledWith(0);
+    });
+
+<%_ if (communication === 'Kafka' || database !== 'None' || caching === 'Redis') { _%>
+    it('should handle errors during shutdown and exit 1', async () => {
+        <%_ if (communication === 'Kafka') { _%>
+        mockKafkaService.disconnect.mockRejectedValueOnce(new Error('Shutdown Error'));
+        <%_ } else if (database === 'MongoDB') { _%>
+        (mongoose.connection.close as jest.Mock).mockRejectedValueOnce(new Error('Shutdown Error'));
+        <%_ } else if (database !== 'None') { _%>
+        (sequelize.close as jest.Mock).mockRejectedValueOnce(new Error('Shutdown Error'));
+        <%_ } else if (caching === 'Redis') { _%>
+        (redisService.quit as jest.Mock).mockRejectedValueOnce(new Error('Shutdown Error'));
+        <%_ } _%>
+
+        setupGracefulShutdown(mockServer as Server<% if (communication === 'Kafka') { %>, mockKafkaService<% } %>);
+        processListeners['SIGTERM']();
+        
+        await flushPromises();
+        await flushPromises();
+        await flushPromises();
+
+        expect(mockExit).toHaveBeenCalledWith(1);
+    });
+
+    it('should forcefully shutdown if cleanup takes too long', async () => {
+        setupGracefulShutdown(mockServer as Server<% if (communication === 'Kafka') { %>, mockKafkaService<% } %>);
+        processListeners['SIGTERM']();
+        
+        jest.advanceTimersByTime(15000);
+        
+        expect(mockExit).toHaveBeenCalledWith(1);
+    });
+<%_ } _%>
+
+});

package/templates/common/shutdown/ts/gracefulShutdown.ts.ejs

@@ -0,0 +1,58 @@
+import { Server } from 'http';
+<%_ if (architecture === 'MVC') { -%>
+import logger from '@/utils/logger';
+<%_ } else { -%>
+import logger from '@/infrastructure/log/logger';
+<%_ } -%>
+
+export const setupGracefulShutdown = (server: Server<% if (communication === 'Kafka') { %>, kafkaService: { disconnect: () => Promise<void> }<% } %>) => {
+    const gracefulShutdown = async (signal: string) => {
+        logger.info(`Received ${signal}. Shutting down gracefully...`);
+        server.close(async () => {
+            logger.info('HTTP server closed.');
+            try {
+<%_ if (database !== 'None') { -%>
+<%_ if (database === 'MongoDB') { -%>
+                const mongoose = (await import('mongoose')).default;
+                await mongoose.connection.close(false);
+                logger.info('MongoDB connection closed.');
+<%_ } else { -%>
+                <%_ if (architecture === 'MVC') { -%>
+                const sequelize = (await import('@/config/database')).default;
+                <%_ } else { -%>
+                const sequelize = (await import('@/infrastructure/database/database')).default;
+                <%_ } -%>
+                await sequelize.close();
+                logger.info('Database connection closed.');
+<%_ } -%>
+<%_ } -%>
+<%_ if (caching === 'Redis') { -%>
+                <%_ if (architecture === 'MVC') { -%>
+                const redisService = (await import('@/config/redisClient')).default;
+                <%_ } else { -%>
+                const redisService = (await import('@/infrastructure/caching/redisClient')).default;
+                <%_ } -%>
+                await redisService.quit();
+                logger.info('Redis connection closed.');
+<%_ } -%>
+<%_ if (communication === 'Kafka') { -%>
+                await kafkaService.disconnect();
+                logger.info('Kafka connection closed.');
+<%_ } -%>
+                logger.info('Graceful shutdown fully completed.');
+                process.exit(0);
+            } catch (err) {
+                logger.error('Error during shutdown:', err);
+                process.exit(1);
+            }
+        });
+
+        setTimeout(() => {
+            logger.error('Could not close connections in time, forcefully shutting down');
+            process.exit(1);
+        }, 15000);
+    };
+
+    process.on('SIGTERM', () => gracefulShutdown('SIGTERM'));
+    process.on('SIGINT', () => gracefulShutdown('SIGINT'));
+};

package/templates/common/src/utils/errorMiddleware.spec.js.ejs

@@ -0,0 +1,79 @@
+const { errorMiddleware } = require('<% if (architecture === "MVC") { %>@/utils/errorMiddleware<% } else { %>@/infrastructure/webserver/middleware/errorMiddleware<% } %>');
+const { ApiError } = require('@/errors/ApiError');
+const HTTP_STATUS = require('@/utils/httpCodes');
+const logger = require('<% if (architecture === "MVC") { %>@/utils/logger<% } else { %>@/infrastructure/log/logger<% } %>');
+
+jest.mock('<% if (architecture === "MVC") { %>@/utils/logger<% } else { %>@/infrastructure/log/logger<% } %>');
+
+describe('Error Middleware', () => {
+    let mockRequest;
+    let mockResponse;
+    let nextFunction;
+    const originalEnv = process.env.NODE_ENV;
+
+    beforeEach(() => {
+        mockRequest = {
+            originalUrl: '/test',
+            method: 'GET',
+            ip: '127.0.0.1'
+        };
+        mockResponse = {
+            status: jest.fn().mockReturnThis(),
+            json: jest.fn()
+        };
+        nextFunction = jest.fn();
+        jest.clearAllMocks();
+    });
+
+    afterEach(() => {
+        process.env.NODE_ENV = originalEnv;
+    });
+
+    it('should handle standard Error by wrapping it in a 500 ApiError', () => {
+        const error = new Error('Standard Error');
+        errorMiddleware(error, mockRequest, mockResponse, nextFunction);
+
+        expect(logger.error).toHaveBeenCalled();
+        expect(mockResponse.status).toHaveBeenCalledWith(HTTP_STATUS.INTERNAL_SERVER_ERROR);
+    });
+
+    it('should handle custom ApiError directly', () => {
+        const customError = new ApiError(HTTP_STATUS.BAD_REQUEST, 'Bad Request Data', true);
+        errorMiddleware(customError, mockRequest, mockResponse, nextFunction);
+
+        expect(mockResponse.status).toHaveBeenCalledWith(HTTP_STATUS.BAD_REQUEST);
+        expect(mockResponse.json).toHaveBeenCalledWith(expect.objectContaining({
+            statusCode: HTTP_STATUS.BAD_REQUEST,
+            message: 'Bad Request Data'
+        }));
+    });
+
+    it('should include stack trace in development environment', () => {
+        process.env.NODE_ENV = 'development';
+        const error = new Error('Test Error');
+        errorMiddleware(error, mockRequest, mockResponse, nextFunction);
+
+        expect(mockResponse.json).toHaveBeenCalledWith(expect.objectContaining({
+            stack: expect.any(String)
+        }));
+    });
+
+    it('should omit stack trace in production environment', () => {
+        process.env.NODE_ENV = 'production';
+        const error = new Error('Test Error');
+        errorMiddleware(error, mockRequest, mockResponse, nextFunction);
+
+        const jsonArg = mockResponse.json.mock.calls[0][0];
+        expect(jsonArg.stack).toBeUndefined();
+    });
+
+    it('should handle error without stack trace', () => {
+        const { ApiError } = require('@/errors/ApiError');
+        const customError = new ApiError(500, 'No Stack', false);
+        delete customError.stack;
+        errorMiddleware(customError, mockRequest, mockResponse, nextFunction);
+
+        expect(logger.error).toHaveBeenCalledWith(expect.stringContaining('No Stack'));
+        expect(logger.error).toHaveBeenCalledWith('No stack trace');
+    });
+});

package/templates/common/src/utils/errorMiddleware.spec.ts.ejs

@@ -0,0 +1,94 @@
+import { errorMiddleware } from '<% if (architecture === "MVC" || language === "TypeScript") { %>@/utils/errorMiddleware<% } else { %>@/infrastructure/webserver/middleware/errorMiddleware<% } %>';
+import { Request, Response } from 'express';
+import { ApiError } from '@/errors/ApiError';
+import { HTTP_STATUS } from '@/utils/httpCodes';
+import logger from '<% if (architecture === "MVC") { %>@/utils/logger<% } else { %>@/infrastructure/log/logger<% } %>';
+
+jest.mock('<% if (architecture === "MVC") { %>@/utils/logger<% } else { %>@/infrastructure/log/logger<% } %>');
+
+describe('Error Middleware', () => {
+    let mockRequest: Partial<Request>;
+    let mockResponse: Partial<Response>;
+    let nextFunction: jest.Mock;
+    const originalEnv = process.env.NODE_ENV;
+
+    beforeEach(() => {
+        mockRequest = {
+            originalUrl: '/test',
+            method: 'GET',
+            ip: '127.0.0.1'
+        };
+        mockResponse = {
+            status: jest.fn().mockReturnThis(),
+            json: jest.fn()
+        };
+        nextFunction = jest.fn();
+        jest.clearAllMocks();
+    });
+
+    afterEach(() => {
+        process.env.NODE_ENV = originalEnv;
+    });
+
+    it('should handle standard Error by wrapping it in a 500 ApiError', () => {
+        const error = new Error('Standard Error');
+        errorMiddleware(error, mockRequest as Request, mockResponse as Response, nextFunction);
+
+        expect(logger.error).toHaveBeenCalled();
+        expect(mockResponse.status).toHaveBeenCalledWith(HTTP_STATUS.INTERNAL_SERVER_ERROR);
+        expect(mockResponse.json).toHaveBeenCalledWith(expect.objectContaining({
+            statusCode: HTTP_STATUS.INTERNAL_SERVER_ERROR,
+            message: 'Standard Error'
+        }));
+    });
+
+    it('should default to Internal Server Error message if none provided on Error', () => {
+        const error = new Error();
+        errorMiddleware(error, mockRequest as Request, mockResponse as Response, nextFunction);
+
+        expect(mockResponse.status).toHaveBeenCalledWith(HTTP_STATUS.INTERNAL_SERVER_ERROR);
+        expect(mockResponse.json).toHaveBeenCalledWith(expect.objectContaining({
+            message: 'Internal Server Error'
+        }));
+    });
+
+    it('should handle custom ApiError directly', () => {
+        const customError = new ApiError(HTTP_STATUS.BAD_REQUEST, 'Bad Request Data', true);
+        errorMiddleware(customError, mockRequest as Request, mockResponse as Response, nextFunction);
+
+        expect(logger.error).not.toHaveBeenCalled();
+        expect(mockResponse.status).toHaveBeenCalledWith(HTTP_STATUS.BAD_REQUEST);
+        expect(mockResponse.json).toHaveBeenCalledWith(expect.objectContaining({
+            statusCode: HTTP_STATUS.BAD_REQUEST,
+            message: 'Bad Request Data'
+        }));
+    });
+
+    it('should include stack trace in development environment', () => {
+        process.env.NODE_ENV = 'development';
+        const error = new Error('Test Error');
+        errorMiddleware(error, mockRequest as Request, mockResponse as Response, nextFunction);
+
+        expect(mockResponse.json).toHaveBeenCalledWith(expect.objectContaining({
+            stack: expect.any(String)
+        }));
+    });
+
+    it('should omit stack trace in production environment', () => {
+        process.env.NODE_ENV = 'production';
+        const error = new Error('Test Error');
+        errorMiddleware(error, mockRequest as Request, mockResponse as Response, nextFunction);
+
+        const jsonArg = (mockResponse.json as jest.Mock).mock.calls[0][0];
+        expect(jsonArg.stack).toBeUndefined();
+    });
+
+    it('should handle error without stack trace', () => {
+        const customError = new ApiError(HTTP_STATUS.INTERNAL_SERVER_ERROR, 'No Stack', false);
+        delete customError.stack;
+        errorMiddleware(customError, mockRequest as Request, mockResponse as Response, nextFunction);
+
+        expect(logger.error).toHaveBeenCalledWith(expect.stringContaining('No Stack'));
+        expect(logger.error).toHaveBeenCalledWith('No stack trace');
+    });
+});

package/templates/common/tsconfig.json

@@ -18,6 +18,6 @@
     ],
     "exclude": [
         "node_modules",
-        "**/*.test.ts"
+        "dist"
     ]
 }

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

@@ -14,19 +14,15 @@ const getUsers = async () => {
   try {
 <%_ if (caching === 'Redis' || caching === 'Memory Cache') { -%>
     const users = await cacheService.getOrSet('users:all', async () => {
-<%_ if (database === 'MongoDB') { -%>
+<%_ if (database === 'MongoDB' || database === 'None') { -%>
         return await User.find();
-<%_ } else if (database === 'None') { -%>
-        return User.mockData;
 <%_ } else { -%>
         return await User.findAll();
 <%_ } -%>
     }, 60);
 <%_ } else { -%>
-<%_ if (database === 'MongoDB') { -%>
+<%_ if (database === 'MongoDB' || database === 'None') { -%>
     const users = await User.find();
-<%_ } else if (database === 'None') { -%>
-    const users = User.mockData;
 <%_ } else { -%>
     const users = await User.findAll();
 <%_ } -%>
@@ -41,20 +37,11 @@ const getUsers = async () => {
 const createUser = async (data) => {
   try {
     const { name, email } = data;
-<%_ if (database === 'None') { -%>
-    const newUser = { id: String(User.mockData.length + 1), name, email };
-    User.mockData.push(newUser);
-<%_ if (caching === 'Redis' || caching === 'Memory Cache') { -%>
-    await cacheService.del('users:all');
-<%_ } -%>
-    return newUser;
-<%_ } else { -%>
     const user = await User.create({ name, email });
 <%_ if (caching === 'Redis' || caching === 'Memory Cache') { -%>
     await cacheService.del('users:all');
 <%_ } -%>
     return user;
-<%_ } -%>
   } catch (error) {
     logger.error('Error creating user:', error);
     throw error;
@@ -65,19 +52,15 @@ const getUsers = async (req, res, next) => {
   try {
 <%_ if (caching === 'Redis' || caching === 'Memory Cache') { -%>
     const users = await cacheService.getOrSet('users:all', async () => {
-<%_ if (database === 'MongoDB') { -%>
+<%_ if (database === 'MongoDB' || database === 'None') { -%>
         return await User.find();
-<%_ } else if (database === 'None') { -%>
-        return User.mockData;
 <%_ } else { -%>
         return await User.findAll();
 <%_ } -%>
     }, 60);
 <%_ } else { -%>
-<%_ if (database === 'MongoDB') { -%>
+<%_ if (database === 'MongoDB' || database === 'None') { -%>
     const users = await User.find();
-<%_ } else if (database === 'None') { -%>
-    const users = User.mockData;
 <%_ } else { -%>
     const users = await User.findAll();
 <%_ } -%>
@@ -92,20 +75,11 @@ const getUsers = async (req, res, next) => {
 const createUser = async (req, res, next) => {
   try {
     const { name, email } = req.body;
-<%_ if (database === 'None') { -%>
-    const newUser = { id: String(User.mockData.length + 1), name, email };
-    User.mockData.push(newUser);
-<%_ if (caching === 'Redis' || caching === 'Memory Cache') { -%>
-    await cacheService.del('users:all');
-<%_ } -%>
-    res.status(HTTP_STATUS.CREATED).json(newUser);
-<%_ } else { -%>
     const user = await User.create({ name, email });
 <%_ if (caching === 'Redis' || caching === 'Memory Cache') { -%>
     await cacheService.del('users:all');
 <%_ } -%>
     res.status(HTTP_STATUS.CREATED).json(user);
-<%_ } -%>
   } catch (error) {
     logger.error('Error creating user:', error);
     next(error);
@@ -114,4 +88,3 @@ const createUser = async (req, res, next) => {
 <% } -%>
 
 module.exports = { getUsers, createUser };
-