@hazeljs/kafka 0.2.0-beta.18

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 HazelJS Team
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,174 @@
+# @hazeljs/kafka
+
+**Kafka Module for HazelJS - Produce, Consume, and Stream Processing**
+
+Apache Kafka integration for HazelJS with decorator-based consumers, producer service, and lightweight stream processing.
+
+[![npm version](https://img.shields.io/npm/v/@hazeljs/kafka.svg)](https://www.npmjs.com/package/@hazeljs/kafka)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+## Features
+
+- **Produce** - Publish messages to Kafka topics via `KafkaProducerService`
+- **Consume** - Decorator-driven consumers with `@KafkaConsumer` and `@KafkaSubscribe`
+- **Stream Processing** - Lightweight `KafkaStreamProcessor` for consume-transform-produce pipelines
+- **Graceful Shutdown** - Clean disconnect on application shutdown
+- **TypeScript** - Full type safety with KafkaJS
+
+## Installation
+
+```bash
+npm install @hazeljs/kafka
+```
+
+## Quick Start
+
+### 1. Configure KafkaModule
+
+```typescript
+// app.module.ts
+import { HazelModule } from '@hazeljs/core';
+import { KafkaModule } from '@hazeljs/kafka';
+
+@HazelModule({
+  imports: [
+    KafkaModule.forRoot({
+      clientId: 'my-app',
+      brokers: ['localhost:9092'],
+    }),
+  ],
+})
+export class AppModule {}
+```
+
+### 2. Produce Messages
+
+```typescript
+import { Injectable } from '@hazeljs/core';
+import { KafkaProducerService } from '@hazeljs/kafka';
+
+@Injectable()
+export class OrderService {
+  constructor(private producer: KafkaProducerService) {}
+
+  async createOrder(data: CreateOrderDto) {
+    await this.producer.send('orders', [
+      { key: data.id, value: JSON.stringify(data) },
+    ]);
+    return data;
+  }
+}
+```
+
+### 3. Consume Messages (Decorator-Based)
+
+```typescript
+import { Injectable } from '@hazeljs/core';
+import { KafkaConsumer, KafkaSubscribe, KafkaMessagePayload } from '@hazeljs/kafka';
+
+@KafkaConsumer({ groupId: 'order-processor' })
+@Injectable()
+export class OrderConsumer {
+  @KafkaSubscribe('orders')
+  async handleOrder({ message }: KafkaMessagePayload) {
+    const order = JSON.parse(message.value!.toString());
+    console.log('Processing order:', order);
+  }
+}
+```
+
+### 4. Register Consumers in Bootstrap
+
+```typescript
+// index.ts
+import { HazelApp, Container } from '@hazeljs/core';
+import { KafkaModule } from '@hazeljs/kafka';
+import { AppModule } from './app.module';
+import { OrderConsumer } from './order.consumer';
+
+async function bootstrap() {
+  const app = new HazelApp(AppModule);
+
+  // Register Kafka consumers
+  const container = Container.getInstance();
+  const orderConsumer = container.resolve(OrderConsumer);
+  if (orderConsumer) {
+    await KafkaModule.registerConsumersFromProvider(orderConsumer);
+  }
+
+  await app.listen(3000);
+}
+bootstrap();
+```
+
+## Stream Processing
+
+For consume-transform-produce pipelines:
+
+```typescript
+import { Container } from '@hazeljs/core';
+import { KafkaStreamProcessor } from '@hazeljs/kafka';
+
+const container = Container.getInstance();
+const processor = container.resolve(KafkaStreamProcessor);
+
+processor
+  .from('raw-events')
+  .transform(async (msg) => ({
+    value: JSON.stringify({ ...JSON.parse(msg.value!.toString()), enriched: true }),
+  }))
+  .to('enriched-events')
+  .start();
+```
+
+## Async Configuration
+
+Use `forRootAsync` with ConfigService:
+
+```typescript
+import { ConfigService } from '@hazeljs/config';
+import { KafkaModule } from '@hazeljs/kafka';
+
+KafkaModule.forRootAsync({
+  useFactory: (config: ConfigService) => ({
+    clientId: config.get('KAFKA_CLIENT_ID', 'my-app'),
+    brokers: (config.get('KAFKA_BROKERS') || 'localhost:9092').toString().split(','),
+  }),
+  inject: [ConfigService],
+})
+```
+
+## API Reference
+
+### KafkaProducerService
+
+- `send(topic, messages, options?)` - Send message(s) to a topic
+- `sendBatch(batch)` - Send to multiple topics
+- `isProducerConnected()` - Check connection status
+
+### Decorators
+
+- `@KafkaConsumer(options)` - Mark class as consumer (groupId required)
+- `@KafkaSubscribe(topic, options?)` - Mark method as topic handler
+  - `fromBeginning?: boolean` - Read from beginning of topic
+
+### KafkaStreamProcessor
+
+- `from(topic)` - Input topic
+- `transform(fn)` - Transform function (message) => output
+- `to(topic)` - Output topic
+- `withGroupId(id)` - Consumer group ID
+- `start()` - Start processing
+- `stop()` - Stop processing
+
+## Environment Variables
+
+```
+KAFKA_BROKERS=localhost:9092
+KAFKA_CLIENT_ID=my-app
+```
+
+## Requirements
+
+- Apache Kafka broker (>= 0.11.x)
+- Node.js >= 14

package/dist/decorators/kafka-consumer.decorator.d.ts

@@ -0,0 +1,32 @@
+import 'reflect-metadata';
+import { KafkaConsumerOptions } from '../kafka.types';
+/**
+ * Metadata key for Kafka consumer class options
+ */
+export declare const KAFKA_CONSUMER_METADATA_KEY: unique symbol;
+/**
+ * Decorator to mark a class as a Kafka consumer with consumer group options
+ *
+ * @example
+ * ```typescript
+ * @KafkaConsumer({ groupId: 'order-processor' })
+ * @Injectable()
+ * export class OrderConsumer {
+ *   @KafkaSubscribe('orders')
+ *   async handleOrder({ message }: KafkaMessagePayload) {
+ *     const order = JSON.parse(message.value.toString());
+ *     // process order
+ *   }
+ * }
+ * ```
+ */
+export declare function KafkaConsumer(options: KafkaConsumerOptions): ClassDecorator;
+/**
+ * Get Kafka consumer metadata from a class or instance
+ */
+export declare function getKafkaConsumerMetadata(target: object): KafkaConsumerOptions | undefined;
+/**
+ * Check if a class is a Kafka consumer
+ */
+export declare function isKafkaConsumer(target: object): boolean;
+//# sourceMappingURL=kafka-consumer.decorator.d.ts.map

package/dist/decorators/kafka-consumer.decorator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"kafka-consumer.decorator.d.ts","sourceRoot":"","sources":["../../src/decorators/kafka-consumer.decorator.ts"],"names":[],"mappings":"AAAA,OAAO,kBAAkB,CAAC;AAC1B,OAAO,EAAE,oBAAoB,EAAE,MAAM,gBAAgB,CAAC;AAGtD;;GAEG;AACH,eAAO,MAAM,2BAA2B,eAA2B,CAAC;AAEpE;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,aAAa,CAAC,OAAO,EAAE,oBAAoB,GAAG,cAAc,CAe3E;AAED;;GAEG;AACH,wBAAgB,wBAAwB,CAAC,MAAM,EAAE,MAAM,GAAG,oBAAoB,GAAG,SAAS,CAKzF;AAED;;GAEG;AACH,wBAAgB,eAAe,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAKvD"}

package/dist/decorators/kafka-consumer.decorator.js

@@ -0,0 +1,64 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KAFKA_CONSUMER_METADATA_KEY = void 0;
+exports.KafkaConsumer = KafkaConsumer;
+exports.getKafkaConsumerMetadata = getKafkaConsumerMetadata;
+exports.isKafkaConsumer = isKafkaConsumer;
+require("reflect-metadata");
+const core_1 = __importDefault(require("@hazeljs/core"));
+/**
+ * Metadata key for Kafka consumer class options
+ */
+exports.KAFKA_CONSUMER_METADATA_KEY = Symbol('kafka:consumer');
+/**
+ * Decorator to mark a class as a Kafka consumer with consumer group options
+ *
+ * @example
+ * ```typescript
+ * @KafkaConsumer({ groupId: 'order-processor' })
+ * @Injectable()
+ * export class OrderConsumer {
+ *   @KafkaSubscribe('orders')
+ *   async handleOrder({ message }: KafkaMessagePayload) {
+ *     const order = JSON.parse(message.value.toString());
+ *     // process order
+ *   }
+ * }
+ * ```
+ */
+function KafkaConsumer(options) {
+    return (target) => {
+        const defaults = {
+            groupId: options.groupId,
+            sessionTimeout: options.sessionTimeout ?? 30000,
+            rebalanceTimeout: options.rebalanceTimeout ?? 60000,
+            heartbeatInterval: options.heartbeatInterval ?? 3000,
+            maxWaitTimeInMs: options.maxWaitTimeInMs ?? 5000,
+            retry: options.retry,
+        };
+        const targetName = typeof target === 'function' ? target.name : 'unknown';
+        core_1.default.debug(`Marking ${targetName} as Kafka consumer with groupId: ${defaults.groupId}`);
+        Reflect.defineMetadata(exports.KAFKA_CONSUMER_METADATA_KEY, defaults, target);
+    };
+}
+/**
+ * Get Kafka consumer metadata from a class or instance
+ */
+function getKafkaConsumerMetadata(target) {
+    const constructor = typeof target === 'function' ? target : target.constructor;
+    if (!constructor)
+        return undefined;
+    return Reflect.getMetadata(exports.KAFKA_CONSUMER_METADATA_KEY, constructor);
+}
+/**
+ * Check if a class is a Kafka consumer
+ */
+function isKafkaConsumer(target) {
+    const constructor = typeof target === 'function' ? target : target.constructor;
+    if (!constructor)
+        return false;
+    return Reflect.hasMetadata(exports.KAFKA_CONSUMER_METADATA_KEY, constructor);
+}

package/dist/decorators/kafka-subscribe.decorator.d.ts

@@ -0,0 +1,40 @@
+import 'reflect-metadata';
+import { KafkaSubscribeOptions } from '../kafka.types';
+/**
+ * Metadata key for Kafka subscribe (topic + handler)
+ */
+export declare const KAFKA_SUBSCRIBE_METADATA_KEY: unique symbol;
+/**
+ * Subscribe handler metadata
+ */
+export interface KafkaSubscribeMetadata {
+    topic: string;
+    methodName: string;
+    options?: KafkaSubscribeOptions;
+}
+/**
+ * Decorator to mark a method as a handler for a Kafka topic
+ *
+ * @example
+ * ```typescript
+ * @KafkaConsumer({ groupId: 'order-processor' })
+ * @Injectable()
+ * export class OrderConsumer {
+ *   @KafkaSubscribe('orders')
+ *   async handleOrder({ message }: KafkaMessagePayload) {
+ *     // process order
+ *   }
+ *
+ *   @KafkaSubscribe('events', { fromBeginning: true })
+ *   async handleEvents({ message }: KafkaMessagePayload) {
+ *     // process events
+ *   }
+ * }
+ * ```
+ */
+export declare function KafkaSubscribe(topic: string, options?: KafkaSubscribeOptions): MethodDecorator;
+/**
+ * Get Kafka subscribe metadata from a class
+ */
+export declare function getKafkaSubscribeMetadata(target: object): KafkaSubscribeMetadata[];
+//# sourceMappingURL=kafka-subscribe.decorator.d.ts.map

package/dist/decorators/kafka-subscribe.decorator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"kafka-subscribe.decorator.d.ts","sourceRoot":"","sources":["../../src/decorators/kafka-subscribe.decorator.ts"],"names":[],"mappings":"AAAA,OAAO,kBAAkB,CAAC;AAC1B,OAAO,EAAE,qBAAqB,EAAE,MAAM,gBAAgB,CAAC;AAGvD;;GAEG;AACH,eAAO,MAAM,4BAA4B,eAA4B,CAAC;AAEtE;;GAEG;AACH,MAAM,WAAW,sBAAsB;IACrC,KAAK,EAAE,MAAM,CAAC;IACd,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,CAAC,EAAE,qBAAqB,CAAC;CACjC;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,qBAAqB,GAAG,eAAe,CAkB9F;AAED;;GAEG;AACH,wBAAgB,yBAAyB,CAAC,MAAM,EAAE,MAAM,GAAG,sBAAsB,EAAE,CAElF"}

