nodejs-quickstart-structure 1.18.1 → 1.19.1

package/templates/common/kafka/ts/messaging/welcomeEmailConsumer.spec.ts.ejs

@@ -1,49 +1,86 @@
-import { WelcomeEmailConsumer } from '<% if (architecture === "Clean Architecture") { %>@/interfaces/messaging/consumers/instances/welcomeEmailConsumer<% } else { %>@/messaging/consumers/instances/welcomeEmailConsumer<% } %>';
-import logger from '<%= loggerPath %>';
-
-jest.mock('<%= loggerPath %>');
-
-describe('WelcomeEmailConsumer', () => {
-    let consumer: WelcomeEmailConsumer;
-
-    beforeEach(() => {
-        jest.clearAllMocks();
-        consumer = new WelcomeEmailConsumer();
-    });
-
-    it('should log welcome email simulation for USER_CREATED action', async () => {
-        const data = {
-            action: 'USER_CREATED',
-            payload: {
-                id: 1,
-                email: 'test@example.com'
-            }
-        };
-
-        await consumer.handle(data);
-
-        expect(logger.info).toHaveBeenCalledWith(
-            expect.stringContaining('[Kafka] Consumer: Received USER_CREATED.')
-        );
-        expect(logger.info).toHaveBeenCalledWith(
-            expect.stringContaining('📧 Sending welcome email to \'test@example.com\'... Done!')
-        );
-    });
-
-    it('should log error for invalid data', async () => {
-        const data = {
-            action: 'USER_CREATED',
-            payload: {
-                id: 1,
-                email: 'invalid-email'
-            }
-        };
-
-        await consumer.handle(data);
-
-        expect(logger.error).toHaveBeenCalledWith(
-            expect.stringContaining('[Kafka] Invalid user event data:'),
-            expect.anything()
-        );
-    });
-});
+import { WelcomeEmailConsumer } from '<% if (architecture === "Clean Architecture") { %>@/interfaces/messaging/consumers/instances/welcomeEmailConsumer<% } else { %>@/messaging/consumers/instances/welcomeEmailConsumer<% } %>';
+import logger from '<%= loggerPath %>';
+
+jest.mock('<%= loggerPath %>');
+
+describe('WelcomeEmailConsumer', () => {
+    let consumer: WelcomeEmailConsumer;
+
+    beforeEach(() => {
+        jest.clearAllMocks();
+        consumer = new WelcomeEmailConsumer();
+    });
+
+    it('should log welcome email simulation for USER_CREATED action', async () => {
+        const data = {
+            action: 'USER_CREATED',
+            payload: {
+                id: 1,
+                email: 'test@example.com'
+            }
+        };
+
+        await consumer.handle(data);
+
+        expect(logger.info).toHaveBeenCalledWith(
+            expect.stringContaining('[Kafka] Consumer: Received USER_CREATED.')
+        );
+        expect(logger.info).toHaveBeenCalledWith(
+            expect.stringContaining('📧 Sending welcome email to \'test@example.com\'... Done!')
+        );
+    });
+
+    it('should log update simulation for USER_UPDATED action', async () => {
+        const data = {
+            action: 'USER_UPDATED',
+            payload: {
+                id: 1,
+                email: 'updated@example.com'
+            }
+        };
+
+        await consumer.handle(data);
+
+        expect(logger.info).toHaveBeenCalledWith(
+            expect.stringContaining('[Kafka] Consumer: Received USER_UPDATED.')
+        );
+        expect(logger.info).toHaveBeenCalledWith(
+            expect.stringContaining('🔄 Updating user records for \'1\' (Email: updated@example.com)... Done!')
+        );
+    });
+
+    it('should log deletion simulation for USER_DELETED action', async () => {
+        const data = {
+            action: 'USER_DELETED',
+            payload: {
+                id: 1
+            }
+        };
+
+        await consumer.handle(data);
+
+        expect(logger.info).toHaveBeenCalledWith(
+            expect.stringContaining('[Kafka] Consumer: Received USER_DELETED.')
+        );
+        expect(logger.info).toHaveBeenCalledWith(
+            expect.stringContaining('🗑️ Cleaning up data for user \'1\'... Done!')
+        );
+    });
+
+    it('should log error for invalid data', async () => {
+        const data = {
+            action: 'USER_CREATED',
+            payload: {
+                id: 1,
+                email: 'invalid-email'
+            }
+        };
+
+        await consumer.handle(data);
+
+        expect(logger.error).toHaveBeenCalledWith(
+            expect.stringContaining('[Kafka] Invalid user event data:'),
+            expect.anything()
+        );
+    });
+});

