@hazeljs/kafka 0.2.0-beta.54 → 0.2.0-beta.56

package/dist/__tests__/kafka-consumer.decorator.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=kafka-consumer.decorator.test.d.ts.map

package/dist/__tests__/kafka-consumer.decorator.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"kafka-consumer.decorator.test.d.ts","sourceRoot":"","sources":["../../src/__tests__/kafka-consumer.decorator.test.ts"],"names":[],"mappings":""}

package/dist/__tests__/kafka-consumer.decorator.test.js

@@ -0,0 +1,100 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const kafka_consumer_decorator_1 = require("../decorators/kafka-consumer.decorator");
+const kafka_subscribe_decorator_1 = require("../decorators/kafka-subscribe.decorator");
+describe('KafkaConsumer decorator', () => {
+    it('should set consumer metadata on class', () => {
+        let TestConsumer = class TestConsumer {
+        };
+        TestConsumer = __decorate([
+            (0, kafka_consumer_decorator_1.KafkaConsumer)({ groupId: 'test-group' })
+        ], TestConsumer);
+        const metadata = (0, kafka_consumer_decorator_1.getKafkaConsumerMetadata)(TestConsumer.prototype);
+        expect(metadata).toBeDefined();
+        expect(metadata?.groupId).toBe('test-group');
+        expect(metadata?.sessionTimeout).toBe(30000);
+    });
+    it('should set custom consumer options', () => {
+        let CustomConsumer = class CustomConsumer {
+        };
+        CustomConsumer = __decorate([
+            (0, kafka_consumer_decorator_1.KafkaConsumer)({
+                groupId: 'custom-group',
+                sessionTimeout: 60000,
+                heartbeatInterval: 5000,
+            })
+        ], CustomConsumer);
+        const metadata = (0, kafka_consumer_decorator_1.getKafkaConsumerMetadata)(CustomConsumer.prototype);
+        expect(metadata?.groupId).toBe('custom-group');
+        expect(metadata?.sessionTimeout).toBe(60000);
+        expect(metadata?.heartbeatInterval).toBe(5000);
+    });
+    it('should return true for Kafka consumer class', () => {
+        let ConsumerClass = class ConsumerClass {
+        };
+        ConsumerClass = __decorate([
+            (0, kafka_consumer_decorator_1.KafkaConsumer)({ groupId: 'test' })
+        ], ConsumerClass);
+        expect((0, kafka_consumer_decorator_1.isKafkaConsumer)(ConsumerClass.prototype)).toBe(true);
+    });
+    it('should return false for non-consumer class', () => {
+        class RegularClass {
+        }
+        expect((0, kafka_consumer_decorator_1.isKafkaConsumer)(RegularClass.prototype)).toBe(false);
+    });
+});
+describe('KafkaSubscribe decorator', () => {
+    it('should set subscribe metadata on method', () => {
+        let TestConsumer = class TestConsumer {
+            handleOrders() { }
+        };
+        __decorate([
+            (0, kafka_subscribe_decorator_1.KafkaSubscribe)('orders'),
+            __metadata("design:type", Function),
+            __metadata("design:paramtypes", []),
+            __metadata("design:returntype", void 0)
+        ], TestConsumer.prototype, "handleOrders", null);
+        TestConsumer = __decorate([
+            (0, kafka_consumer_decorator_1.KafkaConsumer)({ groupId: 'test-group' })
+        ], TestConsumer);
+        const metadata = (0, kafka_subscribe_decorator_1.getKafkaSubscribeMetadata)(TestConsumer.prototype);
+        expect(metadata).toHaveLength(1);
+        expect(metadata[0].topic).toBe('orders');
+        expect(metadata[0].methodName).toBe('handleOrders');
+    });
+    it('should support multiple topic subscriptions', () => {
+        let MultiConsumer = class MultiConsumer {
+            handleA() { }
+            handleB() { }
+        };
+        __decorate([
+            (0, kafka_subscribe_decorator_1.KafkaSubscribe)('topic-a'),
+            __metadata("design:type", Function),
+            __metadata("design:paramtypes", []),
+            __metadata("design:returntype", void 0)
+        ], MultiConsumer.prototype, "handleA", null);
+        __decorate([
+            (0, kafka_subscribe_decorator_1.KafkaSubscribe)('topic-b', { fromBeginning: true }),
+            __metadata("design:type", Function),
+            __metadata("design:paramtypes", []),
+            __metadata("design:returntype", void 0)
+        ], MultiConsumer.prototype, "handleB", null);
+        MultiConsumer = __decorate([
+            (0, kafka_consumer_decorator_1.KafkaConsumer)({ groupId: 'test-group' })
+        ], MultiConsumer);
+        const metadata = (0, kafka_subscribe_decorator_1.getKafkaSubscribeMetadata)(MultiConsumer.prototype);
+        expect(metadata).toHaveLength(2);
+        expect(metadata[0]).toEqual({ topic: 'topic-a', methodName: 'handleA', options: {} });
+        expect(metadata[1].topic).toBe('topic-b');
+        expect(metadata[1].options?.fromBeginning).toBe(true);
+    });
+});