package/dist/decorators/kafka-subscribe.decorator.js

@@ -0,0 +1,53 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KAFKA_SUBSCRIBE_METADATA_KEY = void 0;
+exports.KafkaSubscribe = KafkaSubscribe;
+exports.getKafkaSubscribeMetadata = getKafkaSubscribeMetadata;
+require("reflect-metadata");
+const core_1 = __importDefault(require("@hazeljs/core"));
+/**
+ * Metadata key for Kafka subscribe (topic + handler)
+ */
+exports.KAFKA_SUBSCRIBE_METADATA_KEY = Symbol('kafka:subscribe');
+/**
+ * Decorator to mark a method as a handler for a Kafka topic
+ *
+ * @example
+ * ```typescript
+ * @KafkaConsumer({ groupId: 'order-processor' })
+ * @Injectable()
+ * export class OrderConsumer {
+ *   @KafkaSubscribe('orders')
+ *   async handleOrder({ message }: KafkaMessagePayload) {
+ *     // process order
+ *   }
+ *
+ *   @KafkaSubscribe('events', { fromBeginning: true })
+ *   async handleEvents({ message }: KafkaMessagePayload) {
+ *     // process events
+ *   }
+ * }
+ * ```
+ */
+function KafkaSubscribe(topic, options) {
+    return (target, propertyKey, _descriptor) => {
+        const existingSubscriptions = Reflect.getMetadata(exports.KAFKA_SUBSCRIBE_METADATA_KEY, target.constructor) || [];
+        const subscription = {
+            topic,
+            methodName: propertyKey.toString(),
+            options: options ?? {},
+        };
+        existingSubscriptions.push(subscription);
+        Reflect.defineMetadata(exports.KAFKA_SUBSCRIBE_METADATA_KEY, existingSubscriptions, target.constructor);
+        core_1.default.debug(`KafkaSubscribe applied to ${target.constructor.name}.${String(propertyKey)} for topic: ${topic}`);
+    };
+}
+/**
+ * Get Kafka subscribe metadata from a class
+ */
+function getKafkaSubscribeMetadata(target) {
+    return Reflect.getMetadata(exports.KAFKA_SUBSCRIBE_METADATA_KEY, target.constructor) || [];
+}