package/templates/common/kafka/ts/messaging/welcomeEmailConsumer.ts.ejs

@@ -1,25 +1,38 @@
-import { BaseConsumer } from '<% if (architecture === "Clean Architecture") { %>@/interfaces/messaging/baseConsumer<% } else { %>@/messaging/baseConsumer<% } %>';
-import logger from '<%= loggerPath %>';
-import { UserEventSchema } from '<% if (architecture === "Clean Architecture") { %>@/interfaces/messaging/schemas/userEventSchema<% } else { %>@/messaging/schemas/userEventSchema<% } %>';
-
-export class WelcomeEmailConsumer extends BaseConsumer {
-  topic = 'user-topic';
-  groupId = 'welcome-email-group';
-
-  async handle(data: unknown) {
-    const result = UserEventSchema.safeParse(data);
-    
-    if (!result.success) {
-      logger.error('[Kafka] Invalid user event data:', result.error.format());
-      return;
-    }
-
-    const { action, payload } = result.data;
-
-    if (action === 'USER_CREATED') {
-      logger.info(`[Kafka] Consumer: Received USER_CREATED.`);
-      logger.info(`[Kafka] Consumer: 📧 Sending welcome email to '${payload.email}'... Done!`);
-      // In a real app, you would call an EmailService here
-    }
-  }
-}
+import { BaseConsumer } from '<% if (architecture === "Clean Architecture") { %>@/interfaces/messaging/baseConsumer<% } else { %>@/messaging/baseConsumer<% } %>';
+import logger from '<%= loggerPath %>';
+import { UserEventSchema } from '<% if (architecture === "Clean Architecture") { %>@/interfaces/messaging/schemas/userEventSchema<% } else { %>@/messaging/schemas/userEventSchema<% } %>';
+import { ERROR_MESSAGES } from '@/utils/errorMessages';
+import { KAFKA_ACTIONS } from '@/utils/kafkaEvents';
+
+export class WelcomeEmailConsumer extends BaseConsumer {
+  topic = 'user-topic';
+  groupId = 'welcome-email-group';
+
+  async handle(data: unknown) {
+    const result = UserEventSchema.safeParse(data);
+    
+    if (!result.success) {
+      logger.error(`[Kafka] ${ERROR_MESSAGES.INVALID_USER_DATA}:`, result.error.format());
+      return;
+    }
+
+    const { action, payload } = result.data;
+
+    switch (action) {
+      case KAFKA_ACTIONS.USER_CREATED:
+        logger.info(`[Kafka] Consumer: Received ${KAFKA_ACTIONS.USER_CREATED}.`);
+        logger.info(`[Kafka] Consumer: 📧 Sending welcome email to '${payload.email}'... Done!`);
+        break;
+      case KAFKA_ACTIONS.USER_UPDATED:
+        logger.info(`[Kafka] Consumer: Received ${KAFKA_ACTIONS.USER_UPDATED}.`);
+        logger.info(`[Kafka] Consumer: 🔄 Updating user records for '${payload.id}' (Email: ${payload.email})... Done!`);
+        break;
+      case KAFKA_ACTIONS.USER_DELETED:
+        logger.info(`[Kafka] Consumer: Received ${KAFKA_ACTIONS.USER_DELETED}.`);
+        logger.info(`[Kafka] Consumer: 🗑️ Cleaning up data for user '${payload.id}'... Done!`);
+        break;
+      default:
+        logger.warn(`[Kafka] Unknown action: ${action}`);
+    }
+  }
+}

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