package/dist/__tests__/kafka-consumer.service.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=kafka-consumer.service.test.d.ts.map

package/dist/__tests__/kafka-consumer.service.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"kafka-consumer.service.test.d.ts","sourceRoot":"","sources":["../../src/__tests__/kafka-consumer.service.test.ts"],"names":[],"mappings":""}

package/dist/__tests__/kafka-consumer.service.test.js

@@ -0,0 +1,244 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const kafka_consumer_service_1 = require("../kafka-consumer.service");
+const kafka_consumer_decorator_1 = require("../decorators/kafka-consumer.decorator");
+const kafka_subscribe_decorator_1 = require("../decorators/kafka-subscribe.decorator");
+// Mock metadata reader functions to control what the service sees
+jest.mock('../decorators/kafka-consumer.decorator', () => ({
+    getKafkaConsumerMetadata: jest.fn(),
+    KAFKA_CONSUMER_METADATA_KEY: Symbol('kafka:consumer'),
+}));
+jest.mock('../decorators/kafka-subscribe.decorator', () => ({
+    getKafkaSubscribeMetadata: jest.fn(),
+    KAFKA_SUBSCRIBE_METADATA_KEY: Symbol('kafka:subscribe'),
+}));
+// Mock kafkajs
+const mockConnect = jest.fn().mockResolvedValue(undefined);
+const mockDisconnect = jest.fn().mockResolvedValue(undefined);
+const mockSubscribe = jest.fn().mockResolvedValue(undefined);
+let capturedEachMessage;
+const mockRun = jest
+    .fn()
+    .mockImplementation(async ({ eachMessage }) => {
+    capturedEachMessage = eachMessage;
+});
+jest.mock('kafkajs', () => ({ Kafka: jest.fn() }));
+const mockConsumer = {
+    connect: mockConnect,
+    disconnect: mockDisconnect,
+    subscribe: mockSubscribe,
+    run: mockRun,
+};
+const mockKafka = {
+    consumer: jest.fn().mockReturnValue(mockConsumer),
+};
+const mockGetConsumerMetadata = kafka_consumer_decorator_1.getKafkaConsumerMetadata;
+const mockGetSubscribeMetadata = kafka_subscribe_decorator_1.getKafkaSubscribeMetadata;
+describe('KafkaConsumerService', () => {
+    let service;
+    beforeEach(() => {
+        jest.clearAllMocks();
+        capturedEachMessage = undefined;
+        mockConnect.mockResolvedValue(undefined);
+        mockDisconnect.mockResolvedValue(undefined);
+        mockSubscribe.mockResolvedValue(undefined);
+        mockRun.mockImplementation(async ({ eachMessage }) => {
+            capturedEachMessage = eachMessage;
+        });
+        mockKafka.consumer.mockReturnValue(mockConsumer);
+        service = new kafka_consumer_service_1.KafkaConsumerService(mockKafka);
+    });
+    describe('getConsumerCount()', () => {
+        it('returns 0 initially', () => {
+            expect(service.getConsumerCount()).toBe(0);
+        });
+    });
+    describe('registerFromProvider()', () => {
+        it('warns and returns when provider has no @KafkaConsumer', async () => {
+            mockGetConsumerMetadata.mockReturnValue(undefined);
+            mockGetSubscribeMetadata.mockReturnValue([]);
+            class NoMetadataProvider {
+            }
+            await service.registerFromProvider(new NoMetadataProvider());
+            expect(mockConnect).not.toHaveBeenCalled();
+        });
+        it('warns and returns when provider has @KafkaConsumer but empty @KafkaSubscribe', async () => {
+            mockGetConsumerMetadata.mockReturnValue({ groupId: 'test-group' });
+            mockGetSubscribeMetadata.mockReturnValue([]);
+            class NoSubscribeProvider {
+            }
+            await service.registerFromProvider(new NoSubscribeProvider());
+            expect(mockConnect).not.toHaveBeenCalled();
+        });
+        it('registers and starts a consumer', async () => {
+            mockGetConsumerMetadata.mockReturnValue({ groupId: 'test-group' });
+            mockGetSubscribeMetadata.mockReturnValue([
+                { topic: 'test-topic', methodName: 'handleMessage', options: {} },
+            ]);
+            class TestProvider {
+                async handleMessage(_payload) { }
+            }
+            await service.registerFromProvider(new TestProvider());
+            expect(mockConnect).toHaveBeenCalledTimes(1);
+            expect(mockSubscribe).toHaveBeenCalledWith({ topics: ['test-topic'], fromBeginning: false });
+            expect(mockRun).toHaveBeenCalledTimes(1);
+            expect(service.getConsumerCount()).toBe(1);
+        });
+        it('subscribes with fromBeginning=true when specified', async () => {
+            mockGetConsumerMetadata.mockReturnValue({ groupId: 'replay-group' });
+            mockGetSubscribeMetadata.mockReturnValue([
+                { topic: 'replay-topic', methodName: 'handle', options: { fromBeginning: true } },
+            ]);
+            class ReplayProvider {
+                async handle(_payload) { }
+            }
+            await service.registerFromProvider(new ReplayProvider());
+            expect(mockSubscribe).toHaveBeenCalledWith({ topics: ['replay-topic'], fromBeginning: true });
+        });
+        it('passes consumer options to kafka.consumer()', async () => {
+            mockGetConsumerMetadata.mockReturnValue({
+                groupId: 'my-group',
+                sessionTimeout: 10000,
+                rebalanceTimeout: 20000,
+                heartbeatInterval: 1000,
+                maxWaitTimeInMs: 2000,
+            });
+            mockGetSubscribeMetadata.mockReturnValue([
+                { topic: 'topic', methodName: 'handle', options: {} },
+            ]);
+            class Provider {
+                async handle(_payload) { }
+            }
+            await service.registerFromProvider(new Provider());
+            expect(mockKafka.consumer).toHaveBeenCalledWith(expect.objectContaining({ groupId: 'my-group', sessionTimeout: 10000 }));
+        });
+        it('dispatches eachMessage to the correct handler', async () => {
+            const handleSpy = jest.fn().mockResolvedValue(undefined);
+            mockGetConsumerMetadata.mockReturnValue({ groupId: 'order-group' });
+            mockGetSubscribeMetadata.mockReturnValue([
+                { topic: 'orders', methodName: 'processOrder', options: {} },
+            ]);
+            class OrderProvider {
+                async processOrder(payload) {
+                    handleSpy(payload);
+                }
+            }
+            const provider = new OrderProvider();
+            await service.registerFromProvider(provider);
+            expect(capturedEachMessage).toBeDefined();
+            const testPayload = {
+                topic: 'orders',
+                partition: 0,
+                message: {
+                    key: null,
+                    value: Buffer.from('{"id":1}'),
+                    headers: {},
+                    offset: '0',
+                    timestamp: '1000',
+                },
+                heartbeat: jest.fn(),
+                pause: jest.fn(),
+            };
+            await capturedEachMessage(testPayload);
+            expect(handleSpy).toHaveBeenCalledWith(testPayload);
+        });
+        it('ignores messages for unregistered topics', async () => {
+            const handleSpy = jest.fn();
+            mockGetConsumerMetadata.mockReturnValue({ groupId: 'g' });
+            mockGetSubscribeMetadata.mockReturnValue([
+                { topic: 'known-topic', methodName: 'handle', options: {} },
+            ]);
+            class Provider {
+                async handle() {
+                    handleSpy();
+                }
+            }
+            await service.registerFromProvider(new Provider());
+            await capturedEachMessage({
+                topic: 'unknown-topic',
+                partition: 0,
+                message: { key: null, value: Buffer.from('x'), headers: {}, offset: '0', timestamp: '0' },
+                heartbeat: jest.fn(),
+                pause: jest.fn(),
+            });
+            expect(handleSpy).not.toHaveBeenCalled();
+        });
+        it('handles handler errors gracefully without throwing', async () => {
+            mockGetConsumerMetadata.mockReturnValue({ groupId: 'g' });
+            mockGetSubscribeMetadata.mockReturnValue([
+                { topic: 'error-topic', methodName: 'handle', options: {} },
+            ]);
+            class ErrorProvider {
+                async handle() {
+                    throw new Error('handler blew up');
+                }
+            }
+            await service.registerFromProvider(new ErrorProvider());
+            await expect(capturedEachMessage({
+                topic: 'error-topic',
+                partition: 0,
+                message: { key: null, value: Buffer.from('x'), headers: {}, offset: '0', timestamp: '0' },
+                heartbeat: jest.fn(),
+                pause: jest.fn(),
+            })).resolves.toBeUndefined();
+        });
+        it('logs error when method name is not a function on provider', async () => {
+            mockGetConsumerMetadata.mockReturnValue({ groupId: 'g' });
+            mockGetSubscribeMetadata.mockReturnValue([
+                { topic: 'test-topic', methodName: 'nonExistentMethod', options: {} },
+            ]);
+            class ProviderWithoutMethod {
+            }
+            await service.registerFromProvider(new ProviderWithoutMethod());
+            // Should not throw, just log an error
+            await expect(capturedEachMessage({
+                topic: 'test-topic',
+                partition: 0,
+                message: { key: null, value: Buffer.from('x'), headers: {}, offset: '0', timestamp: '0' },
+                heartbeat: jest.fn(),
+                pause: jest.fn(),
+            })).resolves.toBeUndefined();
+        });
+        it('supports multiple subscriptions on one provider', async () => {
+            mockGetConsumerMetadata.mockReturnValue({ groupId: 'multi-group' });
+            mockGetSubscribeMetadata.mockReturnValue([
+                { topic: 'topic-a', methodName: 'handleA', options: {} },
+                { topic: 'topic-b', methodName: 'handleB', options: {} },
+            ]);
+            class MultiProvider {
+                async handleA(_p) { }
+                async handleB(_p) { }
+            }
+            await service.registerFromProvider(new MultiProvider());
+            expect(mockSubscribe).toHaveBeenCalledTimes(2);
+        });
+    });
+    describe('onModuleDestroy()', () => {
+        it('does nothing when no consumers are running', async () => {
+            await service.onModuleDestroy();
+            expect(mockDisconnect).not.toHaveBeenCalled();
+        });
+        it('disconnects all running consumers and clears list', async () => {
+            mockGetConsumerMetadata.mockReturnValue({ groupId: 'g' });
+            mockGetSubscribeMetadata.mockReturnValue([{ topic: 't', methodName: 'h', options: {} }]);
+            class P {
+                async h() { }
+            }
+            await service.registerFromProvider(new P());
+            expect(service.getConsumerCount()).toBe(1);
+            await service.onModuleDestroy();
+            expect(mockDisconnect).toHaveBeenCalledTimes(1);
+            expect(service.getConsumerCount()).toBe(0);
+        });
+        it('handles disconnect errors gracefully', async () => {
+            mockGetConsumerMetadata.mockReturnValue({ groupId: 'g' });
+            mockGetSubscribeMetadata.mockReturnValue([{ topic: 't', methodName: 'h', options: {} }]);
+            class P {
+                async h() { }
+            }
+            await service.registerFromProvider(new P());
+            mockDisconnect.mockRejectedValueOnce(new Error('disconnect failed'));
+            await expect(service.onModuleDestroy()).resolves.toBeUndefined();
+        });
+    });
+});

