@application-kit/kafka 0.0.0

package/dist/cjs/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/cjs/kafka-error-handler.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); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KafkaErrorHandler = void 0;
+const common_1 = require("@nestjs/common");
+const microservices_1 = require("@nestjs/microservices");
+const rxjs_1 = require("rxjs");
+const constants_js_1 = require("./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 common_1.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 (0, rxjs_1.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 (0, rxjs_1.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}`, '');
+    }
+};
+exports.KafkaErrorHandler = KafkaErrorHandler;
+exports.KafkaErrorHandler = KafkaErrorHandler = __decorate([
+    (0, common_1.Injectable)(),
+    __param(0, (0, common_1.Inject)(constants_js_1.KAFKA_PRODUCER)),
+    __param(1, (0, common_1.Inject)(constants_js_1.KAFKA_LOGGER)),
+    __param(2, (0, common_1.Inject)(constants_js_1.KAFKA_ERROR_HANDLER_OPTIONS)),
+    __metadata("design:paramtypes", [microservices_1.ClientKafka, Object, Object])
+], KafkaErrorHandler);

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

@@ -0,0 +1,67 @@
+"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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KafkaModule = void 0;
+const nestjs_config_module_1 = require("@libs-for-dev/nestjs-config-module");
+const common_1 = require("@nestjs/common");
+const microservices_1 = require("@nestjs/microservices");
+const kafka_config_environment_js_1 = require("./configs/envs/kafka-config.environment.js");
+const kafka_producer_config_js_1 = require("./configs/kafka-producer.config.js");
+const kafka_config_js_1 = require("./configs/kafka.config.js");
+const constants_js_1 = require("./constants.js");
+const kafka_commit_interceptor_js_1 = require("./kafka-commit-interceptor.js");
+const kafka_error_handler_js_1 = require("./kafka-error-handler.js");
+let KafkaModule = class KafkaModule {
+    static forRootAsync(config) {
+        return {
+            exports: [constants_js_1.KAFKA_LOGGER],
+            global: true,
+            module: this,
+            providers: [
+                {
+                    provide: constants_js_1.KAFKA_ERROR_HANDLER_OPTIONS,
+                    useValue: {
+                        baseDelayMs: 500,
+                        maxAttempts: 5,
+                        topicSuffix: {
+                            dlq: 'dlq',
+                            retry: 'retry',
+                        },
+                        ...config.errorHandlerOptions,
+                    },
+                },
+                {
+                    provide: constants_js_1.KAFKA_LOGGER,
+                    useClass: config.logger,
+                },
+            ],
+        };
+    }
+};
+exports.KafkaModule = KafkaModule;
+exports.KafkaModule = KafkaModule = __decorate([
+    (0, common_1.Module)({
+        exports: [kafka_commit_interceptor_js_1.KafkaCommitInterceptor, kafka_error_handler_js_1.KafkaErrorHandler],
+        imports: [
+            microservices_1.ClientsModule.registerAsync({
+                clients: [
+                    {
+                        imports: [nestjs_config_module_1.ConfigsModule.forFeature([kafka_producer_config_js_1.KafkaProducerConfig, kafka_config_js_1.KafkaConfig], [kafka_config_environment_js_1.KafkaConfigEnvironment])],
+                        inject: [kafka_producer_config_js_1.KafkaProducerConfig],
+                        name: constants_js_1.KAFKA_PRODUCER,
+                        useFactory: (config) => config.getOptions(),
+                    },
+                ],
+            }),
+        ],
+        providers: [
+            kafka_error_handler_js_1.KafkaErrorHandler,
+            kafka_commit_interceptor_js_1.KafkaCommitInterceptor,
+        ],
+    })
+], KafkaModule);

package/dist/cjs/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/cjs/libs/consumer.abstract.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConsumerAbstract = void 0;
+const consumers_error_js_1 = require("./errors/consumers-error.js");
+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 consumers_error_js_1.ConsumersError(rejectedResults.map((result) => result.reason));
+        }
+    }
+}
+exports.ConsumerAbstract = ConsumerAbstract;

package/dist/cjs/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/cjs/libs/errors/consumers-error.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConsumersError = void 0;
+class ConsumersError extends Error {
+    errors;
+    constructor(errors, options) {
+        super(errors.map((error) => `${error.name}: "${error.message}"`).join('; '), options);
+        this.errors = errors;
+        this.name = 'ConsumersError';
+    }
+}
+exports.ConsumersError = ConsumersError;

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

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

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

@@ -0,0 +1,17 @@
+"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("./consumers-error.js"), exports);

