@hazeljs/kafka 0.2.0-alpha.1

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.Service)(),
+    __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,54 @@
+{
+  "name": "@hazeljs/kafka",
+  "version": "0.2.0-alpha.1",
+  "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": {
+    "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 <muhammad.arslan@hazeljs.com>",
+  "license": "Apache-2.0",
+  "bugs": {
+    "url": "https://github.com/hazeljs/hazel-js/issues"
+  },
+  "homepage": "https://hazeljs.com",
+  "peerDependencies": {
+    "@hazeljs/core": ">=0.2.0-beta.0"
+  },
+  "gitHead": "cbc5ee2c12ced28fd0576faf13c5f078c1e8421e"
+}