package/dist/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * @hazeljs/kafka - Kafka module for HazelJS
+ */
+export { KafkaModule } from './kafka.module';
+export { KafkaProducerService } from './kafka-producer.service';
+export { KafkaConsumerService } from './kafka-consumer.service';
+export { KafkaStreamProcessor } from './kafka-stream.processor';
+export { KAFKA_CLIENT_TOKEN } from './kafka-producer.service';
+export { KafkaConsumer, getKafkaConsumerMetadata, isKafkaConsumer, } from './decorators/kafka-consumer.decorator';
+export { KafkaSubscribe, getKafkaSubscribeMetadata, type KafkaSubscribeMetadata, } from './decorators/kafka-subscribe.decorator';
+export type { KafkaModuleOptions, KafkaClientOptions, KafkaConsumerOptions, KafkaSubscribeOptions, KafkaProduceOptions, KafkaMessage, KafkaMessagePayload, KafkaMessageHandler, KafkaStreamTransform, KafkaSaslOptions, KafkaSslOptions, SaslMechanism, } from './kafka.types';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAC7C,OAAO,EAAE,oBAAoB,EAAE,MAAM,0BAA0B,CAAC;AAChE,OAAO,EAAE,oBAAoB,EAAE,MAAM,0BAA0B,CAAC;AAChE,OAAO,EAAE,oBAAoB,EAAE,MAAM,0BAA0B,CAAC;AAChE,OAAO,EAAE,kBAAkB,EAAE,MAAM,0BAA0B,CAAC;AAC9D,OAAO,EACL,aAAa,EACb,wBAAwB,EACxB,eAAe,GAChB,MAAM,uCAAuC,CAAC;AAC/C,OAAO,EACL,cAAc,EACd,yBAAyB,EACzB,KAAK,sBAAsB,GAC5B,MAAM,wCAAwC,CAAC;AAChD,YAAY,EACV,kBAAkB,EAClB,kBAAkB,EAClB,oBAAoB,EACpB,qBAAqB,EACrB,mBAAmB,EACnB,YAAY,EACZ,mBAAmB,EACnB,mBAAmB,EACnB,oBAAoB,EACpB,gBAAgB,EAChB,eAAe,EACf,aAAa,GACd,MAAM,eAAe,CAAC"}

package/dist/index.js

