nodejs-quickstart-structure 1.18.1 → 1.19.1

package/templates/common/kafka/js/messaging/baseConsumer.spec.js.ejs

@@ -1,58 +1,58 @@
-const BaseConsumer = require('<% if (architecture === "Clean Architecture") { %>@/interfaces/messaging/baseConsumer<% } else { %>@/messaging/baseConsumer<% } %>');
-const logger = require('<% if (architecture === "Clean Architecture") { %>@/infrastructure/log/logger<% } else { %>@/utils/logger<% } %>');
-
-jest.mock('<% if (architecture === "Clean Architecture") { %>@/infrastructure/log/logger<% } else { %>@/utils/logger<% } %>');
-
-class TestConsumer extends BaseConsumer {
-    constructor() {
-        super();
-        this._topic = 'test-topic';
-    }
-    get topic() { return this._topic; }
-    get groupId() { return 'test-group'; }
-    async handle(data) {
-        logger.info('Handled', data);
-    }
-}
-
-describe('BaseConsumer', () => {
-    let consumer;
-
-    beforeEach(() => {
-        jest.clearAllMocks();
-        consumer = new TestConsumer();
-    });
-
-    it('should throw error if instantiated directly', () => {
-        expect(() => new BaseConsumer()).toThrow("Abstract class 'BaseConsumer' cannot be instantiated.");
-    });
-
-    it('should process a valid message', async () => {
-        const message = { value: Buffer.from(JSON.stringify({ test: 'data' })) };
-        await consumer.onMessage({ message });
-        expect(logger.info).toHaveBeenCalledWith('Handled', { test: 'data' });
-    });
-
-    it('should handle invalid JSON', async () => {
-        const message = { value: Buffer.from('invalid-json') };
-        await consumer.onMessage({ message });
-        expect(logger.error).toHaveBeenCalledWith(
-            expect.stringContaining('[Kafka] Error processing message on topic test-topic:'),
-            expect.anything()
-        );
-    });
-
-    it('should skip empty messages', async () => {
-        const message = { value: null };
-        await consumer.onMessage({ message });
-        expect(logger.info).not.toHaveBeenCalled();
-    });
-
-    it('should throw if topic, groupId or handle are not implemented', async () => {
-        class IncompleteConsumer extends BaseConsumer {}
-        const incomplete = new IncompleteConsumer();
-        expect(() => incomplete.topic).toThrow("Property 'topic' must be implemented");
-        expect(() => incomplete.groupId).toThrow("Property 'groupId' must be implemented");
-        await expect(incomplete.handle({})).rejects.toThrow("Method 'handle()' must be implemented");
-    });
-});
+const BaseConsumer = require('<% if (architecture === "Clean Architecture") { %>@/interfaces/messaging/baseConsumer<% } else { %>@/messaging/baseConsumer<% } %>');
+const logger = require('<% if (architecture === "Clean Architecture") { %>@/infrastructure/log/logger<% } else { %>@/utils/logger<% } %>');
+
+jest.mock('<% if (architecture === "Clean Architecture") { %>@/infrastructure/log/logger<% } else { %>@/utils/logger<% } %>');
+
+class TestConsumer extends BaseConsumer {
+    constructor() {
+        super();
+        this._topic = 'test-topic';
+    }
+    get topic() { return this._topic; }
+    get groupId() { return 'test-group'; }
+    async handle(data) {
+        logger.info('Handled', data);
+    }
+}
+
+describe('BaseConsumer', () => {
+    let consumer;
+
+    beforeEach(() => {
+        jest.clearAllMocks();
+        consumer = new TestConsumer();
+    });
+
+    it('should throw error if instantiated directly', () => {
+        expect(() => new BaseConsumer()).toThrow("Abstract class 'BaseConsumer' cannot be instantiated.");
+    });
+
+    it('should process a valid message', async () => {
+        const message = { value: Buffer.from(JSON.stringify({ test: 'data' })) };
+        await consumer.onMessage({ message });
+        expect(logger.info).toHaveBeenCalledWith('Handled', { test: 'data' });
+    });
+
+    it('should handle invalid JSON', async () => {
+        const message = { value: Buffer.from('invalid-json') };
+        await consumer.onMessage({ message });
+        expect(logger.error).toHaveBeenCalledWith(
+            expect.stringContaining('[Kafka] Error processing message on topic test-topic:'),
+            expect.anything()
+        );
+    });
+
+    it('should skip empty messages', async () => {
+        const message = { value: null };
+        await consumer.onMessage({ message });
+        expect(logger.info).not.toHaveBeenCalled();
+    });
+
+    it('should throw if topic, groupId or handle are not implemented', async () => {
+        class IncompleteConsumer extends BaseConsumer {}
+        const incomplete = new IncompleteConsumer();
+        expect(() => incomplete.topic).toThrow("Property 'topic' must be implemented");
+        expect(() => incomplete.groupId).toThrow("Property 'groupId' must be implemented");
+        await expect(incomplete.handle({})).rejects.toThrow("Method 'handle()' must be implemented");
+    });
+});