@@ -1,81 +1,81 @@
-import { KafkaService } from '<% if (architecture === "Clean Architecture") { %>@/infrastructure/messaging/kafkaClient<% } else { %>@/services/kafkaService<% } %>';
-import { kafka } from '<%= configPath %>';
-
-jest.mock('<%= configPath %>', () => ({
-    kafka: {
-        producer: jest.fn().mockReturnValue({
-            connect: jest.fn().mockResolvedValue(undefined),
-            send: jest.fn().mockResolvedValue(undefined),
-            disconnect: jest.fn().mockResolvedValue(undefined),
-        }),
-        consumer: jest.fn().mockReturnValue({
-            connect: jest.fn().mockResolvedValue(undefined),
-            subscribe: jest.fn().mockResolvedValue(undefined),
-            run: jest.fn().mockResolvedValue(undefined),
-            disconnect: jest.fn().mockResolvedValue(undefined),
-        }),
-    },
-}));
-
-jest.mock('<%= loggerPath %>');
-
-describe('KafkaService', () => {
-    let kafkaService: KafkaService;
-
-    beforeEach(() => {
-        jest.clearAllMocks();
-        kafkaService = new KafkaService();
-    });
-
-    it('should connect producer and consumer', async () => {
-        await kafkaService.connect();
-        const producer = (kafka.producer as jest.Mock).mock.results[0].value;
-        const consumer = (kafka.consumer as jest.Mock).mock.results[0].value;
-
-        expect(producer.connect).toHaveBeenCalled();
-        expect(consumer.connect).toHaveBeenCalled();
-        expect(consumer.subscribe).toHaveBeenCalledWith(expect.objectContaining({ topic: 'user-topic', fromBeginning: true }));
-        expect(consumer.run).toHaveBeenCalled();
-    });
-
-    it('should send a message', async () => {
-        await kafkaService.connect();
-        const topic = 'test-topic';
-        const message = JSON.stringify({ action: 'TEST', payload: { email: 'test@example.com' } });
-        await kafkaService.sendMessage(topic, message);
-        const producer = (kafka.producer as jest.Mock).mock.results[0].value;
-
-        expect(producer.send).toHaveBeenCalledWith({
-            topic,
-            messages: [{ value: message }],
-        });
-    });
-
-    it('should retry connection on failure', async () => {
-        const producer = (kafka.producer as jest.Mock).mock.results[0].value;
-        producer.connect
-            .mockRejectedValueOnce(new Error('Connection failed'))
-            .mockResolvedValueOnce(undefined);
-        
-        jest.useFakeTimers();
-        const connectPromise = kafkaService.connect(2);
-        
-        await jest.advanceTimersByTimeAsync(10000);
-        await connectPromise;
-        
-        expect(producer.connect).toHaveBeenCalledTimes(2);
-    });
-
-    it('should throw error if producer not connected', async () => {
-        await expect(kafkaService.sendMessage('topic', 'msg')).rejects.toThrow('[Kafka] Producer not connected');
-    });
-
-    it('should disconnect producer and consumer', async () => {
-        await kafkaService.disconnect();
-        const producer = (kafka.producer as jest.Mock).mock.results[0].value;
-        const consumer = (kafka.consumer as jest.Mock).mock.results[0].value;
-
-        expect(producer.disconnect).toHaveBeenCalled();
-        expect(consumer.disconnect).toHaveBeenCalled();
-    });
-});
+import { KafkaService } from '<% if (architecture === "Clean Architecture") { %>@/infrastructure/messaging/kafkaClient<% } else { %>@/services/kafkaService<% } %>';
+import { kafka } from '<%= configPath %>';
+
+jest.mock('<%= configPath %>', () => ({
+    kafka: {
+        producer: jest.fn().mockReturnValue({
+            connect: jest.fn().mockResolvedValue(undefined),
+            send: jest.fn().mockResolvedValue(undefined),
+            disconnect: jest.fn().mockResolvedValue(undefined),
+        }),
+        consumer: jest.fn().mockReturnValue({
+            connect: jest.fn().mockResolvedValue(undefined),
+            subscribe: jest.fn().mockResolvedValue(undefined),
+            run: jest.fn().mockResolvedValue(undefined),
+            disconnect: jest.fn().mockResolvedValue(undefined),
+        }),
+    },
+}));
+
+jest.mock('<%= loggerPath %>');
+
+describe('KafkaService', () => {
+    let kafkaService: KafkaService;
+
+    beforeEach(() => {
+        jest.clearAllMocks();
+        kafkaService = new KafkaService();
+    });
+
+    it('should connect producer and consumer', async () => {
+        await kafkaService.connect();
+        const producer = (kafka.producer as jest.Mock).mock.results[0].value;
+        const consumer = (kafka.consumer as jest.Mock).mock.results[0].value;
+
+        expect(producer.connect).toHaveBeenCalled();
+        expect(consumer.connect).toHaveBeenCalled();
+        expect(consumer.subscribe).toHaveBeenCalledWith(expect.objectContaining({ topic: 'user-topic', fromBeginning: true }));
+        expect(consumer.run).toHaveBeenCalled();
+    });
+
+    it('should send a message', async () => {
+        await kafkaService.connect();
+        const topic = 'test-topic';
+        const message = JSON.stringify({ action: 'TEST', payload: { email: 'test@example.com' } });
+        await kafkaService.sendMessage(topic, message);
+        const producer = (kafka.producer as jest.Mock).mock.results[0].value;
+
+        expect(producer.send).toHaveBeenCalledWith({
+            topic,
+            messages: [{ value: message }],
+        });
+    });
+
+    it('should retry connection on failure', async () => {
+        const producer = (kafka.producer as jest.Mock).mock.results[0].value;
+        producer.connect
+            .mockRejectedValueOnce(new Error('Connection failed'))
+            .mockResolvedValueOnce(undefined);
+        
+        jest.useFakeTimers();
+        const connectPromise = kafkaService.connect(2);
+        
+        await jest.advanceTimersByTimeAsync(10000);
+        await connectPromise;
+        
+        expect(producer.connect).toHaveBeenCalledTimes(2);
+    });
+
+    it('should throw error if producer not connected', async () => {
+        await expect(kafkaService.sendMessage('topic', 'msg')).rejects.toThrow('[Kafka] Producer not connected');
+    });
+
+    it('should disconnect producer and consumer', async () => {
+        await kafkaService.disconnect();
+        const producer = (kafka.producer as jest.Mock).mock.results[0].value;
+        const consumer = (kafka.consumer as jest.Mock).mock.results[0].value;
+
+        expect(producer.disconnect).toHaveBeenCalled();
+        expect(consumer.disconnect).toHaveBeenCalled();
+    });
+});

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/migrate-mongo-config.js.ejs

