@application-kit/kafka 0.0.0

package/dist/esm/configs/kafka-consumer.config.d.ts

@@ -0,0 +1,9 @@
+import { KafkaOptions } from '@nestjs/microservices';
+import { KafkaConsumerEnvironment } from './envs/kafka-consumer.environment.js';
+import { KafkaConfig } from './kafka.config.js';
+export declare class KafkaConsumerConfig {
+    private readonly kafkaConfig;
+    private readonly kafkaConsumerEnvironment;
+    constructor(kafkaConfig: KafkaConfig, kafkaConsumerEnvironment: KafkaConsumerEnvironment);
+    getOptions(): KafkaOptions;
+}

package/dist/esm/configs/kafka-consumer.config.js

@@ -0,0 +1,47 @@
+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);
+};
+import { Injectable } from '@nestjs/common';
+import { KafkaConsumerEnvironment } from './envs/kafka-consumer.environment.js';
+import { KafkaConfig } from './kafka.config.js';
+let KafkaConsumerConfig = class KafkaConsumerConfig {
+    kafkaConfig;
+    kafkaConsumerEnvironment;
+    constructor(kafkaConfig, kafkaConsumerEnvironment) {
+        this.kafkaConfig = kafkaConfig;
+        this.kafkaConsumerEnvironment = kafkaConsumerEnvironment;
+    }
+    getOptions() {
+        const options = this.kafkaConfig.getOptions();
+        options.options = {
+            ...options.options,
+            consumer: {
+                allowAutoTopicCreation: true,
+                groupId: this.kafkaConsumerEnvironment.KAFKA_GROUP_ID,
+                retry: {
+                    initialRetryTime: 100,
+                    retries: 0,
+                },
+            },
+            run: {
+                autoCommit: false,
+            },
+            subscribe: {
+                fromBeginning: true,
+            },
+        };
+        return options;
+    }
+};
+KafkaConsumerConfig = __decorate([
+    Injectable(),
+    __metadata("design:paramtypes", [KafkaConfig,
+        KafkaConsumerEnvironment])
+], KafkaConsumerConfig);
+export { KafkaConsumerConfig };

package/dist/esm/configs/kafka-producer.config.d.ts

@@ -0,0 +1,7 @@
+import { KafkaOptions } from '@nestjs/microservices';
+import { KafkaConfig } from './kafka.config.js';
+export declare class KafkaProducerConfig {
+    private readonly kafkaConfig;
+    constructor(kafkaConfig: KafkaConfig);
+    getOptions(): KafkaOptions;
+}

package/dist/esm/configs/kafka-producer.config.js

@@ -0,0 +1,38 @@
+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);
+};
+import { Injectable } from '@nestjs/common';
+import { Partitioners } from 'kafkajs';
+import { KafkaConfig } from './kafka.config.js';
+let KafkaProducerConfig = class KafkaProducerConfig {
+    kafkaConfig;
+    constructor(kafkaConfig) {
+        this.kafkaConfig = kafkaConfig;
+    }
+    getOptions() {
+        const options = this.kafkaConfig.getOptions();
+        options.options = {
+            ...options.options,
+            producer: {
+                allowAutoTopicCreation: true,
+                createPartitioner: Partitioners.DefaultPartitioner,
+                retry: {
+                    retries: 1,
+                },
+            },
+            producerOnlyMode: true,
+        };
+        return options;
+    }
+};
+KafkaProducerConfig = __decorate([
+    Injectable(),
+    __metadata("design:paramtypes", [KafkaConfig])
+], KafkaProducerConfig);
+export { KafkaProducerConfig };

package/dist/esm/configs/kafka.config.d.ts

@@ -0,0 +1,7 @@
+import { KafkaOptions } from '@nestjs/microservices';
+import { KafkaConfigEnvironment } from './envs/kafka-config.environment.js';
+export declare class KafkaConfig {
+    protected readonly kafkaEnvironment: KafkaConfigEnvironment;
+    constructor(kafkaEnvironment: KafkaConfigEnvironment);
+    getOptions(): KafkaOptions;
+}