@@ -0,0 +1,23 @@
+"use strict";
+/**
+ * @hazeljs/kafka - Kafka module for HazelJS
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getKafkaSubscribeMetadata = exports.KafkaSubscribe = exports.isKafkaConsumer = exports.getKafkaConsumerMetadata = exports.KafkaConsumer = exports.KAFKA_CLIENT_TOKEN = exports.KafkaStreamProcessor = exports.KafkaConsumerService = exports.KafkaProducerService = exports.KafkaModule = void 0;
+var kafka_module_1 = require("./kafka.module");
+Object.defineProperty(exports, "KafkaModule", { enumerable: true, get: function () { return kafka_module_1.KafkaModule; } });
+var kafka_producer_service_1 = require("./kafka-producer.service");
+Object.defineProperty(exports, "KafkaProducerService", { enumerable: true, get: function () { return kafka_producer_service_1.KafkaProducerService; } });
+var kafka_consumer_service_1 = require("./kafka-consumer.service");
+Object.defineProperty(exports, "KafkaConsumerService", { enumerable: true, get: function () { return kafka_consumer_service_1.KafkaConsumerService; } });
+var kafka_stream_processor_1 = require("./kafka-stream.processor");
+Object.defineProperty(exports, "KafkaStreamProcessor", { enumerable: true, get: function () { return kafka_stream_processor_1.KafkaStreamProcessor; } });
+var kafka_producer_service_2 = require("./kafka-producer.service");
+Object.defineProperty(exports, "KAFKA_CLIENT_TOKEN", { enumerable: true, get: function () { return kafka_producer_service_2.KAFKA_CLIENT_TOKEN; } });
+var kafka_consumer_decorator_1 = require("./decorators/kafka-consumer.decorator");
+Object.defineProperty(exports, "KafkaConsumer", { enumerable: true, get: function () { return kafka_consumer_decorator_1.KafkaConsumer; } });
+Object.defineProperty(exports, "getKafkaConsumerMetadata", { enumerable: true, get: function () { return kafka_consumer_decorator_1.getKafkaConsumerMetadata; } });
+Object.defineProperty(exports, "isKafkaConsumer", { enumerable: true, get: function () { return kafka_consumer_decorator_1.isKafkaConsumer; } });
+var kafka_subscribe_decorator_1 = require("./decorators/kafka-subscribe.decorator");
+Object.defineProperty(exports, "KafkaSubscribe", { enumerable: true, get: function () { return kafka_subscribe_decorator_1.KafkaSubscribe; } });
+Object.defineProperty(exports, "getKafkaSubscribeMetadata", { enumerable: true, get: function () { return kafka_subscribe_decorator_1.getKafkaSubscribeMetadata; } });

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

@@ -0,0 +1,21 @@
+import { Kafka } from 'kafkajs';
+export declare const KAFKA_CLIENT_TOKEN = "KAFKA_CLIENT";
+/**
+ * Kafka consumer service for consuming messages with decorator-driven handlers
+ */
+export declare class KafkaConsumerService {
+    private readonly kafka;
+    private runningConsumers;
+    constructor(kafka: Kafka);
+    /**
+     * Register a consumer provider and start consuming
+     * Call this for each class that has @KafkaConsumer and @KafkaSubscribe decorators
+     */
+    registerFromProvider(provider: object): Promise<void>;
+    onModuleDestroy(): Promise<void>;
+    /**
+     * Get count of running consumers
+     */
+    getConsumerCount(): number;
+}
+//# sourceMappingURL=kafka-consumer.service.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"kafka-consumer.service.d.ts","sourceRoot":"","sources":["../src/kafka-consumer.service.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAMhC,eAAO,MAAM,kBAAkB,iBAAiB,CAAC;AAQjD;;GAEG;AACH,qBACa,oBAAoB;IAK7B,OAAO,CAAC,QAAQ,CAAC,KAAK;IAJxB,OAAO,CAAC,gBAAgB,CAAyB;gBAI9B,KAAK,EAAE,KAAK;IAG/B;;;OAGG;IACG,oBAAoB,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAiFrD,eAAe,IAAI,OAAO,CAAC,IAAI,CAAC;IAYtC;;OAEG;IACH,gBAAgB,IAAI,MAAM;CAG3B"}

package/dist/kafka-consumer.service.js

@@ -0,0 +1,118 @@
+"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);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KafkaConsumerService = exports.KAFKA_CLIENT_TOKEN = void 0;
+const core_1 = require("@hazeljs/core");
+const kafkajs_1 = require("kafkajs");
+const kafka_consumer_decorator_1 = require("./decorators/kafka-consumer.decorator");
+const kafka_subscribe_decorator_1 = require("./decorators/kafka-subscribe.decorator");
+const core_2 = __importDefault(require("@hazeljs/core"));
+exports.KAFKA_CLIENT_TOKEN = 'KAFKA_CLIENT';
+/**
+ * Kafka consumer service for consuming messages with decorator-driven handlers
+ */
+let KafkaConsumerService = class KafkaConsumerService {
+    constructor(kafka) {
+        this.kafka = kafka;
+        this.runningConsumers = [];
+    }
+    /**
+     * Register a consumer provider and start consuming
+     * Call this for each class that has @KafkaConsumer and @KafkaSubscribe decorators
+     */
+    async registerFromProvider(provider) {
+        const consumerOptions = (0, kafka_consumer_decorator_1.getKafkaConsumerMetadata)(provider.constructor);
+        const subscribeMetadata = (0, kafka_subscribe_decorator_1.getKafkaSubscribeMetadata)(provider.constructor);
+        if (!consumerOptions) {
+            core_2.default.warn(`Provider ${provider.constructor.name} has @KafkaSubscribe but no @KafkaConsumer decorator - skipping`);
+            return;
+        }
+        if (!subscribeMetadata || subscribeMetadata.length === 0) {
+            core_2.default.warn(`Provider ${provider.constructor.name} has @KafkaConsumer but no @KafkaSubscribe - skipping`);
+            return;
+        }
+        const consumer = this.kafka.consumer({
+            groupId: consumerOptions.groupId,
+            sessionTimeout: consumerOptions.sessionTimeout ?? 30000,
+            rebalanceTimeout: consumerOptions.rebalanceTimeout ?? 60000,
+            heartbeatInterval: consumerOptions.heartbeatInterval ?? 3000,
+            maxWaitTimeInMs: consumerOptions.maxWaitTimeInMs ?? 5000,
+            retry: consumerOptions.retry,
+        });
+        const topicHandlers = new Map();
+        await consumer.connect();
+        for (const sub of subscribeMetadata) {
+            topicHandlers.set(sub.topic, {
+                methodName: sub.methodName,
+                fromBeginning: sub.options?.fromBeginning ?? false,
+            });
+            await consumer.subscribe({
+                topics: [sub.topic],
+                fromBeginning: sub.options?.fromBeginning ?? false,
+            });
+        }
+        await consumer.run({
+            eachMessage: async (payload) => {
+                const handlerConfig = topicHandlers.get(payload.topic);
+                if (!handlerConfig)
+                    return;
+                const instance = provider;
+                const method = instance[handlerConfig.methodName];
+                if (typeof method !== 'function') {
+                    core_2.default.error(`Handler ${handlerConfig.methodName} not found on ${provider.constructor.name}`);
+                    return;
+                }
+                try {
+                    await method.call(provider, payload);
+                }
+                catch (error) {
+                    core_2.default.error(`Error in Kafka handler ${provider.constructor.name}.${handlerConfig.methodName}:`, error);
+                }
+            },
+        });
+        this.runningConsumers.push({
+            consumer,
+            provider,
+            topicHandlers,
+        });
+        core_2.default.info(`Kafka consumer started for ${provider.constructor.name} (groupId: ${consumerOptions.groupId}, topics: ${Array.from(topicHandlers.keys()).join(', ')})`);
+    }
+    async onModuleDestroy() {
+        for (const { consumer } of this.runningConsumers) {
+            try {
+                await consumer.disconnect();
+                core_2.default.info('Kafka consumer disconnected');
+            }
+            catch (error) {
+                core_2.default.error('Error disconnecting Kafka consumer:', error);
+            }
+        }
+        this.runningConsumers = [];
+    }
+    /**
+     * Get count of running consumers
+     */
+    getConsumerCount() {
+        return this.runningConsumers.length;
+    }
+};
+exports.KafkaConsumerService = KafkaConsumerService;
+exports.KafkaConsumerService = KafkaConsumerService = __decorate([
+    (0, core_1.Injectable)(),
+    __param(0, (0, core_1.Inject)(exports.KAFKA_CLIENT_TOKEN)),
+    __metadata("design:paramtypes", [kafkajs_1.Kafka])
+], KafkaConsumerService);

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