@@ -1,31 +1,31 @@
-const config = {
-  mongodb: {
-    url: process.env.MONGO_URI || `mongodb://${process.env.DB_HOST || 'localhost'}:27017`,
-    databaseName: process.env.DB_NAME || '<%= dbName %>',
-
-    options: {
-      // useNewUrlParser: true, // No longer needed in Node.js driver v4+
-      // useUnifiedTopology: true, // No longer needed in Node.js driver v4+
-      // connectTimeoutMS: 3600000, // increase connection timeout to 1 hour
-      // socketTimeoutMS: 3600000, // increase socket timeout to 1 hour
-    }
-  },
-
-  // The migrations dir, can be an relative or absolute path. Only edit this when really necessary.
-  migrationsDir: "migrations",
-
-  // The mongodb collection where the applied changes are stored. Only edit this when really necessary.
-  changelogCollectionName: "changelog",
-
-  // The file extension to create migrations and search for in migration dir 
-  migrationFileExtension: ".js",
-
-  // Enable the algorithm to create a checksum of the file contents and use that in the comparison to determine
-  // if the file should be run.  Requires that scripts are coded to be run multiple times.
-  useFileHash: false,
-
-  // Don't change this, unless you know what you are doing
-  moduleSystem: 'commonjs',
-};
-
-module.exports = config;
+const config = {
+  mongodb: {
+    url: process.env.MONGO_URI || `mongodb://${process.env.DB_HOST || 'localhost'}:27017`,
+    databaseName: process.env.DB_NAME || '<%= dbName %>',
+
+    options: {
+      // useNewUrlParser: true, // No longer needed in Node.js driver v4+
+      // useUnifiedTopology: true, // No longer needed in Node.js driver v4+
+      // connectTimeoutMS: 3600000, // increase connection timeout to 1 hour
+      // socketTimeoutMS: 3600000, // increase socket timeout to 1 hour
+    }
+  },
+
+  // The migrations dir, can be an relative or absolute path. Only edit this when really necessary.
+  migrationsDir: "migrations",
+
+  // The mongodb collection where the applied changes are stored. Only edit this when really necessary.
+  changelogCollectionName: "changelog",
+
+  // The file extension to create migrations and search for in migration dir 
+  migrationFileExtension: ".js",
+
+  // Enable the algorithm to create a checksum of the file contents and use that in the comparison to determine
+  // if the file should be run.  Requires that scripts are coded to be run multiple times.
+  useFileHash: false,
+
+  // Don't change this, unless you know what you are doing
+  moduleSystem: 'commonjs',
+};
+
+module.exports = config;