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

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-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.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.55",
   "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": "f2e54f346eea552595a44607999454a9e388cb9e"
 }