nodejs-quickstart-structure 1.18.1 → 1.19.0

package/templates/common/kafka/ts/services/kafkaService.ts.ejs

@@ -1,95 +1,95 @@
-import { kafka } from '<%= configPath %>';
-import { EachMessagePayload, Producer, Consumer } from 'kafkajs';
-import logger from '<%= loggerPath %>';
-
-export class KafkaService {
-    private producer: Producer;
-    private consumer: Consumer;
-    private isConnected = false;
-    private connectionPromise: Promise<void> | null = null;
-
-    constructor() {
-        this.producer = kafka.producer();
-        this.consumer = kafka.consumer({ groupId: 'test-group' });
-    }
-
-    async connect(retries = 10) {
-        if (this.connectionPromise) return this.connectionPromise;
-
-        this.connectionPromise = (async () => {
-            let attempt = 0;
-            // Auto-register WelcomeEmailConsumer if it exists
-            // Note: Dynamic import used here for simplicity and to avoid startup crashes.
-            // In enterprise production, consider using Dependency Injection.
-            const { WelcomeEmailConsumer } = await import('<% if (architecture === "Clean Architecture") { %>@/interfaces/messaging/consumers/instances/welcomeEmailConsumer<% } else { %>@/messaging/consumers/instances/welcomeEmailConsumer<% } %>');
-            while (attempt < retries) {
-                try {
-                    await this.producer.connect();
-                    await this.consumer.connect();
-                    logger.info('[Kafka] Producer connected successfully');
-                    logger.info('[Kafka] Consumer connected successfully');
-                    this.isConnected = true;
-
-                    try {
-                        const welcomeConsumer = new WelcomeEmailConsumer();
-                        await this.consumer.subscribe({ topic: welcomeConsumer.topic, fromBeginning: true });
-                        logger.info(`[Kafka] Registered consumer for topic: ${welcomeConsumer.topic}`);
-                        
-                        await this.consumer.run({
-                            eachMessage: async (payload) => welcomeConsumer.onMessage(payload),
-                        });
-                    } catch (e) {
-                        // Fallback or no consumers found
-                        logger.warn(`[Kafka] Could not load WelcomeEmailConsumer, using fallback: ${(e as Error).message}`);
-                        await this.consumer.subscribe({ topic: 'user-topic', fromBeginning: true });
-                        await this.consumer.run({
-                            eachMessage: async ({ message }: EachMessagePayload) => {
-                                logger.info(`[Kafka] Consumer: Received message on user-topic: ${message.value?.toString()}`);
-                            },
-                        });
-                    }
-                    return; // Success
-                } catch (error) {
-                    attempt++;
-                    logger.error(`[Kafka] Connection attempt ${attempt} failed:`, (error as Error).message);
-                    if (attempt >= retries) {
-                        throw error;
-                    }
-                    await new Promise(res => setTimeout(res, 3000));
-                }
-            }
-        })();
-
-        return this.connectionPromise;
-    }
-
-    async sendMessage(topic: string, message: string) {
-        if (this.connectionPromise) {
-            await this.connectionPromise;
-        }
-
-        if (!this.isConnected) {
-            throw new Error('[Kafka] Producer not connected. Check logs for connection errors.');
-        }
-
-        await this.producer.send({
-            topic,
-            messages: [
-                { value: message },
-            ],
-        });
-        try {
-            const parsed = JSON.parse(message);
-            logger.info(`[Kafka] Producer: Sent ${parsed.action} event for '${parsed.payload?.email || 'unknown'}'`);
-        } catch {
-            logger.info(`[Kafka] Producer: Sent message to ${topic}`);
-        }
-    }
-
-    async disconnect() {
-        await this.producer.disconnect();
-        await this.consumer.disconnect();
-    }
-}
-
-export const kafkaService = new KafkaService();
+import { kafka } from '<%= configPath %>';
+import { EachMessagePayload, Producer, Consumer } from 'kafkajs';
+import logger from '<%= loggerPath %>';
+
+export class KafkaService {
+    private producer: Producer;
+    private consumer: Consumer;
+    private isConnected = false;
+    private connectionPromise: Promise<void> | null = null;
+
+    constructor() {
+        this.producer = kafka.producer();
+        this.consumer = kafka.consumer({ groupId: 'test-group' });
+    }
+
+    async connect(retries = 10) {
+        if (this.connectionPromise) return this.connectionPromise;
+
+        this.connectionPromise = (async () => {
+            let attempt = 0;
+            // Auto-register WelcomeEmailConsumer if it exists
+            // Note: Dynamic import used here for simplicity and to avoid startup crashes.
+            // In enterprise production, consider using Dependency Injection.
+            const { WelcomeEmailConsumer } = await import('<% if (architecture === "Clean Architecture") { %>@/interfaces/messaging/consumers/instances/welcomeEmailConsumer<% } else { %>@/messaging/consumers/instances/welcomeEmailConsumer<% } %>');
+            while (attempt < retries) {
+                try {
+                    await this.producer.connect();
+                    await this.consumer.connect();
+                    logger.info('[Kafka] Producer connected successfully');
+                    logger.info('[Kafka] Consumer connected successfully');
+                    this.isConnected = true;
+
+                    try {
+                        const welcomeConsumer = new WelcomeEmailConsumer();
+                        await this.consumer.subscribe({ topic: welcomeConsumer.topic, fromBeginning: true });
+                        logger.info(`[Kafka] Registered consumer for topic: ${welcomeConsumer.topic}`);
+                        
+                        await this.consumer.run({
+                            eachMessage: async (payload) => welcomeConsumer.onMessage(payload),
+                        });
+                    } catch (e) {
+                        // Fallback or no consumers found
+                        logger.warn(`[Kafka] Could not load WelcomeEmailConsumer, using fallback: ${(e as Error).message}`);
+                        await this.consumer.subscribe({ topic: 'user-topic', fromBeginning: true });
+                        await this.consumer.run({
+                            eachMessage: async ({ message }: EachMessagePayload) => {
+                                logger.info(`[Kafka] Consumer: Received message on user-topic: ${message.value?.toString()}`);
+                            },
+                        });
+                    }
+                    return; // Success
+                } catch (error) {
+                    attempt++;
+                    logger.error(`[Kafka] Connection attempt ${attempt} failed:`, (error as Error).message);
+                    if (attempt >= retries) {
+                        throw error;
+                    }
+                    await new Promise(res => setTimeout(res, 3000));
+                }
+            }
+        })();
+
+        return this.connectionPromise;
+    }
+
+    async sendMessage(topic: string, message: string, key?: string) {
+        if (this.connectionPromise) {
+            await this.connectionPromise;
+        }
+
+        if (!this.isConnected) {
+            throw new Error('[Kafka] Producer not connected. Check logs for connection errors.');
+        }
+
+        await this.producer.send({
+            topic,
+            messages: [
+                { key, value: message },
+            ],
+        });
+        try {
+            const parsed = JSON.parse(message);
+            logger.info(`[Kafka] Producer: Sent ${parsed.action} event for '${parsed.payload?.email || 'unknown'}'`);
+        } catch {
+            logger.info(`[Kafka] Producer: Sent message to ${topic}`);
+        }
+    }
+
+    async disconnect() {
+        await this.producer.disconnect();
+        await this.consumer.disconnect();
+    }
+}
+
+export const kafkaService = new KafkaService();