package/dist/__tests__/kafka-producer.service.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=kafka-producer.service.test.d.ts.map

package/dist/__tests__/kafka-producer.service.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"kafka-producer.service.test.d.ts","sourceRoot":"","sources":["../../src/__tests__/kafka-producer.service.test.ts"],"names":[],"mappings":""}

package/dist/__tests__/kafka-producer.service.test.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const kafka_producer_service_1 = require("../kafka-producer.service");
+// Mock kafkajs
+const mockSend = jest.fn().mockResolvedValue(undefined);
+const mockConnect = jest.fn().mockResolvedValue(undefined);
+const mockDisconnect = jest.fn().mockResolvedValue(undefined);
+jest.mock('kafkajs', () => ({
+    Kafka: jest.fn().mockImplementation(() => ({
+        producer: () => ({
+            connect: mockConnect,
+            disconnect: mockDisconnect,
+            send: mockSend,
+        }),
+    })),
+}));
+// Simple DI container mock for testing
+const mockKafka = {
+    producer: () => ({
+        connect: mockConnect,
+        disconnect: mockDisconnect,
+        send: mockSend,
+    }),
+};
+describe('KafkaProducerService', () => {
+    let service;
+    beforeEach(() => {
+        jest.clearAllMocks();
+        service = new kafka_producer_service_1.KafkaProducerService(mockKafka);
+    });
+    describe('send', () => {
+        it('should connect and send message', async () => {
+            await service.send('test-topic', { value: 'hello' });
+            expect(mockConnect).toHaveBeenCalled();
+            expect(mockSend).toHaveBeenCalledWith(expect.objectContaining({
+                topic: 'test-topic',
+                messages: expect.arrayContaining([expect.objectContaining({ value: 'hello' })]),
+            }));
+        });
+        it('should send multiple messages', async () => {
+            await service.send('test-topic', [
+                { key: '1', value: 'msg1' },
+                { key: '2', value: 'msg2' },
+            ]);
+            expect(mockSend).toHaveBeenCalledWith(expect.objectContaining({
+                messages: expect.arrayContaining([
+                    expect.objectContaining({ key: '1', value: 'msg1' }),
+                    expect.objectContaining({ key: '2', value: 'msg2' }),
+                ]),
+            }));
+        });
+    });
+    describe('sendBatch', () => {
+        it('should send to multiple topics', async () => {
+            await service.sendBatch([
+                { topic: 'topic-a', messages: [{ value: 'a' }] },
+                { topic: 'topic-b', messages: [{ value: 'b' }] },
+            ]);
+            expect(mockSend).toHaveBeenCalledTimes(2);
+        });
+    });
+    describe('lifecycle', () => {
+        it('should connect on onModuleInit', async () => {
+            await service.onModuleInit();
+            expect(mockConnect).toHaveBeenCalled();
+        });
+        it('should disconnect on onModuleDestroy', async () => {
+            await service.onModuleInit();
+            await service.onModuleDestroy();
+            expect(mockDisconnect).toHaveBeenCalled();
+        });
+    });
+});