@@ -0,0 +1,35 @@
+import { Kafka } from 'kafkajs';
+import { KafkaMessage, KafkaProduceOptions } from './kafka.types';
+export declare const KAFKA_CLIENT_TOKEN = "KAFKA_CLIENT";
+/**
+ * Kafka producer service for publishing messages to topics
+ */
+export declare class KafkaProducerService {
+    private readonly kafka;
+    private producer;
+    private isConnected;
+    constructor(kafka: Kafka);
+    onModuleInit(): Promise<void>;
+    /**
+     * Connect producer (called automatically on first send if not already connected)
+     */
+    private connect;
+    onModuleDestroy(): Promise<void>;
+    /**
+     * Send messages to a topic
+     */
+    send(topic: string, messages: KafkaMessage | KafkaMessage[], options?: KafkaProduceOptions): Promise<void>;
+    /**
+     * Send a batch of messages to multiple topics
+     */
+    sendBatch(batch: Array<{
+        topic: string;
+        messages: KafkaMessage | KafkaMessage[];
+        options?: KafkaProduceOptions;
+    }>): Promise<void>;
+    /**
+     * Check if producer is connected
+     */
+    isProducerConnected(): boolean;
+}
+//# sourceMappingURL=kafka-producer.service.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"kafka-producer.service.d.ts","sourceRoot":"","sources":["../src/kafka-producer.service.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAChC,OAAO,EAAE,YAAY,EAAE,mBAAmB,EAAE,MAAM,eAAe,CAAC;AAGlE,eAAO,MAAM,kBAAkB,iBAAiB,CAAC;AAEjD;;GAEG;AACH,qBACa,oBAAoB;IAM7B,OAAO,CAAC,QAAQ,CAAC,KAAK;IALxB,OAAO,CAAC,QAAQ,CAAgC;IAChD,OAAO,CAAC,WAAW,CAAS;gBAIT,KAAK,EAAE,KAAK;IAKzB,YAAY,IAAI,OAAO,CAAC,IAAI,CAAC;IAInC;;OAEG;YACW,OAAO;IAYf,eAAe,IAAI,OAAO,CAAC,IAAI,CAAC;IAWtC;;OAEG;IACG,IAAI,CACR,KAAK,EAAE,MAAM,EACb,QAAQ,EAAE,YAAY,GAAG,YAAY,EAAE,EACvC,OAAO,CAAC,EAAE,mBAAmB,GAC5B,OAAO,CAAC,IAAI,CAAC;IA0BhB;;OAEG;IACG,SAAS,CACb,KAAK,EAAE,KAAK,CAAC;QACX,KAAK,EAAE,MAAM,CAAC;QACd,QAAQ,EAAE,YAAY,GAAG,YAAY,EAAE,CAAC;QACxC,OAAO,CAAC,EAAE,mBAAmB,CAAC;KAC/B,CAAC,GACD,OAAO,CAAC,IAAI,CAAC;IAShB;;OAEG;IACH,mBAAmB,IAAI,OAAO;CAG/B"}

package/dist/kafka-producer.service.js

@@ -0,0 +1,107 @@
+"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);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KafkaProducerService = exports.KAFKA_CLIENT_TOKEN = void 0;
+const core_1 = require("@hazeljs/core");
+const kafkajs_1 = require("kafkajs");
+const core_2 = __importDefault(require("@hazeljs/core"));
+exports.KAFKA_CLIENT_TOKEN = 'KAFKA_CLIENT';
+/**
+ * Kafka producer service for publishing messages to topics
+ */
+let KafkaProducerService = class KafkaProducerService {
+    constructor(kafka) {
+        this.kafka = kafka;
+        this.isConnected = false;
+        this.producer = this.kafka.producer();
+    }
+    async onModuleInit() {
+        await this.connect();
+    }
+    /**
+     * Connect producer (called automatically on first send if not already connected)
+     */
+    async connect() {
+        if (this.isConnected)
+            return;
+        try {
+            await this.producer.connect();
+            this.isConnected = true;
+            core_2.default.info('Kafka producer connected');
+        }
+        catch (error) {
+            core_2.default.error('Failed to connect Kafka producer:', error);
+            throw error;
+        }
+    }
+    async onModuleDestroy() {
+        try {
+            await this.producer.disconnect();
+            this.isConnected = false;
+            core_2.default.info('Kafka producer disconnected');
+        }
+        catch (error) {
+            core_2.default.error('Error disconnecting Kafka producer:', error);
+            throw error;
+        }
+    }
+    /**
+     * Send messages to a topic
+     */
+    async send(topic, messages, options) {
+        await this.connect();
+        const messageArray = Array.isArray(messages) ? messages : [messages];
+        const formattedMessages = messageArray.map((msg) => {
+            const value = msg.value ?? null;
+            return {
+                key: msg.key ?? undefined,
+                value: value,
+                headers: msg.headers ?? undefined,
+                partition: msg.partition ?? undefined,
+                timestamp: msg.timestamp ?? undefined,
+            };
+        });
+        await this.producer.send({
+            topic,
+            messages: formattedMessages,
+            acks: options?.acks ?? -1,
+            timeout: options?.timeout ?? 30000,
+            compression: options?.compression ?? 0,
+        });
+        core_2.default.debug(`Sent ${formattedMessages.length} message(s) to topic: ${topic}`);
+    }
+    /**
+     * Send a batch of messages to multiple topics
+     */
+    async sendBatch(batch) {
+        await this.connect();
+        await Promise.all(batch.map(({ topic, messages, options }) => this.send(topic, messages, options)));
+        core_2.default.debug(`Sent batch to ${batch.length} topic(s)`);
+    }
+    /**
+     * Check if producer is connected
+     */
+    isProducerConnected() {
+        return this.isConnected;
+    }
+};
+exports.KafkaProducerService = KafkaProducerService;
+exports.KafkaProducerService = KafkaProducerService = __decorate([
+    (0, core_1.Injectable)(),
+    __param(0, (0, core_1.Inject)(exports.KAFKA_CLIENT_TOKEN)),
+    __metadata("design:paramtypes", [kafkajs_1.Kafka])
+], KafkaProducerService);

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