package/dist/esm/configs/kafka.config.js

@@ -0,0 +1,49 @@
+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);
+};
+import { Injectable } from '@nestjs/common';
+import { Transport } from '@nestjs/microservices';
+import { logLevel } from '@nestjs/microservices/external/kafka.interface.js';
+import { randomUUID } from 'node:crypto';
+import { readFileSync } from 'node:fs';
+import { KafkaConfigEnvironment } from './envs/kafka-config.environment.js';
+let KafkaConfig = class KafkaConfig {
+    kafkaEnvironment;
+    constructor(kafkaEnvironment) {
+        this.kafkaEnvironment = kafkaEnvironment;
+    }
+    getOptions() {
+        const { KAFKA_BROKERS, KAFKA_CLIENT_ID, KAFKA_LOG_LEVEL, KAFKA_SASL_PASSWORD, KAFKA_SASL_USERNAME, KAFKA_SSL_CA_FILE, } = this.kafkaEnvironment;
+        let ssl;
+        if (KAFKA_SSL_CA_FILE !== undefined) {
+            ssl = { ca: [readFileSync(KAFKA_SSL_CA_FILE, 'utf8')] };
+        }
+        const sasl = KAFKA_SASL_PASSWORD === undefined || KAFKA_SASL_USERNAME === undefined
+            ? undefined
+            : { mechanism: 'scram-sha-512', password: KAFKA_SASL_PASSWORD, username: KAFKA_SASL_USERNAME };
+        return {
+            options: {
+                client: {
+                    brokers: KAFKA_BROKERS.split(','),
+                    clientId: `${KAFKA_CLIENT_ID}-${randomUUID()}`,
+                    logLevel: logLevel[KAFKA_LOG_LEVEL],
+                    ...(ssl !== undefined && { ssl }),
+                    ...(sasl !== undefined && { sasl }),
+                },
+                postfixId: '',
+            },
+            transport: Transport.KAFKA,
+        };
+    }
+};
+KafkaConfig = __decorate([
+    Injectable(),
+    __metadata("design:paramtypes", [KafkaConfigEnvironment])
+], KafkaConfig);
+export { KafkaConfig };

package/dist/esm/constants.d.ts

@@ -0,0 +1,3 @@
+export declare const KAFKA_PRODUCER: unique symbol;
+export declare const KAFKA_LOGGER: unique symbol;
+export declare const KAFKA_ERROR_HANDLER_OPTIONS: unique symbol;

package/dist/esm/constants.js

@@ -0,0 +1,3 @@
+export const KAFKA_PRODUCER = Symbol('KAFKA_PRODUCER');
+export const KAFKA_LOGGER = Symbol('KAFKA_LOGGER');
+export const KAFKA_ERROR_HANDLER_OPTIONS = Symbol('KAFKA_ERROR_HANDLER_OPTIONS');

package/dist/esm/event-contract-version.d.ts

@@ -0,0 +1,5 @@
+export declare const DEFAULT_EVENT_VERSION = "1";
+export declare const EVENT_VERSION_HEADER = "x-event-version";
+export declare const eventVersionOfTopic: (topic: string) => string;
+export declare const eventVersionOfHeaders: (headers: Record<string, unknown> | undefined) => string;
+export declare const versionedQueueName: (queueName: string, version: string) => string;

package/dist/esm/event-contract-version.js

