nodejs-quickstart-structure 1.19.0 → 1.19.1

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

@@ -1,106 +1,106 @@
-let kafka;
-let connectKafka, sendMessage, disconnectKafka;
-
-jest.mock('<% if (architecture === "Clean Architecture") { %>@/infrastructure/config/kafka<% } else { %>@/config/kafka<% } %>', () => ({
-    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('<% if (architecture === "Clean Architecture") { %>@/infrastructure/log/logger<% } else { %>@/utils/logger<% } %>');
-
-describe('Kafka Client', () => {
-    beforeEach(async () => {
-        jest.resetModules();
-        jest.clearAllMocks();
-        jest.useFakeTimers();
-        jest.spyOn(global, 'setTimeout');
-        kafka = require('<% if (architecture === "Clean Architecture") { %>@/infrastructure/config/kafka<% } else { %>@/config/kafka<% } %>').kafka;
-        ({ connectKafka, sendMessage, disconnectKafka } = require('<% if (architecture === "Clean Architecture") { %>@/infrastructure/messaging/kafkaClient<% } else { %>@/services/kafkaService<% } %>'));
-    });
-
-    it('should connect producer and consumer', async () => {
-        await connectKafka();
-        const producer = kafka.producer.mock.results[0].value;
-        const consumer = kafka.consumer.mock.results[0].value;
-
-        expect(producer.connect).toHaveBeenCalled();
-        expect(consumer.connect).toHaveBeenCalled();
-        expect(consumer.subscribe).toHaveBeenCalledWith(expect.objectContaining({ fromBeginning: true }));
-        const subscribeCall = consumer.subscribe.mock.calls.find(call => call[0].topic === 'user-topic' || call[0].topic === 'test-topic');
-        expect(subscribeCall).toBeDefined();
-    });
-
-    it('should send a message', async () => {
-        await connectKafka();
-        const topic = 'test-topic';
-        const message = JSON.stringify({ action: 'TEST', payload: { email: 'test@example.com' } });
-        await sendMessage(topic, message);
-        const producer = kafka.producer.mock.results[0].value;
-
-        expect(producer.send).toHaveBeenCalledWith({
-            topic,
-            messages: [{ value: message }],
-        });
-    });
-
-    it('should retry connection on failure', async () => {
-        // We need to re-require to get a fresh state
-        jest.resetModules();
-        const { connectKafka: retryConnectKafka } = require('<% if (architecture === "Clean Architecture") { %>@/infrastructure/messaging/kafkaClient<% } else { %>@/services/kafkaService<% } %>');
-        const kafkaConfig = require('<% if (architecture === "Clean Architecture") { %>@/infrastructure/config/kafka<% } else { %>@/config/kafka<% } %>');
-        
-        const newProducer = kafkaConfig.kafka.producer();
-        // Mock the next producer creation to return our controlled producer
-        kafkaConfig.kafka.producer.mockReturnValueOnce(newProducer);
-
-        newProducer.connect
-            .mockRejectedValueOnce(new Error('Connection failed'))
-            .mockResolvedValueOnce(undefined);
-        
-        const connectPromise = retryConnectKafka(2);
-        
-        await jest.advanceTimersByTimeAsync(10000); 
-        await connectPromise;
-        expect(newProducer.connect).toHaveBeenCalledTimes(2);
-    });
-
-    it('should throw error if producer not connected', async () => {
-        await expect(sendMessage('topic', 'msg')).rejects.toThrow('[Kafka] Producer not connected');
-    });
-
-    it('should log error when sendMessage fails', async () => {
-        await connectKafka();
-        const producer = kafka.producer.mock.results[0].value;
-        producer.send.mockRejectedValue(new Error('Send failed'));
-        
-        await expect(sendMessage('test-topic', 'msg')).rejects.toThrow('Send failed');
-    });
-
-    it('should disconnect Kafka', async () => {
-        await connectKafka();
-        const producer = kafka.producer.mock.results[0].value;
-        const consumer = kafka.consumer.mock.results[0].value;
-
-        await disconnectKafka();
-
-        expect(producer.disconnect).toHaveBeenCalled();
-        expect(consumer.disconnect).toHaveBeenCalled();
-    });
-
-    it('should allow connecting with custom retries', async () => {
-        await connectKafka(5);
-        // This is mainly for coverage of the retries parameter
-        expect(kafka.producer).toHaveBeenCalled();
-    });
-});
+let kafka;
+let connectKafka, sendMessage, disconnectKafka;
+
+jest.mock('<% if (architecture === "Clean Architecture") { %>@/infrastructure/config/kafka<% } else { %>@/config/kafka<% } %>', () => ({
+    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('<% if (architecture === "Clean Architecture") { %>@/infrastructure/log/logger<% } else { %>@/utils/logger<% } %>');
+
+describe('Kafka Client', () => {
+    beforeEach(async () => {
+        jest.resetModules();
+        jest.clearAllMocks();
+        jest.useFakeTimers();
+        jest.spyOn(global, 'setTimeout');
+        kafka = require('<% if (architecture === "Clean Architecture") { %>@/infrastructure/config/kafka<% } else { %>@/config/kafka<% } %>').kafka;
+        ({ connectKafka, sendMessage, disconnectKafka } = require('<% if (architecture === "Clean Architecture") { %>@/infrastructure/messaging/kafkaClient<% } else { %>@/services/kafkaService<% } %>'));
+    });
+
+    it('should connect producer and consumer', async () => {
+        await connectKafka();
+        const producer = kafka.producer.mock.results[0].value;
+        const consumer = kafka.consumer.mock.results[0].value;
+
+        expect(producer.connect).toHaveBeenCalled();
+        expect(consumer.connect).toHaveBeenCalled();
+        expect(consumer.subscribe).toHaveBeenCalledWith(expect.objectContaining({ fromBeginning: true }));
+        const subscribeCall = consumer.subscribe.mock.calls.find(call => call[0].topic === 'user-topic' || call[0].topic === 'test-topic');
+        expect(subscribeCall).toBeDefined();
+    });
+
+    it('should send a message', async () => {
+        await connectKafka();
+        const topic = 'test-topic';
+        const message = JSON.stringify({ action: 'TEST', payload: { email: 'test@example.com' } });
+        await sendMessage(topic, message);
+        const producer = kafka.producer.mock.results[0].value;
+
+        expect(producer.send).toHaveBeenCalledWith({
+            topic,
+            messages: [{ value: message }],
+        });
+    });
+
+    it('should retry connection on failure', async () => {
+        // We need to re-require to get a fresh state
+        jest.resetModules();
+        const { connectKafka: retryConnectKafka } = require('<% if (architecture === "Clean Architecture") { %>@/infrastructure/messaging/kafkaClient<% } else { %>@/services/kafkaService<% } %>');
+        const kafkaConfig = require('<% if (architecture === "Clean Architecture") { %>@/infrastructure/config/kafka<% } else { %>@/config/kafka<% } %>');
+        
+        const newProducer = kafkaConfig.kafka.producer();
+        // Mock the next producer creation to return our controlled producer
+        kafkaConfig.kafka.producer.mockReturnValueOnce(newProducer);
+
+        newProducer.connect
+            .mockRejectedValueOnce(new Error('Connection failed'))
+            .mockResolvedValueOnce(undefined);
+        
+        const connectPromise = retryConnectKafka(2);
+        
+        await jest.advanceTimersByTimeAsync(10000); 
+        await connectPromise;
+        expect(newProducer.connect).toHaveBeenCalledTimes(2);
+    });
+
+    it('should throw error if producer not connected', async () => {
+        await expect(sendMessage('topic', 'msg')).rejects.toThrow('[Kafka] Producer not connected');
+    });
+
+    it('should log error when sendMessage fails', async () => {
+        await connectKafka();
+        const producer = kafka.producer.mock.results[0].value;
+        producer.send.mockRejectedValue(new Error('Send failed'));
+        
+        await expect(sendMessage('test-topic', 'msg')).rejects.toThrow('Send failed');
+    });
+
+    it('should disconnect Kafka', async () => {
+        await connectKafka();
+        const producer = kafka.producer.mock.results[0].value;
+        const consumer = kafka.consumer.mock.results[0].value;
+
+        await disconnectKafka();
+
+        expect(producer.disconnect).toHaveBeenCalled();
+        expect(consumer.disconnect).toHaveBeenCalled();
+    });
+
+    it('should allow connecting with custom retries', async () => {
+        await connectKafka(5);
+        // This is mainly for coverage of the retries parameter
+        expect(kafka.producer).toHaveBeenCalled();
+    });
+});

package/templates/common/kafka/ts/config/kafka.spec.ts.ejs

@@ -1,27 +1,27 @@
-import { Kafka } from 'kafkajs';
-
-jest.mock('kafkajs', () => {
-    return {
-        Kafka: jest.fn().mockImplementation(() => ({
-            producer: jest.fn(),
-            consumer: jest.fn(),
-        })),
-    };
-});
-
-jest.mock('@/config/env', () => ({
-    env: {
-        KAFKA_BROKER: 'localhost:9092'
-    }
-}));
-
-describe('Kafka Configuration', () => {
-    beforeEach(() => {
-        jest.clearAllMocks();
-    });
-
-    it('should initialize Kafka', () => {
-        require('<% if (architecture === "MVC") { %>@/config/kafka<% } else { %>@/infrastructure/config/kafka<% } %>');
-        expect(Kafka).toHaveBeenCalled();
-    });
-});
+import { Kafka } from 'kafkajs';
+
+jest.mock('kafkajs', () => {
+    return {
+        Kafka: jest.fn().mockImplementation(() => ({
+            producer: jest.fn(),
+            consumer: jest.fn(),
+        })),
+    };
+});
+
+jest.mock('@/config/env', () => ({
+    env: {
+        KAFKA_BROKER: 'localhost:9092'
+    }
+}));
+
+describe('Kafka Configuration', () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+    });
+
+    it('should initialize Kafka', () => {
+        require('<% if (architecture === "MVC") { %>@/config/kafka<% } else { %>@/infrastructure/config/kafka<% } %>');
+        expect(Kafka).toHaveBeenCalled();
+    });
+});

package/templates/common/kafka/ts/config/kafka.ts

@@ -1,7 +1,7 @@
-import { Kafka } from 'kafkajs';
-import { env } from '@/config/env';
-
-export const kafka = new Kafka({
-    clientId: 'nodejs-service',
-    brokers: [env.KAFKA_BROKER]
-});
+import { Kafka } from 'kafkajs';
+import { env } from '@/config/env';
+
+export const kafka = new Kafka({
+    clientId: 'nodejs-service',
+    brokers: [env.KAFKA_BROKER]
+});

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

@@ -1,50 +1,50 @@
-import { BaseConsumer } from '<% if (architecture === "Clean Architecture") { %>@/interfaces/messaging/baseConsumer<% } else { %>@/messaging/baseConsumer<% } %>';
-import logger from '<%= loggerPath %>';
-
-jest.mock('<%= loggerPath %>');
-
-class TestConsumer extends BaseConsumer {
-    constructor() {
-        super();
-    }
-    get topic() { return 'test-topic'; }
-    get groupId() { return 'test-group'; }
-    async handle(data: any) {
-        logger.info('Handled', data);
-    }
-}
-
-describe('BaseConsumer', () => {
-    let consumer: TestConsumer;
-
-    beforeEach(() => {
-        jest.clearAllMocks();
-        consumer = new TestConsumer();
-    });
-
-    it('should throw error if instantiated directly', () => {
-        // @ts-expect-error: Abstract class cannot be instantiated
-        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 } as any);
-        expect(logger.info).toHaveBeenCalledWith('Handled', { test: 'data' });
-    });
-
-    it('should handle invalid JSON', async () => {
-        const message = { value: Buffer.from('invalid-json') };
-        await consumer.onMessage({ message } as any);
-        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 } as any);
-        expect(logger.info).not.toHaveBeenCalled();
-    });
-});
+import { BaseConsumer } from '<% if (architecture === "Clean Architecture") { %>@/interfaces/messaging/baseConsumer<% } else { %>@/messaging/baseConsumer<% } %>';
+import logger from '<%= loggerPath %>';
+
+jest.mock('<%= loggerPath %>');
+
+class TestConsumer extends BaseConsumer {
+    constructor() {
+        super();
+    }
+    get topic() { return 'test-topic'; }
+    get groupId() { return 'test-group'; }
+    async handle(data: any) {
+        logger.info('Handled', data);
+    }
+}
+
+describe('BaseConsumer', () => {
+    let consumer: TestConsumer;
+
+    beforeEach(() => {
+        jest.clearAllMocks();
+        consumer = new TestConsumer();
+    });
+
+    it('should throw error if instantiated directly', () => {
+        // @ts-expect-error: Abstract class cannot be instantiated
+        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 } as any);
+        expect(logger.info).toHaveBeenCalledWith('Handled', { test: 'data' });
+    });
+
+    it('should handle invalid JSON', async () => {
+        const message = { value: Buffer.from('invalid-json') };
+        await consumer.onMessage({ message } as any);
+        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 } as any);
+        expect(logger.info).not.toHaveBeenCalled();
+    });
+});

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