@@ -0,0 +1,43 @@
+import { Kafka } from 'kafkajs';
+import { KafkaStreamTransform } from './kafka.types';
+export declare const KAFKA_CLIENT_TOKEN = "KAFKA_CLIENT";
+/**
+ * Lightweight Kafka stream processor: consume from topic, transform, produce to output topic
+ */
+export declare class KafkaStreamProcessor {
+    private kafka;
+    private consumer;
+    private producer;
+    private pipelineConfig;
+    private isRunning;
+    constructor(kafka: Kafka);
+    /**
+     * Set the input topic to consume from
+     */
+    from(topic: string): this;
+    /**
+     * Set the transform function
+     */
+    transform(fn: KafkaStreamTransform): this;
+    /**
+     * Set the output topic to produce to
+     */
+    to(topic: string): this;
+    /**
+     * Set consumer group ID for the stream processor
+     */
+    withGroupId(groupId: string): this;
+    /**
+     * Start the stream processor
+     */
+    start(): Promise<void>;
+    /**
+     * Stop the stream processor
+     */
+    stop(): Promise<void>;
+    /**
+     * Check if processor is running
+     */
+    isProcessorRunning(): boolean;
+}
+//# sourceMappingURL=kafka-stream.processor.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"kafka-stream.processor.d.ts","sourceRoot":"","sources":["../src/kafka-stream.processor.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAChC,OAAO,EAAE,oBAAoB,EAAE,MAAM,eAAe,CAAC;AAGrD,eAAO,MAAM,kBAAkB,iBAAiB,CAAC;AASjD;;GAEG;AACH,qBACa,oBAAoB;IAC/B,OAAO,CAAC,KAAK,CAAQ;IACrB,OAAO,CAAC,QAAQ,CAA8C;IAC9D,OAAO,CAAC,QAAQ,CAA8C;IAC9D,OAAO,CAAC,cAAc,CAAqC;IAC3D,OAAO,CAAC,SAAS,CAAS;gBAIxB,KAAK,EAAE,KAAK;IAKd;;OAEG;IACH,IAAI,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;IAezB;;OAEG;IACH,SAAS,CAAC,EAAE,EAAE,oBAAoB,GAAG,IAAI;IAQzC;;OAEG;IACH,EAAE,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;IAQvB;;OAEG;IACH,WAAW,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI;IAQlC;;OAEG;IACG,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAsE5B;;OAEG;IACG,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAiB3B;;OAEG;IACH,kBAAkB,IAAI,OAAO;CAG9B"}

package/dist/kafka-stream.processor.js

@@ -0,0 +1,168 @@
+"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);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KafkaStreamProcessor = exports.KAFKA_CLIENT_TOKEN = void 0;
+const core_1 = require("@hazeljs/core");
+const kafkajs_1 = require("kafkajs");
+const core_2 = __importDefault(require("@hazeljs/core"));
+exports.KAFKA_CLIENT_TOKEN = 'KAFKA_CLIENT';
+/**
+ * Lightweight Kafka stream processor: consume from topic, transform, produce to output topic
+ */
+let KafkaStreamProcessor = class KafkaStreamProcessor {
+    constructor(kafka) {
+        this.consumer = null;
+        this.producer = null;
+        this.pipelineConfig = null;
+        this.isRunning = false;
+        this.kafka = kafka;
+    }
+    /**
+     * Set the input topic to consume from
+     */
+    from(topic) {
+        if (!this.pipelineConfig) {
+            this.pipelineConfig = {
+                inputTopic: topic,
+                outputTopic: '',
+                transform: async (msg) => ({
+                    value: msg.value,
+                }),
+            };
+        }
+        else {
+            this.pipelineConfig.inputTopic = topic;
+        }
+        return this;
+    }
+    /**
+     * Set the transform function
+     */
+    transform(fn) {
+        if (!this.pipelineConfig) {
+            throw new Error('Call from(topic) before transform()');
+        }
+        this.pipelineConfig.transform = fn;
+        return this;
+    }
+    /**
+     * Set the output topic to produce to
+     */
+    to(topic) {
+        if (!this.pipelineConfig) {
+            throw new Error('Call from(topic) before to()');
+        }
+        this.pipelineConfig.outputTopic = topic;
+        return this;
+    }
+    /**
+     * Set consumer group ID for the stream processor
+     */
+    withGroupId(groupId) {
+        if (!this.pipelineConfig) {
+            throw new Error('Call from(topic) before withGroupId()');
+        }
+        this.pipelineConfig.groupId = groupId;
+        return this;
+    }
+    /**
+     * Start the stream processor
+     */
+    async start() {
+        if (!this.pipelineConfig) {
+            throw new Error('Pipeline not configured. Use from().transform().to()');
+        }
+        if (this.isRunning) {
+            core_2.default.warn('Kafka stream processor already running');
+            return;
+        }
+        const { inputTopic, outputTopic, transform } = this.pipelineConfig;
+        const groupId = this.pipelineConfig.groupId ?? `stream-${inputTopic}-${outputTopic}`;
+        this.consumer = this.kafka.consumer({ groupId });
+        this.producer = this.kafka.producer();
+        await this.consumer.connect();
+        await this.producer.connect();
+        await this.consumer.subscribe({ topics: [inputTopic], fromBeginning: false });
+        this.isRunning = true;
+        await this.consumer.run({
+            eachMessage: async ({ message }) => {
+                try {
+                    const result = await transform({
+                        key: message.key,
+                        value: message.value,
+                        headers: message.headers,
+                    });
+                    if (result === null)
+                        return;
+                    const outputMessage = typeof result === 'object' && result !== null && 'value' in result
+                        ? result
+                        : { value: result };
+                    const value = outputMessage.value === undefined || outputMessage.value === null
+                        ? message.value
+                        : typeof outputMessage.value === 'string' || Buffer.isBuffer(outputMessage.value)
+                            ? outputMessage.value
+                            : JSON.stringify(outputMessage.value);
+                    await this.producer.send({
+                        topic: outputTopic,
+                        messages: [
+                            {
+                                key: outputMessage.key ?? message.key,
+                                value,
+                                headers: outputMessage.headers ?? message.headers,
+                            },
+                        ],
+                    });
+                }
+                catch (error) {
+                    core_2.default.error('Error in stream transform:', error);
+                    throw error;
+                }
+            },
+        });
+        core_2.default.info(`Kafka stream processor started: ${inputTopic} -> ${outputTopic} (groupId: ${groupId})`);
+    }
+    /**
+     * Stop the stream processor
+     */
+    async stop() {
+        if (!this.isRunning)
+            return;
+        if (this.consumer) {
+            await this.consumer.disconnect();
+            this.consumer = null;
+        }
+        if (this.producer) {
+            await this.producer.disconnect();
+            this.producer = null;
+        }
+        this.isRunning = false;
+        this.pipelineConfig = null;
+        core_2.default.info('Kafka stream processor stopped');
+    }
+    /**
+     * Check if processor is running
+     */
+    isProcessorRunning() {
+        return this.isRunning;
+    }
+};
+exports.KafkaStreamProcessor = KafkaStreamProcessor;
+exports.KafkaStreamProcessor = KafkaStreamProcessor = __decorate([
+    (0, core_1.Injectable)(),
+    __param(0, (0, core_1.Inject)(exports.KAFKA_CLIENT_TOKEN)),
+    __metadata("design:paramtypes", [kafkajs_1.Kafka])
+], KafkaStreamProcessor);