package/dist/cjs/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/cjs/libs/heartbeat-file-writer.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HeartbeatFileWriter = void 0;
+const promises_1 = require("node:fs/promises");
+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 (0, promises_1.writeFile)(this.filePath, String(Date.now()));
+        }
+        catch {
+        }
+    }
+}
+exports.HeartbeatFileWriter = HeartbeatFileWriter;

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

@@ -0,0 +1,25 @@
+"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("./errors/index.js"), exports);
+__exportStar(require("./consumer.abstract.js"), exports);
+__exportStar(require("./heartbeat-file-writer.js"), exports);
+__exportStar(require("./kafka-consumer-heartbeat.js"), exports);
+__exportStar(require("./kafka-consumer-server.js"), exports);
+__exportStar(require("./kafka-logger.js"), exports);
+__exportStar(require("./kafka-logger.interface.js"), exports);
+__exportStar(require("./kafka-message-context.js"), exports);
+__exportStar(require("./topic-suffixes.js"), exports);

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

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.wireKafkaConsumerHeartbeat = void 0;
+const wireKafkaConsumerHeartbeat = (consumer, heartbeat) => {
+    void heartbeat.touch();
+    consumer.on(consumer.events.HEARTBEAT, () => {
+        void heartbeat.touch();
+    });
+    consumer.on(consumer.events.GROUP_JOIN, () => {
+        void heartbeat.touch();
+    });
+};
+exports.wireKafkaConsumerHeartbeat = wireKafkaConsumerHeartbeat;

package/dist/cjs/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>;

package/dist/cjs/libs/kafka-consumer-server.js

@@ -0,0 +1,25 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.kafkaConsumerServer = void 0;
+const nestjs_config_module_1 = require("@libs-for-dev/nestjs-config-module");
+const core_1 = require("@nestjs/core");
+const node_process_1 = __importDefault(require("node:process"));
+const kafka_config_environment_js_1 = require("../configs/envs/kafka-config.environment.js");
+const kafka_consumer_environment_js_1 = require("../configs/envs/kafka-consumer.environment.js");
+const kafka_consumer_config_js_1 = require("../configs/kafka-consumer.config.js");
+const kafka_config_js_1 = require("../configs/kafka.config.js");
+const heartbeat_file_writer_js_1 = require("./heartbeat-file-writer.js");
+const kafka_consumer_heartbeat_js_1 = require("./kafka-consumer-heartbeat.js");
+const kafkaConsumerServer = async (module, loggerModule) => {
+    const kafkaConsumerConfig = new kafka_consumer_config_js_1.KafkaConsumerConfig(new kafka_config_js_1.KafkaConfig((0, nestjs_config_module_1.exposeObjectWithValidation)(node_process_1.default.env, kafka_config_environment_js_1.KafkaConfigEnvironment)), (0, nestjs_config_module_1.exposeObjectWithValidation)(node_process_1.default.env, kafka_consumer_environment_js_1.KafkaConsumerEnvironment));
+    const app = await core_1.NestFactory.createMicroservice(module, kafkaConsumerConfig.getOptions());
+    const logger = app.get(loggerModule);
+    app.useLogger(logger);
+    await app.listen();
+    const [, consumer] = app.unwrap();
+    (0, kafka_consumer_heartbeat_js_1.wireKafkaConsumerHeartbeat)(consumer, heartbeat_file_writer_js_1.HeartbeatFileWriter.fromEnvironment());
+};
+exports.kafkaConsumerServer = kafkaConsumerServer;

package/dist/cjs/libs/kafka-logger.d.ts

@@ -0,0 +1,5 @@
+import * as nestjsPino from 'nestjs-pino';
+import type { KafkaLoggerInterface } from './kafka-logger.interface.js';
+export declare class KafkaLogger extends nestjsPino.PinoLogger implements KafkaLoggerInterface {
+    constructor(options: nestjsPino.Params);
+}

package/dist/cjs/libs/kafka-logger.interface.d.ts

@@ -0,0 +1,5 @@
+export interface KafkaLoggerInterface {
+    error(context: unknown, message: string): void;
+    info(context: unknown, message: string): void;
+    warn(context: unknown, message: string): void;
+}

package/dist/cjs/libs/kafka-logger.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/libs/kafka-logger.js

@@ -0,0 +1,59 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+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 __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var KafkaLogger_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KafkaLogger = void 0;
+const common_1 = require("@nestjs/common");
+const nestjsPino = __importStar(require("nestjs-pino"));
+let KafkaLogger = KafkaLogger_1 = class KafkaLogger extends nestjsPino.PinoLogger {
+    constructor(options) {
+        super(options);
+        this.setContext(KafkaLogger_1.name);
+    }
+};
+exports.KafkaLogger = KafkaLogger;
+exports.KafkaLogger = KafkaLogger = KafkaLogger_1 = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [Object])
+], KafkaLogger);