package/templates/common/kafka/js/messaging/userEventSchema.js.ejs

@@ -1,11 +1,12 @@
-const { z } = require('zod');
-
-const UserEventSchema = z.object({
-  action: z.enum(['USER_CREATED', 'UPDATE_USER', 'DELETE_USER']),
-  payload: z.object({
-    id: z.union([z.string(), z.number()]),
-    email: z.string().email(),
-  }),
-});
-
-module.exports = { UserEventSchema };
+const { z } = require('zod');
+const { KAFKA_ACTIONS } = require('<%- kafkaEventsPath %>');
+
+const UserEventSchema = z.object({
+  action: z.enum(Object.values(KAFKA_ACTIONS)),
+  payload: z.object({
+    id: z.union([z.string(), z.number()]),
+    email: z.string().email().optional(),
+  }),
+});
+
+module.exports = { UserEventSchema };

package/templates/common/kafka/js/messaging/userEventSchema.spec.js.ejs

@@ -1,27 +1,27 @@
-const { UserEventSchema } = require('<% if (architecture === "Clean Architecture") { %>@/interfaces/messaging/schemas/userEventSchema<% } else { %>@/messaging/schemas/userEventSchema<% } %>');
-
-describe('UserEventSchema', () => {
-    it('should validate a correct USER_CREATED event', () => {
-        const validEvent = {
-            action: 'USER_CREATED',
-            payload: {
-                id: 1,
-                email: 'test@example.com'
-            }
-        };
-        const result = UserEventSchema.safeParse(validEvent);
-        expect(result.success).toBe(true);
-    });
-
-    it('should fail validation for invalid email', () => {
-        const invalidEvent = {
-            action: 'USER_CREATED',
-            payload: {
-                id: 1,
-                email: 'invalid-email'
-            }
-        };
-        const result = UserEventSchema.safeParse(invalidEvent);
-        expect(result.success).toBe(false);
-    });
-});
+const { UserEventSchema } = require('<% if (architecture === "Clean Architecture") { %>@/interfaces/messaging/schemas/userEventSchema<% } else { %>@/messaging/schemas/userEventSchema<% } %>');
+
+describe('UserEventSchema', () => {
+    it('should validate a correct USER_CREATED event', () => {
+        const validEvent = {
+            action: 'USER_CREATED',
+            payload: {
+                id: 1,
+                email: 'test@example.com'
+            }
+        };
+        const result = UserEventSchema.safeParse(validEvent);
+        expect(result.success).toBe(true);
+    });
+
+    it('should fail validation for invalid email', () => {
+        const invalidEvent = {
+            action: 'USER_CREATED',
+            payload: {
+                id: 1,
+                email: 'invalid-email'
+            }
+        };
+        const result = UserEventSchema.safeParse(invalidEvent);
+        expect(result.success).toBe(false);
+    });
+});

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