package/dist/kafka.module.d.ts

@@ -0,0 +1,33 @@
+import { KafkaModuleOptions } from './kafka.types';
+/**
+ * Kafka module for HazelJS
+ */
+export declare class KafkaModule {
+    /**
+     * Configure Kafka module.
+     * Registers the Kafka client with the container before module initialization,
+     * since HazelJS does not process dynamic module provider configs from forRoot return values.
+     */
+    static forRoot(options?: Partial<KafkaModuleOptions>): typeof KafkaModule;
+    /**
+     * Configure Kafka module asynchronously.
+     * Must be awaited before creating the app so the Kafka client is registered.
+     */
+    static forRootAsync(options: {
+        useFactory: (...args: unknown[]) => Promise<KafkaModuleOptions> | KafkaModuleOptions;
+        inject?: unknown[];
+    }): Promise<typeof KafkaModule>;
+    /**
+     * Register Kafka consumers from a provider instance.
+     * Call this after the provider has been instantiated (e.g. in bootstrap).
+     *
+     * @example
+     * ```typescript
+     * const container = Container.getInstance();
+     * const orderConsumer = container.resolve(OrderConsumer);
+     * KafkaModule.registerConsumersFromProvider(orderConsumer);
+     * ```
+     */
+    static registerConsumersFromProvider(provider: object): Promise<void>;
+}
+//# sourceMappingURL=kafka.module.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"kafka.module.d.ts","sourceRoot":"","sources":["../src/kafka.module.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,kBAAkB,EAAE,MAAM,eAAe,CAAC;AAQnD;;GAEG;AACH,qBAIa,WAAW;IACtB;;;;OAIG;IACH,MAAM,CAAC,OAAO,CAAC,OAAO,GAAE,OAAO,CAAC,kBAAkB,CAAM,GAAG,OAAO,WAAW;IAgB7E;;;OAGG;WACU,YAAY,CAAC,OAAO,EAAE;QACjC,UAAU,EAAE,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,OAAO,CAAC,kBAAkB,CAAC,GAAG,kBAAkB,CAAC;QACrF,MAAM,CAAC,EAAE,OAAO,EAAE,CAAC;KACpB,GAAG,OAAO,CAAC,OAAO,WAAW,CAAC;IAiB/B;;;;;;;;;;OAUG;WACU,6BAA6B,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;CAgB5E"}

package/dist/kafka.module.js

@@ -0,0 +1,93 @@
+"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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+var KafkaModule_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KafkaModule = void 0;
+const core_1 = require("@hazeljs/core");
+const kafkajs_1 = require("kafkajs");
+const kafka_producer_service_1 = require("./kafka-producer.service");
+const kafka_consumer_service_1 = require("./kafka-consumer.service");
+const kafka_stream_processor_1 = require("./kafka-stream.processor");
+const kafka_producer_service_2 = require("./kafka-producer.service");
+const core_2 = require("@hazeljs/core");
+const core_3 = __importDefault(require("@hazeljs/core"));
+/**
+ * Kafka module for HazelJS
+ */
+let KafkaModule = KafkaModule_1 = class KafkaModule {
+    /**
+     * Configure Kafka module.
+     * Registers the Kafka client with the container before module initialization,
+     * since HazelJS does not process dynamic module provider configs from forRoot return values.
+     */
+    static forRoot(options = {}) {
+        const { clientId = 'hazeljs-app', brokers = ['localhost:9092'], ...kafkaOptions } = options;
+        core_3.default.info('Configuring Kafka module...');
+        const kafkaClient = new kafkajs_1.Kafka({
+            clientId,
+            brokers,
+            ...kafkaOptions,
+        });
+        core_2.Container.getInstance().register(kafka_producer_service_2.KAFKA_CLIENT_TOKEN, kafkaClient);
+        return KafkaModule_1;
+    }
+    /**
+     * Configure Kafka module asynchronously.
+     * Must be awaited before creating the app so the Kafka client is registered.
+     */
+    static async forRootAsync(options) {
+        const container = core_2.Container.getInstance();
+        const injectTokens = options.inject ?? [];
+        const deps = injectTokens.map((token) => container.resolve(token));
+        const kafkaOptions = await Promise.resolve(options.useFactory(...deps));
+        const { clientId = 'hazeljs-app', brokers = ['localhost:9092'], ...rest } = kafkaOptions;
+        const kafkaClient = new kafkajs_1.Kafka({
+            clientId,
+            brokers,
+            ...rest,
+        });
+        container.register(kafka_producer_service_2.KAFKA_CLIENT_TOKEN, kafkaClient);
+        return KafkaModule_1;
+    }
+    /**
+     * Register Kafka consumers from a provider instance.
+     * Call this after the provider has been instantiated (e.g. in bootstrap).
+     *
+     * @example
+     * ```typescript
+     * const container = Container.getInstance();
+     * const orderConsumer = container.resolve(OrderConsumer);
+     * KafkaModule.registerConsumersFromProvider(orderConsumer);
+     * ```
+     */
+    static async registerConsumersFromProvider(provider) {
+        try {
+            const container = core_2.Container.getInstance();
+            const consumerService = container.resolve(kafka_consumer_service_1.KafkaConsumerService);
+            if (!consumerService) {
+                core_3.default.warn('KafkaConsumerService not found in DI container');
+                return;
+            }
+            await consumerService.registerFromProvider(provider);
+            core_3.default.info(`Registered Kafka consumer from provider: ${provider.constructor.name}`);
+        }
+        catch (error) {
+            core_3.default.error('Error registering Kafka consumers from provider:', error);
+        }
+    }
+};
+exports.KafkaModule = KafkaModule;
+exports.KafkaModule = KafkaModule = KafkaModule_1 = __decorate([
+    (0, core_1.HazelModule)({
+        providers: [kafka_producer_service_1.KafkaProducerService, kafka_consumer_service_1.KafkaConsumerService, kafka_stream_processor_1.KafkaStreamProcessor],
+        exports: [kafka_producer_service_1.KafkaProducerService, kafka_consumer_service_1.KafkaConsumerService, kafka_stream_processor_1.KafkaStreamProcessor],
+    })
+], KafkaModule);

