@hazeljs/kafka 0.2.0-alpha.1

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.Service)(),
+    __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.Service)(),
+    __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"}