package/dist/__tests__/kafka-stream.processor.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=kafka-stream.processor.test.d.ts.map

package/dist/__tests__/kafka-stream.processor.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"kafka-stream.processor.test.d.ts","sourceRoot":"","sources":["../../src/__tests__/kafka-stream.processor.test.ts"],"names":[],"mappings":""}

package/dist/__tests__/kafka-stream.processor.test.js

@@ -0,0 +1,243 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const kafka_stream_processor_1 = require("../kafka-stream.processor");
+// Mock kafkajs
+const mockConsumerConnect = jest.fn().mockResolvedValue(undefined);
+const mockConsumerDisconnect = jest.fn().mockResolvedValue(undefined);
+const mockConsumerSubscribe = jest.fn().mockResolvedValue(undefined);
+let capturedEachMessage;
+const mockConsumerRun = jest
+    .fn()
+    .mockImplementation(async ({ eachMessage }) => {
+    capturedEachMessage = eachMessage;
+});
+const mockProducerConnect = jest.fn().mockResolvedValue(undefined);
+const mockProducerDisconnect = jest.fn().mockResolvedValue(undefined);
+const mockProducerSend = jest.fn().mockResolvedValue(undefined);
+jest.mock('kafkajs', () => ({ Kafka: jest.fn() }));
+const mockKafka = {
+    consumer: jest.fn().mockReturnValue({
+        connect: mockConsumerConnect,
+        disconnect: mockConsumerDisconnect,
+        subscribe: mockConsumerSubscribe,
+        run: mockConsumerRun,
+    }),
+    producer: jest.fn().mockReturnValue({
+        connect: mockProducerConnect,
+        disconnect: mockProducerDisconnect,
+        send: mockProducerSend,
+    }),
+};
+describe('KafkaStreamProcessor', () => {
+    let processor;
+    beforeEach(() => {
+        jest.clearAllMocks();
+        capturedEachMessage = undefined;
+        mockConsumerConnect.mockResolvedValue(undefined);
+        mockConsumerDisconnect.mockResolvedValue(undefined);
+        mockConsumerSubscribe.mockResolvedValue(undefined);
+        mockConsumerRun.mockImplementation(async ({ eachMessage }) => {
+            capturedEachMessage = eachMessage;
+        });
+        mockProducerConnect.mockResolvedValue(undefined);
+        mockProducerDisconnect.mockResolvedValue(undefined);
+        mockProducerSend.mockResolvedValue(undefined);
+        mockKafka.consumer.mockReturnValue({
+            connect: mockConsumerConnect,
+            disconnect: mockConsumerDisconnect,
+            subscribe: mockConsumerSubscribe,
+            run: mockConsumerRun,
+        });
+        mockKafka.producer.mockReturnValue({
+            connect: mockProducerConnect,
+            disconnect: mockProducerDisconnect,
+            send: mockProducerSend,
+        });
+        processor = new kafka_stream_processor_1.KafkaStreamProcessor(mockKafka);
+    });
+    describe('fluent API', () => {
+        it('from() returns this (chainable)', () => {
+            expect(processor.from('input-topic')).toBe(processor);
+        });
+        it('from() can be called again to update inputTopic', () => {
+            processor.from('first');
+            expect(processor.from('second')).toBe(processor);
+        });
+        it('transform() returns this (chainable)', () => {
+            processor.from('input');
+            expect(processor.transform(async (msg) => ({ value: msg.value }))).toBe(processor);
+        });
+        it('to() returns this (chainable)', () => {
+            processor.from('input');
+            expect(processor.to('output')).toBe(processor);
+        });
+        it('withGroupId() returns this (chainable)', () => {
+            processor.from('input');
+            expect(processor.withGroupId('my-group')).toBe(processor);
+        });
+        it('transform() throws when called before from()', () => {
+            expect(() => processor.transform(async (msg) => ({ value: msg.value }))).toThrow('Call from(topic) before transform()');
+        });
+        it('to() throws when called before from()', () => {
+            expect(() => processor.to('output')).toThrow('Call from(topic) before to()');
+        });
+        it('withGroupId() throws when called before from()', () => {
+            expect(() => processor.withGroupId('group')).toThrow('Call from(topic) before withGroupId()');
+        });
+    });
+    describe('isProcessorRunning()', () => {
+        it('returns false initially', () => {
+            expect(processor.isProcessorRunning()).toBe(false);
+        });
+    });
+    describe('start()', () => {
+        it('throws when pipeline is not configured', async () => {
+            await expect(processor.start()).rejects.toThrow('Pipeline not configured');
+        });
+        it('starts the processor and sets isRunning', async () => {
+            processor.from('input').to('output');
+            await processor.start();
+            expect(mockConsumerConnect).toHaveBeenCalled();
+            expect(mockProducerConnect).toHaveBeenCalled();
+            expect(mockConsumerSubscribe).toHaveBeenCalledWith({
+                topics: ['input'],
+                fromBeginning: false,
+            });
+            expect(processor.isProcessorRunning()).toBe(true);
+        });
+        it('is idempotent (second start() is no-op)', async () => {
+            processor.from('input').to('output');
+            await processor.start();
+            await processor.start();
+            expect(mockConsumerConnect).toHaveBeenCalledTimes(1);
+        });
+        it('uses custom groupId when provided', async () => {
+            processor.from('input').to('output').withGroupId('custom-group');
+            await processor.start();
+            expect(mockKafka.consumer).toHaveBeenCalledWith({ groupId: 'custom-group' });
+        });
+        it('generates default groupId from topic names', async () => {
+            processor.from('in-topic').to('out-topic');
+            await processor.start();
+            expect(mockKafka.consumer).toHaveBeenCalledWith({
+                groupId: 'stream-in-topic-out-topic',
+            });
+        });
+        it('produces transformed message to output topic', async () => {
+            processor
+                .from('in')
+                .transform(async (msg) => ({ value: Buffer.from(`processed:${msg.value?.toString()}`) }))
+                .to('out');
+            await processor.start();
+            await capturedEachMessage({
+                message: { key: Buffer.from('key1'), value: Buffer.from('hello'), headers: {} },
+            });
+            expect(mockProducerSend).toHaveBeenCalledWith(expect.objectContaining({ topic: 'out' }));
+        });
+        it('skips producing when transform returns null', async () => {
+            processor
+                .from('in')
+                .transform(async () => null)
+                .to('out');
+            await processor.start();
+            await capturedEachMessage({
+                message: { key: null, value: Buffer.from('data'), headers: {} },
+            });
+            expect(mockProducerSend).not.toHaveBeenCalled();
+        });
+        it('serializes non-buffer/string output to JSON', async () => {
+            processor
+                .from('in')
+                .transform(async () => ({ value: { nested: 'obj' } }))
+                .to('out');
+            await processor.start();
+            await capturedEachMessage({
+                message: { key: null, value: Buffer.from('in'), headers: {} },
+            });
+            const sentMsg = mockProducerSend.mock.calls[0][0].messages[0];
+            expect(sentMsg.value).toBe('{"nested":"obj"}');
+        });
+        it('passes string value through as-is', async () => {
+            processor
+                .from('in')
+                .transform(async () => ({ value: 'plain-text' }))
+                .to('out');
+            await processor.start();
+            await capturedEachMessage({
+                message: { key: null, value: Buffer.from('in'), headers: {} },
+            });
+            const sentMsg = mockProducerSend.mock.calls[0][0].messages[0];
+            expect(sentMsg.value).toBe('plain-text');
+        });
+        it('passes Buffer value through as-is', async () => {
+            const buf = Buffer.from('raw');
+            processor
+                .from('in')
+                .transform(async () => ({ value: buf }))
+                .to('out');
+            await processor.start();
+            await capturedEachMessage({
+                message: { key: null, value: Buffer.from('in'), headers: {} },
+            });
+            const sentMsg = mockProducerSend.mock.calls[0][0].messages[0];
+            expect(sentMsg.value).toBe(buf);
+        });
+        it('uses original message value when transform output value is null', async () => {
+            processor
+                .from('in')
+                .transform(async (msg) => ({ value: null, key: msg.key }))
+                .to('out');
+            await processor.start();
+            const origValue = Buffer.from('original');
+            await capturedEachMessage({
+                message: { key: null, value: origValue, headers: {} },
+            });
+            const sentMsg = mockProducerSend.mock.calls[0][0].messages[0];
+            expect(sentMsg.value).toBe(origValue);
+        });
+        it('handles transform errors by re-throwing', async () => {
+            processor
+                .from('in')
+                .transform(async () => {
+                throw new Error('transform failed');
+            })
+                .to('out');
+            await processor.start();
+            await expect(capturedEachMessage({
+                message: { key: null, value: Buffer.from('x'), headers: {} },
+            })).rejects.toThrow('transform failed');
+        });
+        it('uses identity transform when no transform() is called', async () => {
+            processor.from('in').to('out');
+            await processor.start();
+            const val = Buffer.from('unchanged');
+            await capturedEachMessage({
+                message: { key: null, value: val, headers: {} },
+            });
+            expect(mockProducerSend).toHaveBeenCalled();
+        });
+    });
+    describe('stop()', () => {
+        it('does nothing when processor is not running', async () => {
+            await processor.stop();
+            expect(mockConsumerDisconnect).not.toHaveBeenCalled();
+        });
+        it('disconnects both consumer and producer', async () => {
+            processor.from('in').to('out');
+            await processor.start();
+            await processor.stop();
+            expect(mockConsumerDisconnect).toHaveBeenCalled();
+            expect(mockProducerDisconnect).toHaveBeenCalled();
+            expect(processor.isProcessorRunning()).toBe(false);
+        });
+        it('resets pipelineConfig after stop', async () => {
+            processor.from('in').to('out');
+            await processor.start();
+            await processor.stop();
+            // Can start a new pipeline after stop
+            processor.from('new-in').to('new-out');
+            await processor.start();
+            expect(processor.isProcessorRunning()).toBe(true);
+        });
+    });
+});

