@application-kit/kafka 0.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 application-kit
+
+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,95 @@
+# @application-kit/kafka
+
+Kafka-транспорт для NestJS: бутстрап консьюмер-процесса с heartbeat-файлом, труба потребления
+(ручной commit offset'а, retry и DLQ), имена топиков и контракт версии события, общий для
+производителя (outbox + Debezium EventRouter) и потребителя.
+
+## Установка
+
+```sh
+yarn add @application-kit/kafka
+```
+
+Peer-зависимости: `@nestjs/common`, `@nestjs/core`, `@nestjs/microservices`, `kafkajs`, `rxjs`,
+`@libs-for-dev/nestjs-config-module`, `class-transformer`, `class-validator`, `nestjs-pino`.
+
+Пакет грузится одним экземпляром на процесс: DI-токены — `Symbol()`, и ESM- и CJS-копии разом
+дали бы два набора токенов.
+
+## Окружение
+
+| Переменная | Назначение |
+|---|---|
+| `KAFKA_BROKERS` | список брокеров через запятую |
+| `KAFKA_CLIENT_ID` | префикс `clientId` (к нему добавляется uuid процесса) |
+| `KAFKA_GROUP_ID` | группа консьюмера — нужна только консьюмер-процессу |
+| `KAFKA_LOG_LEVEL` | уровень kafkajs: `NOTHING`, `ERROR`, `WARN`, `INFO` (дефолт), `DEBUG` |
+| `KAFKA_SASL_USERNAME`, `KAFKA_SASL_PASSWORD` | SCRAM-SHA-512; не заданы — без аутентификации |
+| `KAFKA_SSL_CA_FILE` | путь к CA брокера; не задан — без TLS |
+| `HEARTBEAT_FILE` | файл пульса для exec-liveness; не задан — пульс не пишется |
+
+Переменные валидируются при старте: с неверным окружением процесс не поднимается.
+
+## Консьюмер-процесс
+
+```ts
+import { KafkaLogger, KafkaModule, kafkaConsumerServer } from '@application-kit/kafka'
+import { Module } from '@nestjs/common'
+import { Logger } from 'nestjs-pino'
+
+@Module({
+  imports: [
+    // logger — класс, а не экземпляр: экземпляр, созданный на импорте файла, забрал бы себе
+    // корневой логгер nestjs-pino с дефолтными опциями.
+    KafkaModule.forRootAsync({ logger: KafkaLogger }),
+    // …модули с консьюмерами
+  ],
+})
+class ConsumerModule {}
+
+void kafkaConsumerServer(ConsumerModule, Logger)
+```
+
+`kafkaConsumerServer` поднимает Nest-микросервис и обновляет `HEARTBEAT_FILE` на событиях kafkajs
+`HEARTBEAT` и `GROUP_JOIN`: зависшая группа перестаёт слать пульс, файл протухает, и
+оркестратор перезапускает процесс по `mtime`.
+
+`forRootAsync` принимает `errorHandlerOptions` — `maxAttempts` (5), `baseDelayMs` (500) и
+`topicSuffix` (`retry`, `dlq`). `KafkaLogger` — реализация `KafkaLoggerInterface` на `nestjs-pino`;
+свой логгер — любой класс с `error`, `info`, `warn`.
+
+## Консьюмер
+
+```ts
+import {
+  ConsumerAbstract,
+  eventIdOf,
+  eventTopics,
+  KafkaAutoCommit,
+  type KafkaMessageContextInterface,
+} from '@application-kit/kafka'
+
+@Controller()
+export class UserConsumer extends ConsumerAbstract {
+  @EventPattern(eventTopics(UserWasCreatedEvent.queueName))
+  @KafkaAutoCommit()
+  public async created(@Payload() payload: UserDto, @Ctx() context: KafkaMessageContextInterface) {
+    await this.handleAll(payload, [this.welcomeLetter, this.audit])
+  }
+}
+```
+
+- `eventTopics(queue, version?)` — пара топиков очереди: `events.<queue>` и его `.retry`.
+- `@KafkaAutoCommit()` коммитит offset после успешной обработки; упавшее сообщение уходит в
+  retry-топик с растущей задержкой, после `maxAttempts` — в DLQ.
+- `ConsumerAbstract.handleAll` запускает обработчики (`HandlerInterface<TPayload>`) параллельно;
+  отказ любого — `ConsumersError`, сообщение переигрывается целиком.
+- `eventIdOf(context)` — идентификатор события из заголовка `id` (его ставит Debezium EventRouter).
+
+## Версия контракта события
+
+Несовместимая смена контракта уводит события в свою очередь `<queue>.v<N>`; первая версия живёт
+в топике без сегмента. Производитель собирает имя очереди `versionedQueueName(queue, version)`,
+потребитель подписывается `eventTopics(queue, version)`, а труба сверяет версию топика
+(`eventVersionOfTopic`) с заголовком `x-event-version` (`eventVersionOfHeaders`) до вызова
+обработчика: сообщение чужой версии уходит в DLQ, не доходя до кода потребителя.

package/dist/cjs/configs/envs/index.d.ts

@@ -0,0 +1,2 @@
+export * from './kafka-config.environment.js';
+export * from './kafka-consumer.environment.js';

package/dist/cjs/configs/envs/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./kafka-config.environment.js"), exports);
+__exportStar(require("./kafka-consumer.environment.js"), exports);

package/dist/cjs/configs/envs/kafka-config.environment.d.ts

@@ -0,0 +1,9 @@
+import { logLevel } from '@nestjs/microservices/external/kafka.interface.js';
+export declare class KafkaConfigEnvironment {
+    KAFKA_BROKERS: string;
+    KAFKA_CLIENT_ID: string;
+    KAFKA_LOG_LEVEL: keyof typeof logLevel;
+    KAFKA_SASL_PASSWORD?: string;
+    KAFKA_SASL_USERNAME?: string;
+    KAFKA_SSL_CA_FILE?: string;
+}

package/dist/cjs/configs/envs/kafka-config.environment.js

@@ -0,0 +1,64 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KafkaConfigEnvironment = void 0;
+const class_transformer_1 = require("class-transformer");
+const class_validator_1 = require("class-validator");
+var KafkaLogLevel;
+(function (KafkaLogLevel) {
+    KafkaLogLevel["DEBUG"] = "DEBUG";
+    KafkaLogLevel["ERROR"] = "ERROR";
+    KafkaLogLevel["INFO"] = "INFO";
+    KafkaLogLevel["NOTHING"] = "NOTHING";
+    KafkaLogLevel["WARN"] = "WARN";
+})(KafkaLogLevel || (KafkaLogLevel = {}));
+class KafkaConfigEnvironment {
+    KAFKA_BROKERS;
+    KAFKA_CLIENT_ID;
+    KAFKA_LOG_LEVEL = KafkaLogLevel.INFO;
+    KAFKA_SASL_PASSWORD;
+    KAFKA_SASL_USERNAME;
+    KAFKA_SSL_CA_FILE;
+}
+exports.KafkaConfigEnvironment = KafkaConfigEnvironment;
+__decorate([
+    (0, class_transformer_1.Expose)(),
+    (0, class_validator_1.IsString)(),
+    __metadata("design:type", String)
+], KafkaConfigEnvironment.prototype, "KAFKA_BROKERS", void 0);
+__decorate([
+    (0, class_transformer_1.Expose)(),
+    (0, class_validator_1.IsString)(),
+    __metadata("design:type", String)
+], KafkaConfigEnvironment.prototype, "KAFKA_CLIENT_ID", void 0);
+__decorate([
+    (0, class_transformer_1.Expose)(),
+    (0, class_validator_1.IsEnum)(KafkaLogLevel),
+    __metadata("design:type", Object)
+], KafkaConfigEnvironment.prototype, "KAFKA_LOG_LEVEL", void 0);
+__decorate([
+    (0, class_transformer_1.Expose)(),
+    (0, class_validator_1.IsOptional)(),
+    (0, class_validator_1.IsString)(),
+    __metadata("design:type", String)
+], KafkaConfigEnvironment.prototype, "KAFKA_SASL_PASSWORD", void 0);
+__decorate([
+    (0, class_transformer_1.Expose)(),
+    (0, class_validator_1.IsOptional)(),
+    (0, class_validator_1.IsString)(),
+    __metadata("design:type", String)
+], KafkaConfigEnvironment.prototype, "KAFKA_SASL_USERNAME", void 0);
+__decorate([
+    (0, class_transformer_1.Expose)(),
+    (0, class_validator_1.IsOptional)(),
+    (0, class_validator_1.IsString)(),
+    __metadata("design:type", String)
+], KafkaConfigEnvironment.prototype, "KAFKA_SSL_CA_FILE", void 0);

package/dist/cjs/configs/envs/kafka-consumer.environment.d.ts

@@ -0,0 +1,3 @@
+export declare class KafkaConsumerEnvironment {
+    KAFKA_GROUP_ID: string;
+}

package/dist/cjs/configs/envs/kafka-consumer.environment.js

@@ -0,0 +1,27 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KafkaConsumerEnvironment = void 0;
+const common_1 = require("@nestjs/common");
+const class_transformer_1 = require("class-transformer");
+const class_validator_1 = require("class-validator");
+let KafkaConsumerEnvironment = class KafkaConsumerEnvironment {
+    KAFKA_GROUP_ID;
+};
+exports.KafkaConsumerEnvironment = KafkaConsumerEnvironment;
+__decorate([
+    (0, class_transformer_1.Expose)(),
+    (0, class_validator_1.IsString)(),
+    __metadata("design:type", String)
+], KafkaConsumerEnvironment.prototype, "KAFKA_GROUP_ID", void 0);
+exports.KafkaConsumerEnvironment = KafkaConsumerEnvironment = __decorate([
+    (0, common_1.Injectable)()
+], KafkaConsumerEnvironment);

package/dist/cjs/configs/index.d.ts

@@ -0,0 +1,4 @@
+export * from './envs/index.js';
+export * from './kafka-consumer.config.js';
+export * from './kafka-producer.config.js';
+export * from './kafka.config.js';

package/dist/cjs/configs/index.js

@@ -0,0 +1,20 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./envs/index.js"), exports);
+__exportStar(require("./kafka-consumer.config.js"), exports);
+__exportStar(require("./kafka-producer.config.js"), exports);
+__exportStar(require("./kafka.config.js"), exports);

package/dist/cjs/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/cjs/configs/kafka-consumer.config.js

@@ -0,0 +1,50 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KafkaConsumerConfig = void 0;
+const common_1 = require("@nestjs/common");
+const kafka_consumer_environment_js_1 = require("./envs/kafka-consumer.environment.js");
+const kafka_config_js_1 = require("./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;
+    }
+};
+exports.KafkaConsumerConfig = KafkaConsumerConfig;
+exports.KafkaConsumerConfig = KafkaConsumerConfig = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [kafka_config_js_1.KafkaConfig,
+        kafka_consumer_environment_js_1.KafkaConsumerEnvironment])
+], KafkaConsumerConfig);