@@ -0,0 +1,14 @@
+export const DEFAULT_EVENT_VERSION = '1';
+export const EVENT_VERSION_HEADER = 'x-event-version';
+const VERSION_SEGMENT = /^v\d+$/u;
+const versionSegment = (version) => (version === DEFAULT_EVENT_VERSION ? '' : `.v${version}`);
+export const eventVersionOfTopic = (topic) => {
+    const segment = topic.split('.').find((part) => VERSION_SEGMENT.test(part));
+    return segment === undefined ? DEFAULT_EVENT_VERSION : segment.slice(1);
+};
+export const eventVersionOfHeaders = (headers) => {
+    const raw = headers?.[EVENT_VERSION_HEADER];
+    const value = Buffer.isBuffer(raw) ? raw.toString('utf8') : raw;
+    return typeof value === 'string' && value !== '' ? value : DEFAULT_EVENT_VERSION;
+};
+export const versionedQueueName = (queueName, version) => `${queueName}${versionSegment(version)}`;

package/dist/esm/index.d.ts

@@ -0,0 +1,7 @@
+export * from './configs/index.js';
+export * from './libs/index.js';
+export * from './constants.js';
+export * from './event-contract-version.js';
+export * from './kafka-commit-interceptor.js';
+export * from './kafka-error-handler.js';
+export * from './kafka.module.js';

package/dist/esm/index.js

@@ -0,0 +1,7 @@
+export * from './configs/index.js';
+export * from './libs/index.js';
+export * from './constants.js';
+export * from './event-contract-version.js';
+export * from './kafka-commit-interceptor.js';
+export * from './kafka-error-handler.js';
+export * from './kafka.module.js';

package/dist/esm/kafka-commit-interceptor.d.ts

@@ -0,0 +1,13 @@
+import { CallHandler, ExecutionContext, NestInterceptor } from '@nestjs/common';
+import { Observable } from 'rxjs';
+import type { KafkaLoggerInterface } from './libs/kafka-logger.interface.js';
+import { KafkaErrorHandler } from './kafka-error-handler.js';
+export declare class KafkaCommitInterceptor implements NestInterceptor {
+    private readonly kafkaErrorHandler;
+    private readonly logger;
+    constructor(kafkaErrorHandler: KafkaErrorHandler, logger: KafkaLoggerInterface);
+    intercept(context: ExecutionContext, next: CallHandler): Observable<unknown>;
+    private readCommitContext;
+    private rejectForeignContractVersion;
+}
+export declare const KafkaAutoCommit: () => MethodDecorator;

package/dist/esm/kafka-commit-interceptor.js