@@ -1,31 +1,44 @@
-const BaseConsumer = require('../../baseConsumer');
-const logger = require('<% if (architecture === "Clean Architecture") { %>../../../../infrastructure/log/logger<% } else { %>../../../utils/logger<% } %>');
-const { UserEventSchema } = require('../../schemas/userEventSchema');
-
-class WelcomeEmailConsumer extends BaseConsumer {
-  constructor() {
-    super();
-  }
-
-  get topic() { return 'user-topic'; }
-  get groupId() { return 'welcome-email-group'; }
-
-  async handle(data) {
-    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
-    }
-  }
-}
-
-module.exports = WelcomeEmailConsumer;
+const BaseConsumer = require('<%- baseConsumerPath %>');
+const logger = require('<%- loggerPath %>');
+const { UserEventSchema } = require('<%- userEventSchemaPath %>');
+const ERROR_MESSAGES = require('<%- errorMessagesPath %>');
+const { KAFKA_ACTIONS } = require('<%- kafkaEventsPath %>');
+
+class WelcomeEmailConsumer extends BaseConsumer {
+  constructor() {
+    super();
+  }
+
+  get topic() { return 'user-topic'; }
+  get groupId() { return 'welcome-email-group'; }
+
+  async handle(data) {
+    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}`);
+    }
+  }
+}
+
+module.exports = WelcomeEmailConsumer;

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

@@ -1,49 +1,86 @@
-const WelcomeEmailConsumer = require('<% if (architecture === "Clean Architecture") { %>@/interfaces/messaging/consumers/instances/welcomeEmailConsumer<% } else { %>@/messaging/consumers/instances/welcomeEmailConsumer<% } %>');
-const logger = require('<% if (architecture === "Clean Architecture") { %>@/infrastructure/log/logger<% } else { %>@/utils/logger<% } %>');
-
-jest.mock('<% if (architecture === "Clean Architecture") { %>@/infrastructure/log/logger<% } else { %>@/utils/logger<% } %>');
-
-describe('WelcomeEmailConsumer', () => {
-    let consumer;
-
-    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()
-        );
-    });
-});
+const WelcomeEmailConsumer = require('<% if (architecture === "Clean Architecture") { %>@/interfaces/messaging/consumers/instances/welcomeEmailConsumer<% } else { %>@/messaging/consumers/instances/welcomeEmailConsumer<% } %>');
+const logger = require('<% if (architecture === "Clean Architecture") { %>@/infrastructure/log/logger<% } else { %>@/utils/logger<% } %>');
+
+jest.mock('<% if (architecture === "Clean Architecture") { %>@/infrastructure/log/logger<% } else { %>@/utils/logger<% } %>');
+
+describe('WelcomeEmailConsumer', () => {
+    let consumer;
+
+    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/js/services/kafkaService.js.ejs

@@ -1,93 +1,93 @@
-const { kafka } = require('../config/kafka');
-const logger = require('<% if (architecture === "Clean Architecture") { %>../log/logger<% } else { %>../utils/logger<% } %>');
-
-let producer = null;
-let consumer = null;
-let isConnected = false;
-let connectionPromise = null;
-
-const connectKafka = async (retries = 10) => {
-    if (connectionPromise) return connectionPromise;
-
-    connectionPromise = (async () => {
-        if (!producer) producer = kafka.producer();
-        if (!consumer) consumer = kafka.consumer({ groupId: 'test-group' });
-
-        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 = require('<% if (architecture === "Clean Architecture") { %>../../interfaces/messaging/consumers/instances/welcomeEmailConsumer<% } else { %>../messaging/consumers/instances/welcomeEmailConsumer<% } %>');
-        while (attempt < retries) {
-            try {
-                await producer.connect();
-                await consumer.connect();
-                logger.info('[Kafka] Producer connected successfully');
-                logger.info('[Kafka] Consumer connected successfully');
-                isConnected = true;
-
-                try {
-                    const welcomeConsumer = new WelcomeEmailConsumer();
-                    await consumer.subscribe({ topic: welcomeConsumer.topic, fromBeginning: true });
-                    logger.info(`[Kafka] Registered consumer for topic: ${welcomeConsumer.topic}`);
-
-                    await consumer.run({
-                        eachMessage: async (payload) => welcomeConsumer.onMessage(payload),
-                    });
-                } catch (error) {
-                    // Fallback or no consumers found
-                    await consumer.subscribe({ topic: 'user-topic', fromBeginning: true });
-                    await consumer.run({
-                        eachMessage: async ({ message }) => {
-                            logger.info({ value: message.value.toString() });
-                        },
-                    });
-                }
-                return; // Success
-            } catch (error) {
-                attempt++;
-                logger.error(`[Kafka] Connection attempt ${attempt} failed:`, error.message);
-                if (attempt >= retries) {
-                    throw error; // Rethrow after final attempt
-                }
-                await new Promise(res => setTimeout(res, 3000)); // Wait 3s between retries
-            }
-        }
-    })();
-
-    return connectionPromise;
-};
-
-const sendMessage = async (topic, message) => {
-    if (connectionPromise) {
-        await connectionPromise;
-    }
-
-    if (!isConnected) {
-        throw new Error('[Kafka] Producer not connected. Check logs for connection errors.');
-    }
-    
-    try {
-        await 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 (error) {
-            logger.info(`[Kafka] Producer: Sent message to ${topic}`, error);
-        }
-    } catch (error) {
-        logger.error(`[Kafka] Failed to send message to ${topic}:`, error.message);
-        throw error;
-    }
-};
-
-const disconnectKafka = async () => {
-    if (producer) await producer.disconnect();
-    if (consumer) await consumer.disconnect();
-};
-
-module.exports = { connectKafka, sendMessage, disconnectKafka };
+const { kafka } = require('../config/kafka');
+const logger = require('<% if (architecture === "Clean Architecture") { %>../log/logger<% } else { %>../utils/logger<% } %>');
+
+let producer = null;
+let consumer = null;
+let isConnected = false;
+let connectionPromise = null;
+
+const connectKafka = async (retries = 10) => {
+    if (connectionPromise) return connectionPromise;
+
+    connectionPromise = (async () => {
+        if (!producer) producer = kafka.producer();
+        if (!consumer) consumer = kafka.consumer({ groupId: 'test-group' });
+
+        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 = require('<% if (architecture === "Clean Architecture") { %>../../interfaces/messaging/consumers/instances/welcomeEmailConsumer<% } else { %>../messaging/consumers/instances/welcomeEmailConsumer<% } %>');
+        while (attempt < retries) {
+            try {
+                await producer.connect();
+                await consumer.connect();
+                logger.info('[Kafka] Producer connected successfully');
+                logger.info('[Kafka] Consumer connected successfully');
+                isConnected = true;
+
+                try {
+                    const welcomeConsumer = new WelcomeEmailConsumer();
+                    await consumer.subscribe({ topic: welcomeConsumer.topic, fromBeginning: true });
+                    logger.info(`[Kafka] Registered consumer for topic: ${welcomeConsumer.topic}`);
+
+                    await consumer.run({
+                        eachMessage: async (payload) => welcomeConsumer.onMessage(payload),
+                    });
+                } catch (error) {
+                    // Fallback or no consumers found
+                    await consumer.subscribe({ topic: 'user-topic', fromBeginning: true });
+                    await consumer.run({
+                        eachMessage: async ({ message }) => {
+                            logger.info({ value: message.value.toString() });
+                        },
+                    });
+                }
+                return; // Success
+            } catch (error) {
+                attempt++;
+                logger.error(`[Kafka] Connection attempt ${attempt} failed:`, error.message);
+                if (attempt >= retries) {
+                    throw error; // Rethrow after final attempt
+                }
+                await new Promise(res => setTimeout(res, 3000)); // Wait 3s between retries
+            }
+        }
+    })();
+
+    return connectionPromise;
+};
+
+const sendMessage = async (topic, message, key) => {
+    if (connectionPromise) {
+        await connectionPromise;
+    }
+
+    if (!isConnected) {
+        throw new Error('[Kafka] Producer not connected. Check logs for connection errors.');
+    }
+    
+    try {
+        await 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 (error) {
+            logger.info(`[Kafka] Producer: Sent message to ${topic}`, error);
+        }
+    } catch (error) {
+        logger.error(`[Kafka] Failed to send message to ${topic}:`, error.message);
+        throw error;
+    }
+};
+
+const disconnectKafka = async () => {
+    if (producer) await producer.disconnect();
+    if (consumer) await consumer.disconnect();
+};
+
+module.exports = { connectKafka, sendMessage, disconnectKafka };