package/dist/cjs/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/cjs/configs/kafka-producer.config.js

@@ -0,0 +1,41 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KafkaProducerConfig = void 0;
+const common_1 = require("@nestjs/common");
+const kafkajs_1 = require("kafkajs");
+const kafka_config_js_1 = require("./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: kafkajs_1.Partitioners.DefaultPartitioner,
+                retry: {
+                    retries: 1,
+                },
+            },
+            producerOnlyMode: true,
+        };
+        return options;
+    }
+};
+exports.KafkaProducerConfig = KafkaProducerConfig;
+exports.KafkaProducerConfig = KafkaProducerConfig = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [kafka_config_js_1.KafkaConfig])
+], KafkaProducerConfig);

package/dist/cjs/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/cjs/configs/kafka.config.js

@@ -0,0 +1,52 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KafkaConfig = void 0;
+const common_1 = require("@nestjs/common");
+const microservices_1 = require("@nestjs/microservices");
+const kafka_interface_js_1 = require("@nestjs/microservices/external/kafka.interface.js");
+const node_crypto_1 = require("node:crypto");
+const node_fs_1 = require("node:fs");
+const kafka_config_environment_js_1 = require("./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: [(0, node_fs_1.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}-${(0, node_crypto_1.randomUUID)()}`,
+                    logLevel: kafka_interface_js_1.logLevel[KAFKA_LOG_LEVEL],
+                    ...(ssl !== undefined && { ssl }),
+                    ...(sasl !== undefined && { sasl }),
+                },
+                postfixId: '',
+            },
+            transport: microservices_1.Transport.KAFKA,
+        };
+    }
+};
+exports.KafkaConfig = KafkaConfig;
+exports.KafkaConfig = KafkaConfig = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [kafka_config_environment_js_1.KafkaConfigEnvironment])
+], KafkaConfig);