@@ -0,0 +1,83 @@
+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); }
+};
+import { applyDecorators, BadRequestException, Inject, Injectable, UseInterceptors, } from '@nestjs/common';
+import { catchError, of, tap, throwError } from 'rxjs';
+import { KAFKA_LOGGER } from './constants.js';
+import { eventVersionOfHeaders, eventVersionOfTopic } from './event-contract-version.js';
+import { KafkaErrorHandler } from './kafka-error-handler.js';
+let KafkaCommitInterceptor = class KafkaCommitInterceptor {
+    kafkaErrorHandler;
+    logger;
+    constructor(kafkaErrorHandler, logger) {
+        this.kafkaErrorHandler = kafkaErrorHandler;
+        this.logger = logger;
+    }
+    intercept(context, next) {
+        if (context.getType() !== 'rpc') {
+            return next.handle();
+        }
+        const kafkaContext = context.switchToRpc().getContext();
+        if (kafkaContext === undefined || typeof kafkaContext.getConsumer !== 'function') {
+            return next.handle();
+        }
+        const { consumer, logContext, nextOffset, partition, topic } = this.readCommitContext(kafkaContext);
+        const rejected = this.rejectForeignContractVersion(kafkaContext, topic);
+        return (rejected ?? next.handle()).pipe(tap(async () => {
+            try {
+                await consumer.commitOffsets([{ offset: nextOffset, partition, topic }]);
+                this.logger.info(logContext, 'Kafka message processed');
+            }
+            catch (commitError) {
+                this.logger.error({ errorContext: { ...logContext, error: commitError } }, `Failed to commit offset: ${Error.isError(commitError) ? commitError.message : 'Unknown error'}`);
+            }
+        }), catchError(async (error) => {
+            try {
+                const commitOffsets = async () => {
+                    await consumer.commitOffsets([{ offset: nextOffset, partition, topic }]);
+                };
+                await this.kafkaErrorHandler.handleError(kafkaContext, error, commitOffsets);
+                this.logger.warn({ errorContext: { ...logContext, error: error.message } }, `Message moved to retry/dlq: ${error.message}`);
+            }
+            catch (catchedError) {
+                this.logger.error({ errorContext: { ...logContext, error: catchedError } }, `Failed to move message to retry/dlq: ${Error.isError(catchedError) ? catchedError.message : 'Unknown error'}`);
+            }
+            return of(error);
+        }));
+    }
+    readCommitContext(kafkaContext) {
+        const { headers, key, offset } = kafkaContext.getMessage();
+        const partition = kafkaContext.getPartition();
+        const topic = kafkaContext.getTopic();
+        return {
+            consumer: kafkaContext.getConsumer(),
+            logContext: { headers, key, offset, partition, topic },
+            nextOffset: (BigInt(offset) + 1n).toString(),
+            partition,
+            topic,
+        };
+    }
+    rejectForeignContractVersion(kafkaContext, topic) {
+        const expectedVersion = eventVersionOfTopic(topic);
+        const messageVersion = eventVersionOfHeaders(kafkaContext.getMessage().headers);
+        return messageVersion === expectedVersion
+            ? undefined
+            : throwError(() => new BadRequestException(`Unsupported event contract version "${messageVersion}" on topic "${topic}": expected "${expectedVersion}"`));
+    }
+};
+KafkaCommitInterceptor = __decorate([
+    Injectable(),
+    __param(1, Inject(KAFKA_LOGGER)),
+    __metadata("design:paramtypes", [KafkaErrorHandler, Object])
+], KafkaCommitInterceptor);
+export { KafkaCommitInterceptor };
+export const KafkaAutoCommit = () => applyDecorators(UseInterceptors(KafkaCommitInterceptor));

package/dist/esm/kafka-error-handler.d.ts

@@ -0,0 +1,25 @@
+import { ClientKafka, KafkaContext } from '@nestjs/microservices';
+import type { KafkaLoggerInterface } from './libs/kafka-logger.interface.js';
+export interface KafkaErrorHandlerOptionsInterface {
+    baseDelayMs: number;
+    maxAttempts: number;
+    topicSuffix: {
+        dlq: string;
+        retry: string;
+    };
+}
+export declare class KafkaErrorHandler {
+    private readonly client;
+    private readonly logger;
+    private readonly options;
+    constructor(client: ClientKafka, logger: KafkaLoggerInterface, options: KafkaErrorHandlerOptionsInterface);
+    handleError(context: KafkaContext, error: Error, commit: () => Promise<void>): Promise<void>;
+    private buildPayload;
+    private headers;
+    private readAttempt;
+    private scheduleRetry;
+    private sendToDlq;
+    private stringifyKey;
+    private stringifyValue;
+    private stripRetrySuffixes;
+}

package/dist/esm/kafka-error-handler.js