package/dist/cjs/libs/kafka-message-context.d.ts

@@ -0,0 +1,6 @@
+export interface KafkaMessageContextInterface {
+    getMessage(): {
+        headers?: Record<string, unknown> | undefined;
+    };
+}
+export declare const eventIdOf: (context: KafkaMessageContextInterface) => null | string;

package/dist/cjs/libs/kafka-message-context.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.eventIdOf = void 0;
+const eventIdOf = (context) => {
+    const raw = context.getMessage().headers?.id;
+    if (Buffer.isBuffer(raw)) {
+        return raw.toString('utf8');
+    }
+    return typeof raw === 'string' && raw !== '' ? raw : null;
+};
+exports.eventIdOf = eventIdOf;

package/dist/cjs/libs/topic-suffixes.d.ts

@@ -0,0 +1 @@
+export declare const eventTopics: (queueName: string, version?: string) => string[];

package/dist/cjs/libs/topic-suffixes.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.eventTopics = void 0;
+const event_contract_version_js_1 = require("../event-contract-version.js");
+const RETRY_TOPIC_SUFFIX = 'retry';
+const eventTopics = (queueName, version = event_contract_version_js_1.DEFAULT_EVENT_VERSION) => {
+    const baseTopic = `events.${(0, event_contract_version_js_1.versionedQueueName)(queueName, version)}`;
+    return [baseTopic, `${baseTopic}.${RETRY_TOPIC_SUFFIX}`];
+};
+exports.eventTopics = eventTopics;

package/dist/cjs/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "commonjs"
+}

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

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

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

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

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

@@ -0,0 +1,60 @@
+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 { Expose } from 'class-transformer';
+import { IsEnum, IsOptional, IsString } from 'class-validator';
+var KafkaLogLevel;
+(function (KafkaLogLevel) {
+    KafkaLogLevel["DEBUG"] = "DEBUG";
+    KafkaLogLevel["ERROR"] = "ERROR";
+    KafkaLogLevel["INFO"] = "INFO";
+    KafkaLogLevel["NOTHING"] = "NOTHING";
+    KafkaLogLevel["WARN"] = "WARN";
+})(KafkaLogLevel || (KafkaLogLevel = {}));
+export class KafkaConfigEnvironment {
+    KAFKA_BROKERS;
+    KAFKA_CLIENT_ID;
+    KAFKA_LOG_LEVEL = KafkaLogLevel.INFO;
+    KAFKA_SASL_PASSWORD;
+    KAFKA_SASL_USERNAME;
+    KAFKA_SSL_CA_FILE;
+}
+__decorate([
+    Expose(),
+    IsString(),
+    __metadata("design:type", String)
+], KafkaConfigEnvironment.prototype, "KAFKA_BROKERS", void 0);
+__decorate([
+    Expose(),
+    IsString(),
+    __metadata("design:type", String)
+], KafkaConfigEnvironment.prototype, "KAFKA_CLIENT_ID", void 0);
+__decorate([
+    Expose(),
+    IsEnum(KafkaLogLevel),
+    __metadata("design:type", Object)
+], KafkaConfigEnvironment.prototype, "KAFKA_LOG_LEVEL", void 0);
+__decorate([
+    Expose(),
+    IsOptional(),
+    IsString(),
+    __metadata("design:type", String)
+], KafkaConfigEnvironment.prototype, "KAFKA_SASL_PASSWORD", void 0);
+__decorate([
+    Expose(),
+    IsOptional(),
+    IsString(),
+    __metadata("design:type", String)
+], KafkaConfigEnvironment.prototype, "KAFKA_SASL_USERNAME", void 0);
+__decorate([
+    Expose(),
+    IsOptional(),
+    IsString(),
+    __metadata("design:type", String)
+], KafkaConfigEnvironment.prototype, "KAFKA_SSL_CA_FILE", void 0);

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

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

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

@@ -0,0 +1,24 @@
+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 { Expose } from 'class-transformer';
+import { IsString } from 'class-validator';
+let KafkaConsumerEnvironment = class KafkaConsumerEnvironment {
+    KAFKA_GROUP_ID;
+};
+__decorate([
+    Expose(),
+    IsString(),
+    __metadata("design:type", String)
+], KafkaConsumerEnvironment.prototype, "KAFKA_GROUP_ID", void 0);
+KafkaConsumerEnvironment = __decorate([
+    Injectable()
+], KafkaConsumerEnvironment);
+export { KafkaConsumerEnvironment };

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

@@ -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';