nodejs-quickstart-structure 1.18.1 → 1.19.0

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

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

@@ -1,55 +1,59 @@
-import { Server } from 'http';
-<%_ if (architecture === 'MVC') { -%>
-import logger from '@/utils/logger';
-<%_ } else { -%>
-import logger from '@/infrastructure/log/logger';
-<%_ } -%>
-<%_ 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<% } %>';
-<%_ } -%>
-
-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') { -%>
-                await mongoose.connection.close(false);
-                logger.info('MongoDB connection closed.');
-<%_ } else { -%>
-                await sequelize.close();
-                logger.info('Database connection closed.');
-<%_ } -%>
-<%_ } -%>
-<%_ if (caching === 'Redis') { -%>
-                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'));
-};
+import { Server } from 'http';
+<%_ if (architecture === 'MVC') { -%>
+import logger from '@/utils/logger';
+<%_ } else { -%>
+import logger from '@/infrastructure/log/logger';
+<%_ } -%>
+<%_ 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<% } %>';
+<%_ } -%>
+
+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 (err: Error | undefined) => {
+            if (err) {
+                logger.error('Error closing HTTP server:', err);
+                process.exit(1);
+            }
+            logger.info('HTTP server closed.');
+            try {
+<%_ if (database !== 'None') { -%>
+<%_ if (database === 'MongoDB') { -%>
+                await mongoose.connection.close(false);
+                logger.info('MongoDB connection closed.');
+<%_ } else { -%>
+                await sequelize.close();
+                logger.info('Database connection closed.');
+<%_ } -%>
+<%_ } -%>
+<%_ if (caching === 'Redis') { -%>
+                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/tests/e2e/e2e.users.test.js.ejs

@@ -1,49 +1,120 @@
-const request = require('supertest');
-
-const SERVER_URL = process.env.TEST_URL || `http://127.0.0.1:${process.env.PORT || 3001}`;
-
-describe('E2E User Tests', () => {
-  // Global setup and teardown hooks can be added here
-  // typically for database seeding or external authentication checks prior to E2E.
-  const uniqueEmail = `test_${Date.now()}@example.com`;
-
-<%_ if (communication === 'GraphQL') { _%>
-  it('should create a user and verify flow via GraphQL', async () => {
-    const query = `
-      mutation {
-        createUser(name: "Test User", email: "${uniqueEmail}") {
-          id
-          name
-          email
-        }
-      }
-    `;
-    const response = await request(SERVER_URL)
-      .post('/graphql')
-      .send({ query });
-
-    expect(response.statusCode).toBe(200);
-  });
-<%_ } else if (communication === 'Kafka') { _%>
-  it('should trigger Kafka event for user creation', async () => {
-    const response = await request(SERVER_URL)
-      .post('/api/users')
-      .send({ name: 'Test User', email: uniqueEmail });
-
-    // Assuming the API returns 201 or 404 (if no REST endpoint is exposed in Kafka skeleton)
-    expect([201, 202, 404]).toContain(response.statusCode);
-    
-    // Wait for Kafka to process...
-    await new Promise(resolve => setTimeout(resolve, 1000));
-  });
-<%_ } else { _%>
-  it('should create a user successfully via REST', async () => {
-    const response = await request(SERVER_URL)
-      .post('/api/users')
-      .send({ name: 'Test User', email: uniqueEmail });
-
-    // E2E Tests must have strict and deterministic assertions
-    expect(response.statusCode).toBe(201);
-  });
-<%_ } _%>
-});
+const request = require('supertest');
+
+const SERVER_URL = process.env.TEST_URL || `http://127.0.0.1:${process.env.PORT || 3001}`;
+
+describe('E2E User Tests', () => {
+  // Global setup and teardown hooks can be added here
+  // typically for database seeding or external authentication checks prior to E2E.
+  let userId;
+  const uniqueEmail = `test_${Date.now()}@example.com`;
+
+<%_ if (communication === 'GraphQL') { -%>
+  it('should create a user via GraphQL', async () => {
+    const query = `
+      mutation {
+        createUser(name: "Test User", email: "${uniqueEmail}") {
+          id
+          name
+          email
+        }
+      }
+    `;
+    const response = await request(SERVER_URL)
+      .post('/graphql')
+      .send({ query });
+
+    expect(response.statusCode).toBe(200);
+    userId = response.body.data.createUser.id;
+    expect(userId).toBeDefined();
+  });
+
+  it('should update a user via GraphQL', async () => {
+    const query = `
+      mutation {
+        updateUser(id: "${userId}", name: "Updated User") {
+          id
+          name
+        }
+      }
+    `;
+    const response = await request(SERVER_URL)
+      .post('/graphql')
+      .send({ query });
+
+    expect(response.statusCode).toBe(200);
+    expect(response.body.data.updateUser.name).toBe("Updated User");
+  });
+
+  it('should delete a user via GraphQL', async () => {
+    const query = `
+      mutation {
+        deleteUser(id: "${userId}")
+      }
+    `;
+    const response = await request(SERVER_URL)
+      .post('/graphql')
+      .send({ query });
+
+    expect(response.statusCode).toBe(200);
+    expect(response.body.data.deleteUser).toBe(true);
+  });
+<%_ } else if (communication === 'Kafka') { -%>
+  it('should trigger Kafka event for user creation', async () => {
+    const response = await request(SERVER_URL)
+      .post('/api/users')
+      .send({ name: 'Test User', email: uniqueEmail });
+
+    expect([201, 202]).toContain(response.statusCode);
+    userId = response.body.id || response.body._id;
+    expect(userId).toBeDefined();
+
+    // Wait for Kafka to process...
+    await new Promise(resolve => setTimeout(resolve, 500));
+  });
+
+  it('should trigger Kafka event for user update', async () => {
+    const response = await request(SERVER_URL)
+      .patch(`/api/users/${userId}`)
+      .send({ name: 'Updated User' });
+
+    expect([200, 202, 204]).toContain(response.statusCode);
+
+    // Wait for Kafka to process...
+    await new Promise(resolve => setTimeout(resolve, 500));
+  });
+
+  it('should trigger Kafka event for user deletion', async () => {
+    const response = await request(SERVER_URL)
+      .delete(`/api/users/${userId}`);
+
+    expect([200, 202, 204]).toContain(response.statusCode);
+
+    // Wait for Kafka to process...
+    await new Promise(resolve => setTimeout(resolve, 500));
+  });
+<%_ } else { -%>
+  it('should create a user successfully via REST', async () => {
+    const response = await request(SERVER_URL)
+      .post('/api/users')
+      .send({ name: 'Test User', email: uniqueEmail });
+
+    expect(response.statusCode).toBe(201);
+    userId = response.body.id || response.body._id;
+  });
+
+  it('should update a user successfully via REST', async () => {
+    const response = await request(SERVER_URL)
+      .patch(`/api/users/${userId}`)
+      .send({ name: 'Updated User' });
+
+    expect(response.statusCode).toBe(200);
+  });
+
+  it('should delete a user successfully via REST', async () => {
+    const response = await request(SERVER_URL)
+      .delete(`/api/users/${userId}`);
+
+    expect(response.statusCode).toBe(200);
+  });
+<%_ } -%>
+});