@@ -0,0 +1,115 @@
+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); }
+};
+import { BadRequestException, Inject, Injectable } from '@nestjs/common';
+import { ClientKafka } from '@nestjs/microservices';
+import { firstValueFrom } from 'rxjs';
+import { KAFKA_ERROR_HANDLER_OPTIONS, KAFKA_LOGGER, KAFKA_PRODUCER, } from './constants.js';
+let KafkaErrorHandler = class KafkaErrorHandler {
+    client;
+    logger;
+    options;
+    constructor(client, logger, options) {
+        this.client = client;
+        this.logger = logger;
+        this.options = options;
+    }
+    async handleError(context, error, commit) {
+        const message = context.getMessage();
+        const topic = context.getTopic();
+        const payload = this.buildPayload(message);
+        const attempt = this.readAttempt(message.headers ?? {});
+        const baseTopic = this.stripRetrySuffixes(topic);
+        const isRetryableError = !(error instanceof BadRequestException);
+        if (isRetryableError && attempt < this.options.maxAttempts) {
+            this.scheduleRetry({ attempt, baseTopic, commit, error, payload, topic });
+            return;
+        }
+        await this.sendToDlq({ baseTopic, commit, error, key: message.key, payload });
+    }
+    buildPayload(message) {
+        return {
+            headers: this.headers(message.headers ?? {}),
+            key: this.stringifyKey(message.key),
+            value: this.stringifyValue(message.value),
+        };
+    }
+    headers(headers) {
+        const flatHeaders = {};
+        for (const [key, value] of Object.entries(headers)) {
+            if (value !== undefined) {
+                flatHeaders[key] = typeof value === 'object' && !Buffer.isBuffer(value)
+                    ? JSON.stringify(value)
+                    : value;
+            }
+        }
+        return flatHeaders;
+    }
+    readAttempt(headers) {
+        const parsedAttempt = Number(headers['x-retry-attempt']?.toString());
+        return Number.isFinite(parsedAttempt) ? Math.trunc(parsedAttempt) : 0;
+    }
+    scheduleRetry(parameters) {
+        const { attempt, baseTopic, commit, error, payload, topic } = parameters;
+        const { baseDelayMs, maxAttempts, topicSuffix } = this.options;
+        const retryTopic = `${baseTopic}.${topicSuffix.retry}`;
+        const nextAttempt = attempt + 1;
+        const delayMs = baseDelayMs * 2 ** attempt;
+        payload.headers['x-retry-attempt'] = nextAttempt.toString();
+        payload.headers['x-retry-reason'] = error.message;
+        this.logger.warn({ errorContext: {
+                delayMs,
+                headers: payload.headers,
+                key: payload.key,
+                maxAttempts,
+                nextAttempt,
+                topic,
+            } }, `[Retry] Attempt ${nextAttempt}/${maxAttempts} for "${topic}". Waiting ${delayMs}ms...`);
+        setTimeout(async () => {
+            try {
+                await firstValueFrom(this.client.emit(retryTopic, payload));
+                await commit();
+            }
+            catch (retryError) {
+                this.logger.error({ errorContext: { error: retryError, key: payload.key, topic: retryTopic } }, `[Retry] Failed to re-emit to "${retryTopic}": ${Error.isError(retryError) ? retryError.message : 'Unknown error'}`);
+            }
+        }, delayMs);
+    }
+    async sendToDlq(parameters) {
+        const { baseTopic, commit, error, key, payload } = parameters;
+        const dlqTopic = `${baseTopic}.${this.options.topicSuffix.dlq}`;
+        payload.headers['x-dlq-reason'] = error.message;
+        this.logger.error({ errorContext: { headers: payload.headers, key, topic: dlqTopic } }, `[DLQ] Send to "${dlqTopic}"`);
+        await firstValueFrom(this.client.emit(dlqTopic, payload));
+        await commit();
+    }
+    stringifyKey(key) {
+        return typeof key === 'object' && !Buffer.isBuffer(key) ? JSON.stringify(key) : key;
+    }
+    stringifyValue(value) {
+        return typeof value === 'object' && !Buffer.isBuffer(value) ? JSON.stringify(value) : value;
+    }
+    stripRetrySuffixes(topic) {
+        const { topicSuffix } = this.options;
+        return topic
+            .replace(`.${topicSuffix.retry}`, '')
+            .replace(`.${topicSuffix.dlq}`, '');
+    }
+};
+KafkaErrorHandler = __decorate([
+    Injectable(),
+    __param(0, Inject(KAFKA_PRODUCER)),
+    __param(1, Inject(KAFKA_LOGGER)),
+    __param(2, Inject(KAFKA_ERROR_HANDLER_OPTIONS)),
+    __metadata("design:paramtypes", [ClientKafka, Object, Object])
+], KafkaErrorHandler);
+export { KafkaErrorHandler };

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