package/templates/common/kafka/ts/utils/kafkaEvents.ts.ejs

@@ -0,0 +1,5 @@
+export enum KAFKA_ACTIONS {
+    USER_CREATED = 'USER_CREATED',
+    USER_UPDATED = 'USER_UPDATED',
+    USER_DELETED = 'USER_DELETED'
+}

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

@@ -1,61 +1,65 @@
-<%_ 
-let loggerPath = './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 logger = require('<%- loggerPath %>');
-
-const setupGracefulShutdown = (server) => {
-    const gracefulShutdown = async (signal) => {
-        logger.info(`Received ${signal}. Shutting down gracefully...`);
-        server.close(async () => {
-            logger.info('HTTP server closed.');
-            try {
-<%_ if (database !== 'None') { -%>
-<%_ if (database === 'MongoDB') { -%>
-                const mongoose = require('mongoose');
-                await mongoose.connection.close(false);
-                logger.info('MongoDB connection closed.');
-<%_ } else { -%>
-                const sequelize = require('<%- dbPath %>');
-                await sequelize.close();
-                logger.info('Database connection closed.');
-<%_ } -%>
-<%_ } -%>
-<%_ if (caching === 'Redis') { -%>
-                const redisService = require('<%- redisPath %>');
-                await redisService.quit();
-                logger.info('Redis connection closed.');
-<%_ } -%>
-<%_ if (communication === 'Kafka') { -%>
-                const { disconnectKafka } = require('<%- kafkaPath %>');
-                await disconnectKafka();
-                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'));
-};
-
-module.exports = setupGracefulShutdown;
+<%_ 
+let loggerPath = './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 logger = require('<%- loggerPath %>');
+
+const setupGracefulShutdown = (server) => {
+    const gracefulShutdown = async (signal) => {
+        logger.info(`Received ${signal}. Shutting down gracefully...`);
+        server.close(async (err) => {
+            if (err) {
+                logger.error('Error closing HTTP server:', err);
+                process.exit(1);
+            }
+            logger.info('HTTP server closed.');
+            try {
+<%_ if (database !== 'None') { -%>
+<%_ if (database === 'MongoDB') { -%>
+                const mongoose = require('mongoose');
+                await mongoose.connection.close(false);
+                logger.info('MongoDB connection closed.');
+<%_ } else { -%>
+                const sequelize = require('<%- dbPath %>');
+                await sequelize.close();
+                logger.info('Database connection closed.');
+<%_ } -%>
+<%_ } -%>
+<%_ if (caching === 'Redis') { -%>
+                const redisService = require('<%- redisPath %>');
+                await redisService.quit();
+                logger.info('Redis connection closed.');
+<%_ } -%>
+<%_ if (communication === 'Kafka') { -%>
+                const { disconnectKafka } = require('<%- kafkaPath %>');
+                await disconnectKafka();
+                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'));
+};
+
+module.exports = setupGracefulShutdown;

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