package/dist/cjs/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/cjs/constants.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KAFKA_ERROR_HANDLER_OPTIONS = exports.KAFKA_LOGGER = exports.KAFKA_PRODUCER = void 0;
+exports.KAFKA_PRODUCER = Symbol('KAFKA_PRODUCER');
+exports.KAFKA_LOGGER = Symbol('KAFKA_LOGGER');
+exports.KAFKA_ERROR_HANDLER_OPTIONS = Symbol('KAFKA_ERROR_HANDLER_OPTIONS');

package/dist/cjs/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/cjs/event-contract-version.js

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

package/dist/cjs/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/cjs/index.js

@@ -0,0 +1,23 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./configs/index.js"), exports);
+__exportStar(require("./libs/index.js"), exports);
+__exportStar(require("./constants.js"), exports);
+__exportStar(require("./event-contract-version.js"), exports);
+__exportStar(require("./kafka-commit-interceptor.js"), exports);
+__exportStar(require("./kafka-error-handler.js"), exports);
+__exportStar(require("./kafka.module.js"), exports);

package/dist/cjs/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/cjs/kafka-commit-interceptor.js

@@ -0,0 +1,87 @@
+"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); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KafkaAutoCommit = exports.KafkaCommitInterceptor = void 0;
+const common_1 = require("@nestjs/common");
+const rxjs_1 = require("rxjs");
+const constants_js_1 = require("./constants.js");
+const event_contract_version_js_1 = require("./event-contract-version.js");
+const kafka_error_handler_js_1 = require("./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((0, rxjs_1.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'}`);
+            }
+        }), (0, rxjs_1.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 (0, rxjs_1.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 = (0, event_contract_version_js_1.eventVersionOfTopic)(topic);
+        const messageVersion = (0, event_contract_version_js_1.eventVersionOfHeaders)(kafkaContext.getMessage().headers);
+        return messageVersion === expectedVersion
+            ? undefined
+            : (0, rxjs_1.throwError)(() => new common_1.BadRequestException(`Unsupported event contract version "${messageVersion}" on topic "${topic}": expected "${expectedVersion}"`));
+    }
+};
+exports.KafkaCommitInterceptor = KafkaCommitInterceptor;
+exports.KafkaCommitInterceptor = KafkaCommitInterceptor = __decorate([
+    (0, common_1.Injectable)(),
+    __param(1, (0, common_1.Inject)(constants_js_1.KAFKA_LOGGER)),
+    __metadata("design:paramtypes", [kafka_error_handler_js_1.KafkaErrorHandler, Object])
+], KafkaCommitInterceptor);
+const KafkaAutoCommit = () => (0, common_1.applyDecorators)((0, common_1.UseInterceptors)(KafkaCommitInterceptor));
+exports.KafkaAutoCommit = KafkaAutoCommit;