@@ -0,0 +1,9 @@
+import { DynamicModule, Type } from '@nestjs/common';
+import { KafkaErrorHandlerOptionsInterface } from './kafka-error-handler.js';
+import { KafkaLoggerInterface } from './libs/kafka-logger.interface.js';
+export declare class KafkaModule {
+    static forRootAsync(config: {
+        errorHandlerOptions?: Partial<KafkaErrorHandlerOptionsInterface>;
+        logger: Type<KafkaLoggerInterface>;
+    }): DynamicModule;
+}

package/dist/esm/kafka.module.js

@@ -0,0 +1,64 @@
+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;
+};
+import { ConfigsModule } from '@libs-for-dev/nestjs-config-module';
+import { Module } from '@nestjs/common';
+import { ClientsModule } from '@nestjs/microservices';
+import { KafkaConfigEnvironment } from './configs/envs/kafka-config.environment.js';
+import { KafkaProducerConfig } from './configs/kafka-producer.config.js';
+import { KafkaConfig } from './configs/kafka.config.js';
+import { KAFKA_ERROR_HANDLER_OPTIONS, KAFKA_LOGGER, KAFKA_PRODUCER, } from './constants.js';
+import { KafkaCommitInterceptor } from './kafka-commit-interceptor.js';
+import { KafkaErrorHandler } from './kafka-error-handler.js';
+let KafkaModule = class KafkaModule {
+    static forRootAsync(config) {
+        return {
+            exports: [KAFKA_LOGGER],
+            global: true,
+            module: this,
+            providers: [
+                {
+                    provide: KAFKA_ERROR_HANDLER_OPTIONS,
+                    useValue: {
+                        baseDelayMs: 500,
+                        maxAttempts: 5,
+                        topicSuffix: {
+                            dlq: 'dlq',
+                            retry: 'retry',
+                        },
+                        ...config.errorHandlerOptions,
+                    },
+                },
+                {
+                    provide: KAFKA_LOGGER,
+                    useClass: config.logger,
+                },
+            ],
+        };
+    }
+};
+KafkaModule = __decorate([
+    Module({
+        exports: [KafkaCommitInterceptor, KafkaErrorHandler],
+        imports: [
+            ClientsModule.registerAsync({
+                clients: [
+                    {
+                        imports: [ConfigsModule.forFeature([KafkaProducerConfig, KafkaConfig], [KafkaConfigEnvironment])],
+                        inject: [KafkaProducerConfig],
+                        name: KAFKA_PRODUCER,
+                        useFactory: (config) => config.getOptions(),
+                    },
+                ],
+            }),
+        ],
+        providers: [
+            KafkaErrorHandler,
+            KafkaCommitInterceptor,
+        ],
+    })
+], KafkaModule);
+export { KafkaModule };

package/dist/esm/libs/consumer.abstract.d.ts

@@ -0,0 +1,6 @@
+export interface HandlerInterface<TPayload = unknown> {
+    handle(payload: TPayload): Promise<void>;
+}
+export declare abstract class ConsumerAbstract {
+    protected handleAll<TPayload>(payload: TPayload, handlers: HandlerInterface<TPayload>[]): Promise<void>;
+}

package/dist/esm/libs/consumer.abstract.js

@@ -0,0 +1,10 @@
+import { ConsumersError } from './errors/consumers-error.js';
+export class ConsumerAbstract {
+    async handleAll(payload, handlers) {
+        const results = await Promise.allSettled(handlers.map(async (handler) => handler.handle(payload)));
+        const rejectedResults = results.filter((result) => result.status === 'rejected');
+        if (rejectedResults.length > 0) {
+            throw new ConsumersError(rejectedResults.map((result) => result.reason));
+        }
+    }
+}