package/dist/kafka.types.d.ts

@@ -0,0 +1,137 @@
+/**
+ * Kafka module types and interfaces
+ */
+/**
+ * SASL authentication mechanism
+ */
+export type SaslMechanism = 'plain' | 'scram-sha-256' | 'scram-sha-512';
+/**
+ * SASL configuration for Kafka authentication
+ */
+export interface KafkaSaslOptions {
+    mechanism: SaslMechanism;
+    username: string;
+    password: string;
+}
+/**
+ * SSL configuration for Kafka
+ */
+export interface KafkaSslOptions {
+    rejectUnauthorized?: boolean;
+    ca?: string[];
+    cert?: string;
+    key?: string;
+}
+/**
+ * Base Kafka client options (KafkaJS compatible)
+ */
+export interface KafkaClientOptions {
+    clientId: string;
+    brokers: string[];
+    connectionTimeout?: number;
+    requestTimeout?: number;
+    retry?: {
+        retries?: number;
+        initialRetryTime?: number;
+        maxRetryTime?: number;
+    };
+    ssl?: boolean | KafkaSslOptions;
+    sasl?: KafkaSaslOptions;
+}
+/**
+ * Kafka module options for forRoot()
+ */
+export interface KafkaModuleOptions extends KafkaClientOptions {
+    /**
+     * Whether this is a global module
+     * @default true
+     */
+    isGlobal?: boolean;
+    /**
+     * Enable Kafka Stream Processor
+     * @default true
+     */
+    enableStreamProcessor?: boolean;
+}
+/**
+ * Consumer group options (KafkaJS consumer config)
+ */
+export interface KafkaConsumerOptions {
+    groupId: string;
+    sessionTimeout?: number;
+    rebalanceTimeout?: number;
+    heartbeatInterval?: number;
+    maxWaitTimeInMs?: number;
+    retry?: {
+        retries?: number;
+        initialRetryTime?: number;
+        maxRetryTime?: number;
+    };
+}
+/**
+ * Topic subscription options
+ */
+export interface KafkaSubscribeOptions {
+    /**
+     * Read from beginning of topic
+     * @default false
+     */
+    fromBeginning?: boolean;
+}
+/**
+ * Producer send options
+ */
+export interface KafkaProduceOptions {
+    acks?: -1 | 0 | 1;
+    timeout?: number;
+    compression?: 0 | 1 | 2 | 3;
+}
+/**
+ * Kafka message for producing
+ */
+export interface KafkaMessage {
+    key?: string | Buffer;
+    value: string | Buffer | null;
+    headers?: Record<string, string>;
+    partition?: number;
+    timestamp?: string;
+}
+/**
+ * Payload passed to eachMessage handler (matches KafkaJS EachMessagePayload)
+ */
+export interface KafkaMessagePayload {
+    topic: string;
+    partition: number;
+    message: {
+        key: Buffer | null;
+        value: Buffer | null;
+        headers: Record<string, string>;
+        offset: string;
+        timestamp: string;
+        attributes?: number;
+    };
+    heartbeat(): Promise<void>;
+    pause(): void;
+    commitOffsets?(offsets: Array<{
+        topic: string;
+        partition: number;
+        offset: string;
+    }>): Promise<void>;
+}
+/**
+ * Handler type for Kafka message processing
+ */
+export type KafkaMessageHandler = (payload: KafkaMessagePayload) => Promise<void>;
+/**
+ * Transform function for stream processor
+ */
+export type KafkaStreamTransform<T = unknown, R = unknown> = (message: {
+    key: Buffer | null;
+    value: Buffer | null;
+    headers: Record<string, string>;
+}) => Promise<{
+    key?: string | Buffer;
+    value: T | string | Buffer | null;
+    headers?: Record<string, string>;
+} | R | null>;
+//# sourceMappingURL=kafka.types.d.ts.map

package/dist/kafka.types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"kafka.types.d.ts","sourceRoot":"","sources":["../src/kafka.types.ts"],"names":[],"mappings":"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"}

package/dist/kafka.types.js

@@ -0,0 +1,5 @@
+"use strict";
+/**
+ * Kafka module types and interfaces
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -0,0 +1,52 @@
+{
+  "name": "@hazeljs/kafka",
+  "version": "0.2.0-beta.18",
+  "description": "Kafka module for HazelJS framework - produce, consume, and stream processing",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "test": "jest --coverage",
+    "lint": "eslint \"src/**/*.ts\"",
+    "lint:fix": "eslint \"src/**/*.ts\" --fix",
+    "clean": "rm -rf dist"
+  },
+  "dependencies": {
+    "@hazeljs/core": "^0.2.0-beta.18",
+    "kafkajs": "^2.2.4"
+  },
+  "devDependencies": {
+    "@types/node": "^20.17.50",
+    "@typescript-eslint/eslint-plugin": "^8.18.2",
+    "@typescript-eslint/parser": "^8.18.2",
+    "eslint": "^8.56.0",
+    "jest": "^29.7.0",
+    "ts-jest": "^29.1.2",
+    "typescript": "^5.3.3"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/hazel-js/hazeljs.git",
+    "directory": "packages/kafka"
+  },
+  "keywords": [
+    "hazeljs",
+    "kafka",
+    "message-queue",
+    "stream-processing",
+    "kafkajs"
+  ],
+  "author": "Muhammad Arslan <marslan@hazeljs.com>",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/hazeljs/hazel-js/issues"
+  },
+  "homepage": "https://hazeljs.com",
+  "gitHead": "22082c1277661421cd32b3c4371c2c9d0bdf0501"
+}