package/dist/__tests__/kafka.module.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=kafka.module.test.d.ts.map

package/dist/__tests__/kafka.module.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"kafka.module.test.d.ts","sourceRoot":"","sources":["../../src/__tests__/kafka.module.test.ts"],"names":[],"mappings":""}

package/dist/__tests__/kafka.module.test.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const kafka_module_1 = require("../kafka.module");
+const core_1 = require("@hazeljs/core");
+const kafka_producer_service_1 = require("../kafka-producer.service");
+describe('KafkaModule', () => {
+    describe('forRoot', () => {
+        it('should return KafkaModule and register client', () => {
+            const result = kafka_module_1.KafkaModule.forRoot({
+                clientId: 'test-app',
+                brokers: ['localhost:9092'],
+            });
+            expect(result).toBe(kafka_module_1.KafkaModule);
+            const container = core_1.Container.getInstance();
+            const client = container.resolve(kafka_producer_service_1.KAFKA_CLIENT_TOKEN);
+            expect(client).toBeDefined();
+            expect(client?.producer).toBeDefined();
+        });
+        it('should use default options', () => {
+            kafka_module_1.KafkaModule.forRoot({});
+            const container = core_1.Container.getInstance();
+            const client = container.resolve(kafka_producer_service_1.KAFKA_CLIENT_TOKEN);
+            expect(client).toBeDefined();
+        });
+    });
+    describe('forRootAsync', () => {
+        it('should return KafkaModule and register client', async () => {
+            const result = await kafka_module_1.KafkaModule.forRootAsync({
+                useFactory: () => Promise.resolve({
+                    clientId: 'async-app',
+                    brokers: ['kafka:9092'],
+                }),
+                inject: [],
+            });
+            expect(result).toBe(kafka_module_1.KafkaModule);
+            const container = core_1.Container.getInstance();
+            const client = container.resolve(kafka_producer_service_1.KAFKA_CLIENT_TOKEN);
+            expect(client).toBeDefined();
+        });
+    });
+});

