nodejs-quickstart-structure 1.18.0 → 1.19.0

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

@@ -1,160 +1,149 @@
-<%_ 
-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);
-    });
-<%_ } _%>
-});
+<%_ 
+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);
+    });
+
+    it('should handle errors during shutdown and exit 1', async () => {
+        // Force server.close to fail to test the error path
+        mockServer.close.mockImplementationOnce((cb) => {
+            if (cb) Promise.resolve().then(() => cb(new Error('Server Close Error')));
+            return mockServer;
+        });
+
+        setupGracefulShutdown(mockServer);
+        processListeners['SIGTERM']();
+        
+        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

@@ -1,158 +1,179 @@
-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);
-    });
-<%_ } _%>
-
-});
+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'));
+        <%_ if (database === 'MongoDB') { -%>
+        (mongoose.connection.close as jest.Mock).mockResolvedValueOnce(true);
+        <%_ } else if (database !== 'None') { -%>
+        (sequelize.close as jest.Mock).mockResolvedValueOnce(true);
+        <%_ } -%>
+        <%_ } 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 handle server close errors', async () => {
+        const serverError = new Error('Server Close Error');
+        mockServer.close = jest.fn().mockImplementation((cb?: (err?: Error) => void) => {
+            if (cb) Promise.resolve().then(() => cb(serverError));
+            return mockServer;
+        });
+
+        setupGracefulShutdown(mockServer as Server<% if (communication === 'Kafka') { %>, mockKafkaService<% } %>);
+        processListeners['SIGTERM']();
+        
+        await flushPromises();
+        // Since it's inside server.close callback, we need to wait
+        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);
+    });
+<%_ } -%>
+});