@@ -1,27 +1,27 @@
-import { EachMessagePayload } from 'kafkajs';
-import logger from '<%= loggerPath %>';
-
-export abstract class BaseConsumer {
-  abstract topic: string;
-  abstract groupId: string;
-
-  public constructor() {
-    if (new.target === BaseConsumer) {
-      throw new Error("Abstract class 'BaseConsumer' cannot be instantiated.");
-    }
-  }
-
-  async onMessage({ message }: EachMessagePayload) {
-    try {
-      const rawValue = message.value?.toString();
-      if (!rawValue) return;
-      
-      const data = JSON.parse(rawValue);
-      await this.handle(data);
-    } catch (error) {
-      logger.error(`[Kafka] Error processing message on topic ${this.topic}:`, error);
-    }
-  }
-
-  abstract handle(data: unknown): Promise<void>;
-}
+import { EachMessagePayload } from 'kafkajs';
+import logger from '<%= loggerPath %>';
+
+export abstract class BaseConsumer {
+  abstract topic: string;
+  abstract groupId: string;
+
+  public constructor() {
+    if (new.target === BaseConsumer) {
+      throw new Error("Abstract class 'BaseConsumer' cannot be instantiated.");
+    }
+  }
+
+  async onMessage({ message }: EachMessagePayload) {
+    try {
+      const rawValue = message.value?.toString();
+      if (!rawValue) return;
+      
+      const data = JSON.parse(rawValue);
+      await this.handle(data);
+    } catch (error) {
+      logger.error(`[Kafka] Error processing message on topic ${this.topic}:`, error);
+    }
+  }
+
+  abstract handle(data: unknown): Promise<void>;
+}

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