package/dist/esm/libs/errors/consumers-error.d.ts

@@ -0,0 +1,4 @@
+export declare class ConsumersError extends Error {
+    readonly errors: Error[];
+    constructor(errors: Error[], options?: ErrorOptions);
+}

package/dist/esm/libs/errors/consumers-error.js

@@ -0,0 +1,8 @@
+export class ConsumersError extends Error {
+    errors;
+    constructor(errors, options) {
+        super(errors.map((error) => `${error.name}: "${error.message}"`).join('; '), options);
+        this.errors = errors;
+        this.name = 'ConsumersError';
+    }
+}

package/dist/esm/libs/errors/index.d.ts

@@ -0,0 +1 @@
+export * from './consumers-error.js';

package/dist/esm/libs/errors/index.js

@@ -0,0 +1 @@
+export * from './consumers-error.js';

package/dist/esm/libs/heartbeat-file-writer.d.ts

@@ -0,0 +1,6 @@
+export declare class HeartbeatFileWriter {
+    private readonly filePath?;
+    constructor(filePath?: string | undefined);
+    static fromEnvironment(): HeartbeatFileWriter;
+    touch(): Promise<void>;
+}

package/dist/esm/libs/heartbeat-file-writer.js

@@ -0,0 +1,20 @@
+import { writeFile } from 'node:fs/promises';
+export class HeartbeatFileWriter {
+    filePath;
+    constructor(filePath) {
+        this.filePath = filePath;
+    }
+    static fromEnvironment() {
+        return new HeartbeatFileWriter(process.env.HEARTBEAT_FILE);
+    }
+    async touch() {
+        if (this.filePath === undefined || this.filePath === '') {
+            return;
+        }
+        try {
+            await writeFile(this.filePath, String(Date.now()));
+        }
+        catch {
+        }
+    }
+}

package/dist/esm/libs/index.d.ts

@@ -0,0 +1,9 @@
+export * from './errors/index.js';
+export * from './consumer.abstract.js';
+export * from './heartbeat-file-writer.js';
+export * from './kafka-consumer-heartbeat.js';
+export * from './kafka-consumer-server.js';
+export * from './kafka-logger.js';
+export * from './kafka-logger.interface.js';
+export * from './kafka-message-context.js';
+export * from './topic-suffixes.js';

package/dist/esm/libs/index.js

@@ -0,0 +1,9 @@
+export * from './errors/index.js';
+export * from './consumer.abstract.js';
+export * from './heartbeat-file-writer.js';
+export * from './kafka-consumer-heartbeat.js';
+export * from './kafka-consumer-server.js';
+export * from './kafka-logger.js';
+export * from './kafka-logger.interface.js';
+export * from './kafka-message-context.js';
+export * from './topic-suffixes.js';

package/dist/esm/libs/kafka-consumer-heartbeat.d.ts

@@ -0,0 +1,3 @@
+import type { Consumer } from 'kafkajs';
+import type { HeartbeatFileWriter } from './heartbeat-file-writer.js';
+export declare const wireKafkaConsumerHeartbeat: (consumer: Consumer, heartbeat: HeartbeatFileWriter) => void;

package/dist/esm/libs/kafka-consumer-heartbeat.js

@@ -0,0 +1,9 @@
+export const wireKafkaConsumerHeartbeat = (consumer, heartbeat) => {
+    void heartbeat.touch();
+    consumer.on(consumer.events.HEARTBEAT, () => {
+        void heartbeat.touch();
+    });
+    consumer.on(consumer.events.GROUP_JOIN, () => {
+        void heartbeat.touch();
+    });
+};

package/dist/esm/libs/kafka-consumer-server.d.ts

@@ -0,0 +1,2 @@
+import type { DynamicModule, Type } from '@nestjs/common';
+export declare const kafkaConsumerServer: (module: DynamicModule | Type, loggerModule: Type) => Promise<void>;