package/dist/kafka-consumer.service.js

@@ -112,7 +112,7 @@ let KafkaConsumerService = class KafkaConsumerService {
 };
 exports.KafkaConsumerService = KafkaConsumerService;
 exports.KafkaConsumerService = KafkaConsumerService = __decorate([
-    (0, core_1.Injectable)(),
+    (0, core_1.Service)(),
     __param(0, (0, core_1.Inject)(exports.KAFKA_CLIENT_TOKEN)),
     __metadata("design:paramtypes", [kafkajs_1.Kafka])
 ], KafkaConsumerService);

package/dist/kafka-producer.service.js

@@ -101,7 +101,7 @@ let KafkaProducerService = class KafkaProducerService {
 };
 exports.KafkaProducerService = KafkaProducerService;
 exports.KafkaProducerService = KafkaProducerService = __decorate([
-    (0, core_1.Injectable)(),
+    (0, core_1.Service)(),
     __param(0, (0, core_1.Inject)(exports.KAFKA_CLIENT_TOKEN)),
     __metadata("design:paramtypes", [kafkajs_1.Kafka])
 ], KafkaProducerService);

package/dist/kafka-stream.processor.js

@@ -162,7 +162,7 @@ let KafkaStreamProcessor = class KafkaStreamProcessor {
 };
 exports.KafkaStreamProcessor = KafkaStreamProcessor;
 exports.KafkaStreamProcessor = KafkaStreamProcessor = __decorate([
-    (0, core_1.Injectable)(),
+    (0, core_1.Service)(),
     __param(0, (0, core_1.Inject)(exports.KAFKA_CLIENT_TOKEN)),
     __metadata("design:paramtypes", [kafkajs_1.Kafka])
 ], KafkaStreamProcessor);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hazeljs/kafka",
-  "version": "0.2.0-beta.54",
+  "version": "0.2.0-beta.56",
   "description": "Kafka module for HazelJS framework - produce, consume, and stream processing",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -50,5 +50,5 @@
   "peerDependencies": {
     "@hazeljs/core": ">=0.2.0-beta.0"
   },
-  "gitHead": "c593ce33447cdc62d7bd2386cc2db47840292fcb"
+  "gitHead": "c2737e90974458a8438eee623726f0a453b66b8b"
 }