@loipv/nestjs-kafka 0.0.1

package/README.md

@@ -0,0 +1,377 @@
+# @loipv/nestjs-kafka
+
+A production-ready NestJS module for Kafka client and consumer functionality built on top of [KafkaJS](https://kafka.js.org/). This library provides enterprise-grade features including intelligent batch processing, idempotency guarantees, key-based grouping, and automatic pressure management.
+
+## Features
+
+- **Producer (KafkaClient)**: High-performance Kafka producer with `send()`, `sendBatch()`, `sendQueued()` methods
+- **Consumer**: Method decorator-based consumer with auto-discovery
+- **Batch Processing**: Intelligent batching with configurable size and timeout
+- **Key-Based Grouping**: Group messages by key within batches for ordered processing
+- **Back Pressure**: Automatic pause/resume when consumers are overwhelmed
+- **Idempotency**: In-memory duplicate prevention with TTL
+- **Dead Letter Queue (DLQ)**: Automatic retry with exponential backoff
+- **Health Checks**: Integration with `@nestjs/terminus`
+- **Graceful Shutdown**: Proper cleanup on application shutdown
+
+## Installation
+
+```bash
+npm install @loipv/nestjs-kafka kafkajs
+```
+
+### Peer Dependencies
+
+Make sure you have the following peer dependencies installed:
+
+```bash
+npm install @nestjs/common @nestjs/core @nestjs/terminus reflect-metadata rxjs
+```
+
+## Quick Start
+
+### 1. Import KafkaModule
+
+```typescript
+import { Module } from '@nestjs/common';
+import { KafkaModule, ConsumerModule } from '@loipv/nestjs-kafka';
+import { OrderConsumer } from './order.consumer';
+
+@Module({
+  imports: [
+    KafkaModule.forRoot({
+      clientId: 'my-app',
+      brokers: ['localhost:9092'],
+    }),
+    ConsumerModule,
+  ],
+  providers: [OrderConsumer],
+})
+export class AppModule {}
+```
+
+### 2. Create a Consumer
+
+```typescript
+import { Injectable } from '@nestjs/common';
+import { Consumer } from '@loipv/nestjs-kafka';
+import { KafkaMessage } from 'kafkajs';
+
+@Injectable()
+export class OrderConsumer {
+  @Consumer('orders')
+  async handleOrder(message: KafkaMessage) {
+    const order = JSON.parse(message.value.toString());
+    console.log('Processing order:', order);
+  }
+}
+```
+
+### 3. Use the Producer
+
+```typescript
+import { Injectable } from '@nestjs/common';
+import { KafkaClient } from '@loipv/nestjs-kafka';
+
+@Injectable()
+export class OrderService {
+  constructor(private readonly kafka: KafkaClient) {}
+
+  async createOrder(order: Order) {
+    await this.kafka.send('orders', {
+      key: order.customerId,
+      value: order, // Automatically serialized to JSON
+    });
+  }
+}
+```
+
+## Configuration
+
+### KafkaModule Options
+
+```typescript
+KafkaModule.forRoot({
+  // Required
+  clientId: 'my-app',
+  brokers: ['localhost:9092'],
+
+  // Optional - SSL/SASL
+  ssl: true,
+  sasl: {
+    mechanism: 'scram-sha-256',
+    username: process.env.KAFKA_USERNAME,
+    password: process.env.KAFKA_PASSWORD,
+  },
+
+  // Optional - Connection settings
+  connectionTimeout: 3000,
+  requestTimeout: 30000,
+
+  // Optional - Retry configuration
+  retry: {
+    initialRetryTime: 100,
+    retries: 8,
+    maxRetryTime: 30000,
+  },
+
+  // Optional - Logging
+  logLevel: 'INFO', // 'NOTHING' | 'ERROR' | 'WARN' | 'INFO' | 'DEBUG'
+});
+```
+
+### Async Configuration
+
+```typescript
+KafkaModule.forRootAsync({
+  imports: [ConfigModule],
+  useFactory: (config: ConfigService) => ({
+    clientId: config.get('KAFKA_CLIENT_ID'),
+    brokers: config.get('KAFKA_BROKERS').split(','),
+  }),
+  inject: [ConfigService],
+});
+```
+
+## Consumer Options
+
+### Basic Consumer
+
+```typescript
+@Consumer('topic-name')
+async handleMessage(message: KafkaMessage) {
+  // Process single message
+}
+```
+
+### Batch Consumer
+
+```typescript
+@Consumer('orders', {
+  batch: true,
+  batchSize: 100,        // Max messages per batch (default: 100)
+  batchTimeout: 5000,    // Max wait time in ms (default: 5000)
+})
+async handleBatch(messages: KafkaMessage[]) {
+  // Process batch of messages
+}
+```
+
+### Batch with Key Grouping
+
+```typescript
+@Consumer('orders', {
+  batch: true,
+  batchSize: 100,
+  groupByKey: true,  // Group messages by key within batch
+})
+async handleBatch(groupedMessages: GroupedBatch[]) {
+  // groupedMessages = [{ key: 'customer-1', messages: [...] }, ...]
+  for (const group of groupedMessages) {
+    console.log(`Processing ${group.messages.length} orders for ${group.key}`);
+  }
+}
+```
+
+### Consumer with DLQ
+
+```typescript
+@Consumer('payments', {
+  dlq: {
+    topic: 'payments-dlq',
+    maxRetries: 3,           // Retry 3 times before DLQ
+    retryDelay: 1000,        // Initial delay: 1 second
+    retryBackoffMultiplier: 2, // Exponential backoff
+    includeErrorInfo: true,  // Include error in DLQ headers
+  },
+})
+async handlePayment(message: KafkaMessage) {
+  // If this throws, message will be retried then sent to DLQ
+}
+```
+
+### Consumer with Idempotency
+
+```typescript
+@Consumer('events', {
+  idempotencyKey: (msg) => msg.headers?.['event-id']?.toString(),
+  idempotencyTtl: 3600000, // 1 hour
+})
+async handleEvent(message: KafkaMessage) {
+  // Duplicate messages (same event-id) will be skipped
+}
+```
+
+### Consumer with Back Pressure
+
+```typescript
+@Consumer('high-volume', {
+  batch: true,
+  backPressureThreshold: 80, // Pause at 80% capacity
+  maxQueueSize: 1000,
+})
+async handleHighVolume(messages: KafkaMessage[]) {
+  // Consumer will auto-pause when overwhelmed
+}
+```
+
+### Disabled Consumer
+
+```typescript
+@Consumer('orders', {
+  disabled: true, // Consumer will be skipped during registration
+})
+async handleOrder(message: KafkaMessage) {
+  // This handler will not be registered
+}
+```
+
+Use this to temporarily disable a consumer without removing the code.
+
+### All Consumer Options
+
+```typescript
+interface ConsumerOptions {
+  // Enable/disable consumer
+  disabled?: boolean;            // Default: false (skip registration when true)
+
+  // Consumer group settings
+  groupId?: string;
+  sessionTimeout?: number;      // Default: 30000
+  heartbeatInterval?: number;   // Default: 3000
+  rebalanceTimeout?: number;
+
+  // Batch processing
+  batch?: boolean;
+  batchSize?: number;           // Default: 100
+  batchTimeout?: number;        // Default: 5000
+  groupByKey?: boolean;
+
+  // Pressure management
+  backPressureThreshold?: number; // Default: 80
+  maxQueueSize?: number;          // Default: 1000
+
+  // Idempotency
+  idempotencyKey?: (message: KafkaMessage) => string | undefined;
+  idempotencyTtl?: number;        // Default: 3600000 (1 hour)
+
+  // Dead Letter Queue
+  dlq?: {
+    topic: string;
+    maxRetries?: number;          // Default: 3
+    retryDelay?: number;          // Default: 1000
+    retryBackoffMultiplier?: number; // Default: 2
+  };
+
+  // Commit settings
+  autoCommit?: boolean;           // Default: true
+  autoCommitInterval?: number;
+  fromBeginning?: boolean;        // Default: false
+}
+```
+
+## Producer API
+
+### KafkaClient Methods
+
+```typescript
+// Send single message
+await kafka.send('topic', {
+  key: 'message-key',
+  value: { data: 'value' }, // Auto-serialized
+  headers: { 'correlation-id': '123' },
+});
+
+// Send batch to single topic
+await kafka.sendBatch('topic', [
+  { key: 'key1', value: 'value1' },
+  { key: 'key2', value: 'value2' },
+]);
+
+// Send to multiple topics
+await kafka.sendMultiTopicBatch([
+  { topic: 'topic1', messages: [{ value: 'msg1' }] },
+  { topic: 'topic2', messages: [{ value: 'msg2' }] },
+]);
+
+// Queue message for auto-batching
+await kafka.sendQueued('topic', { value: 'message' });
+```
+
+### Send Options
+
+```typescript
+await kafka.send('topic', message, {
+  acks: -1,        // -1 (all), 0 (none), 1 (leader only)
+  timeout: 30000,
+  compression: 1,  // 0=None, 1=GZIP, 2=Snappy, 3=LZ4, 4=ZSTD
+});
+```
+
+## Health Checks
+
+Integrate with `@nestjs/terminus`:
+
+```typescript
+import { Controller, Get } from '@nestjs/common';
+import { HealthCheck, HealthCheckService } from '@nestjs/terminus';
+import { KafkaHealthIndicator } from '@loipv/nestjs-kafka';
+
+@Controller('health')
+export class HealthController {
+  constructor(
+    private health: HealthCheckService,
+    private kafkaHealth: KafkaHealthIndicator,
+  ) {}
+
+  @Get()
+  @HealthCheck()
+  check() {
+    return this.health.check([
+      () => this.kafkaHealth.isHealthy('kafka'),
+    ]);
+  }
+
+  @Get('kafka/brokers')
+  @HealthCheck()
+  checkBrokers() {
+    return this.health.check([
+      () => this.kafkaHealth.checkBrokers('kafka-brokers'),
+    ]);
+  }
+}
+```
+
+## API Reference
+
+### Exports
+
+```typescript
+// Modules
+export { KafkaModule } from './kafka.module';
+export { ConsumerModule } from './consumer.module';
+
+// Decorators
+export { Consumer } from './decorators';
+
+// Services
+export { KafkaClient } from './services/kafka-client.service';
+
+// Health
+export { KafkaHealthIndicator } from './health/kafka-health-indicator';
+
+// Interfaces
+export {
+  KafkaModuleOptions,
+  KafkaModuleAsyncOptions,
+  ConsumerOptions,
+  DlqOptions,
+  ProducerMessage,
+  SendOptions,
+  GroupedBatch,
+} from './interfaces';
+```
+
+## License
+
+MIT

package/dist/consumer.module.d.ts

@@ -0,0 +1,10 @@
+import { OnModuleInit, OnApplicationShutdown } from '@nestjs/common';
+import { ConsumerDiscoveryService } from './discovery/consumer-discovery.service';
+import { ConsumerRegistryService } from './services/consumer-registry.service';
+export declare class ConsumerModule implements OnModuleInit, OnApplicationShutdown {
+    private readonly discoveryService;
+    private readonly registryService;
+    constructor(discoveryService: ConsumerDiscoveryService, registryService: ConsumerRegistryService);
+    onModuleInit(): Promise<void>;
+    onApplicationShutdown(): Promise<void>;
+}

package/dist/consumer.module.js

@@ -0,0 +1,38 @@
+"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.ConsumerModule = void 0;
+const common_1 = require("@nestjs/common");
+const consumer_discovery_service_1 = require("./discovery/consumer-discovery.service");
+const consumer_registry_service_1 = require("./services/consumer-registry.service");
+let ConsumerModule = class ConsumerModule {
+    discoveryService;
+    registryService;
+    constructor(discoveryService, registryService) {
+        this.discoveryService = discoveryService;
+        this.registryService = registryService;
+    }
+    async onModuleInit() {
+        const consumers = this.discoveryService.discoverConsumers();
+        this.registryService.registerConsumers(consumers);
+        await this.registryService.startAll();
+    }
+    async onApplicationShutdown() {
+        await this.registryService.gracefulShutdown();
+    }
+};
+exports.ConsumerModule = ConsumerModule;
+exports.ConsumerModule = ConsumerModule = __decorate([
+    (0, common_1.Module)({}),
+    __metadata("design:paramtypes", [consumer_discovery_service_1.ConsumerDiscoveryService,
+        consumer_registry_service_1.ConsumerRegistryService])
+], ConsumerModule);
+//# sourceMappingURL=consumer.module.js.map

package/dist/consumer.module.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"consumer.module.js","sourceRoot":"","sources":["../lib/consumer.module.ts"],"names":[],"mappings":";;;;;;;;;;;;AAAA,2CAA6E;AAC7E,uFAAkF;AAClF,oFAA+E;AAGxE,IAAM,cAAc,GAApB,MAAM,cAAc;IAEN;IACA;IAFnB,YACmB,gBAA0C,EAC1C,eAAwC;QADxC,qBAAgB,GAAhB,gBAAgB,CAA0B;QAC1C,oBAAe,GAAf,eAAe,CAAyB;IACxD,CAAC;IAEJ,KAAK,CAAC,YAAY;QAChB,MAAM,SAAS,GAAG,IAAI,CAAC,gBAAgB,CAAC,iBAAiB,EAAE,CAAC;QAE5D,IAAI,CAAC,eAAe,CAAC,iBAAiB,CAAC,SAAS,CAAC,CAAC;QAClD,MAAM,IAAI,CAAC,eAAe,CAAC,QAAQ,EAAE,CAAC;IACxC,CAAC;IAED,KAAK,CAAC,qBAAqB;QACzB,MAAM,IAAI,CAAC,eAAe,CAAC,gBAAgB,EAAE,CAAC;IAChD,CAAC;CACF,CAAA;AAhBY,wCAAc;yBAAd,cAAc;IAD1B,IAAA,eAAM,EAAC,EAAE,CAAC;qCAG4B,qDAAwB;QACzB,mDAAuB;GAHhD,cAAc,CAgB1B"}

package/dist/decorators/constants.d.ts

@@ -0,0 +1 @@
+export declare const KAFKA_CONSUMER_METADATA: unique symbol;

package/dist/decorators/constants.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KAFKA_CONSUMER_METADATA = void 0;
+exports.KAFKA_CONSUMER_METADATA = Symbol('KAFKA_CONSUMER_METADATA');
+//# sourceMappingURL=constants.js.map

package/dist/decorators/constants.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.js","sourceRoot":"","sources":["../../lib/decorators/constants.ts"],"names":[],"mappings":";;;AAAa,QAAA,uBAAuB,GAAG,MAAM,CAAC,yBAAyB,CAAC,CAAC"}

package/dist/decorators/consumer.decorator.d.ts

@@ -0,0 +1,8 @@
+import { ConsumerOptions } from '../interfaces';
+export interface ConsumerMethodMetadata {
+    topic: string;
+    options: Partial<ConsumerOptions>;
+}
+export declare function Consumer(topic: string, options?: Partial<ConsumerOptions>): MethodDecorator;
+export type MessageHandler<T = any> = (message: T) => Promise<void>;
+export type BatchHandler<T = any> = (messages: T[]) => Promise<void>;

package/dist/decorators/consumer.decorator.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Consumer = Consumer;
+const common_1 = require("@nestjs/common");
+const constants_1 = require("./constants");
+function Consumer(topic, options) {
+    return (target, propertyKey, descriptor) => {
+        const metadata = {
+            topic,
+            options: options || {},
+        };
+        (0, common_1.SetMetadata)(constants_1.KAFKA_CONSUMER_METADATA, metadata)(target, propertyKey, descriptor);
+        return descriptor;
+    };
+}
+//# sourceMappingURL=consumer.decorator.js.map

package/dist/decorators/consumer.decorator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"consumer.decorator.js","sourceRoot":"","sources":["../../lib/decorators/consumer.decorator.ts"],"names":[],"mappings":";;AASA,4BAsBC;AA/BD,2CAA6C;AAE7C,2CAAsD;AAOtD,SAAgB,QAAQ,CACtB,KAAa,EACb,OAAkC;IAElC,OAAO,CACL,MAAc,EACd,WAA4B,EAC5B,UAA8B,EAC9B,EAAE;QACF,MAAM,QAAQ,GAA2B;YACvC,KAAK;YACL,OAAO,EAAE,OAAO,IAAI,EAAE;SACvB,CAAC;QAEF,IAAA,oBAAW,EAAC,mCAAuB,EAAE,QAAQ,CAAC,CAC5C,MAAM,EACN,WAAW,EACX,UAAU,CACX,CAAC;QAEF,OAAO,UAAU,CAAC;IACpB,CAAC,CAAC;AACJ,CAAC"}

package/dist/decorators/index.d.ts

@@ -0,0 +1,2 @@
+export * from './constants';
+export { Consumer, ConsumerMethodMetadata } from './consumer.decorator';

package/dist/decorators/index.js

@@ -0,0 +1,21 @@
+"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 });
+exports.Consumer = void 0;
+__exportStar(require("./constants"), exports);
+var consumer_decorator_1 = require("./consumer.decorator");
+Object.defineProperty(exports, "Consumer", { enumerable: true, get: function () { return consumer_decorator_1.Consumer; } });
+//# sourceMappingURL=index.js.map

package/dist/decorators/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../lib/decorators/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;AAAA,8CAA4B;AAC5B,2DAAwE;AAA/D,8GAAA,QAAQ,OAAA"}

package/dist/discovery/consumer-discovery.service.d.ts

@@ -0,0 +1,14 @@
+import { OnModuleInit } from '@nestjs/common';
+import { DiscoveryService, MetadataScanner, Reflector } from '@nestjs/core';
+import { ConsumerMetadata } from '../interfaces';
+export declare class ConsumerDiscoveryService implements OnModuleInit {
+    private readonly discoveryService;
+    private readonly reflector;
+    private readonly metadataScanner;
+    private readonly logger;
+    private discoveredConsumers;
+    constructor(discoveryService: DiscoveryService, reflector: Reflector, metadataScanner: MetadataScanner);
+    onModuleInit(): void;
+    discoverConsumers(): ConsumerMetadata[];
+    getConsumers(): ConsumerMetadata[];
+}

package/dist/discovery/consumer-discovery.service.js

@@ -0,0 +1,82 @@
+"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 ConsumerDiscoveryService_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConsumerDiscoveryService = void 0;
+const common_1 = require("@nestjs/common");
+const core_1 = require("@nestjs/core");
+const constants_1 = require("../decorators/constants");
+let ConsumerDiscoveryService = ConsumerDiscoveryService_1 = class ConsumerDiscoveryService {
+    discoveryService;
+    reflector;
+    metadataScanner;
+    logger = new common_1.Logger(ConsumerDiscoveryService_1.name);
+    discoveredConsumers = [];
+    constructor(discoveryService, reflector, metadataScanner) {
+        this.discoveryService = discoveryService;
+        this.reflector = reflector;
+        this.metadataScanner = metadataScanner;
+    }
+    onModuleInit() {
+        this.discoverConsumers();
+    }
+    discoverConsumers() {
+        if (this.discoveredConsumers.length > 0) {
+            return this.discoveredConsumers;
+        }
+        const providers = this.discoveryService.getProviders();
+        for (const wrapper of providers) {
+            const { instance, metatype } = wrapper;
+            if (!instance || !metatype) {
+                continue;
+            }
+            const prototype = Object.getPrototypeOf(instance);
+            const methodNames = this.metadataScanner.getAllMethodNames(prototype);
+            for (const methodName of methodNames) {
+                const methodRef = prototype[methodName];
+                if (typeof methodRef !== 'function') {
+                    continue;
+                }
+                const metadata = this.reflector.get(constants_1.KAFKA_CONSUMER_METADATA, methodRef);
+                if (!metadata) {
+                    continue;
+                }
+                if (metadata.options.disabled) {
+                    this.logger.log(`Skipping disabled consumer: ${metatype.name}.${methodName} for topic: ${metadata.topic}`);
+                    continue;
+                }
+                const consumerMetadata = {
+                    topic: metadata.topic,
+                    options: {
+                        ...metadata.options,
+                        topic: metadata.topic,
+                    },
+                    target: instance,
+                    methodName,
+                };
+                this.discoveredConsumers.push(consumerMetadata);
+                this.logger.log(`Discovered consumer: ${metatype.name}.${methodName} for topic: ${metadata.topic}`);
+            }
+        }
+        return this.discoveredConsumers;
+    }
+    getConsumers() {
+        return this.discoveredConsumers;
+    }
+};
+exports.ConsumerDiscoveryService = ConsumerDiscoveryService;
+exports.ConsumerDiscoveryService = ConsumerDiscoveryService = ConsumerDiscoveryService_1 = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [core_1.DiscoveryService,
+        core_1.Reflector,
+        core_1.MetadataScanner])
+], ConsumerDiscoveryService);
+//# sourceMappingURL=consumer-discovery.service.js.map

package/dist/discovery/consumer-discovery.service.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"consumer-discovery.service.js","sourceRoot":"","sources":["../../lib/discovery/consumer-discovery.service.ts"],"names":[],"mappings":";;;;;;;;;;;;;AAAA,2CAAkE;AAClE,uCAA4E;AAC5E,uDAAkE;AAK3D,IAAM,wBAAwB,gCAA9B,MAAM,wBAAwB;IAKhB;IACA;IACA;IANF,MAAM,GAAG,IAAI,eAAM,CAAC,0BAAwB,CAAC,IAAI,CAAC,CAAC;IAC5D,mBAAmB,GAAuB,EAAE,CAAC;IAErD,YACmB,gBAAkC,EAClC,SAAoB,EACpB,eAAgC;QAFhC,qBAAgB,GAAhB,gBAAgB,CAAkB;QAClC,cAAS,GAAT,SAAS,CAAW;QACpB,oBAAe,GAAf,eAAe,CAAiB;IAChD,CAAC;IAEJ,YAAY;QACV,IAAI,CAAC,iBAAiB,EAAE,CAAC;IAC3B,CAAC;IAED,iBAAiB;QACf,IAAI,IAAI,CAAC,mBAAmB,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YACxC,OAAO,IAAI,CAAC,mBAAmB,CAAC;QAClC,CAAC;QAED,MAAM,SAAS,GAAG,IAAI,CAAC,gBAAgB,CAAC,YAAY,EAAE,CAAC;QAEvD,KAAK,MAAM,OAAO,IAAI,SAAS,EAAE,CAAC;YAEhC,MAAM,EAAE,QAAQ,EAAE,QAAQ,EAAE,GAAG,OAAO,CAAC;YAEvC,IAAI,CAAC,QAAQ,IAAI,CAAC,QAAQ,EAAE,CAAC;gBAC3B,SAAS;YACX,CAAC;YAED,MAAM,SAAS,GAAG,MAAM,CAAC,cAAc,CAAC,QAAQ,CAAW,CAAC;YAC5D,MAAM,WAAW,GAAG,IAAI,CAAC,eAAe,CAAC,iBAAiB,CAAC,SAAS,CAAC,CAAC;YAEtE,KAAK,MAAM,UAAU,IAAI,WAAW,EAAE,CAAC;gBACrC,MAAM,SAAS,GAAG,SAAS,CAAC,UAAoC,CAAC,CAAC;gBAElE,IAAI,OAAO,SAAS,KAAK,UAAU,EAAE,CAAC;oBACpC,SAAS;gBACX,CAAC;gBAED,MAAM,QAAQ,GAAG,IAAI,CAAC,SAAS,CAAC,GAAG,CACjC,mCAAuB,EACvB,SAAS,CACV,CAAC;gBAEF,IAAI,CAAC,QAAQ,EAAE,CAAC;oBACd,SAAS;gBACX,CAAC;gBAGD,IAAI,QAAQ,CAAC,OAAO,CAAC,QAAQ,EAAE,CAAC;oBAC9B,IAAI,CAAC,MAAM,CAAC,GAAG,CACb,+BAA+B,QAAQ,CAAC,IAAI,IAAI,UAAU,eAAe,QAAQ,CAAC,KAAK,EAAE,CAC1F,CAAC;oBACF,SAAS;gBACX,CAAC;gBAED,MAAM,gBAAgB,GAAqB;oBACzC,KAAK,EAAE,QAAQ,CAAC,KAAK;oBACrB,OAAO,EAAE;wBACP,GAAG,QAAQ,CAAC,OAAO;wBACnB,KAAK,EAAE,QAAQ,CAAC,KAAK;qBACtB;oBAED,MAAM,EAAE,QAAQ;oBAChB,UAAU;iBACX,CAAC;gBAEF,IAAI,CAAC,mBAAmB,CAAC,IAAI,CAAC,gBAAgB,CAAC,CAAC;gBAChD,IAAI,CAAC,MAAM,CAAC,GAAG,CACb,wBAAwB,QAAQ,CAAC,IAAI,IAAI,UAAU,eAAe,QAAQ,CAAC,KAAK,EAAE,CACnF,CAAC;YACJ,CAAC;QACH,CAAC;QAED,OAAO,IAAI,CAAC,mBAAmB,CAAC;IAClC,CAAC;IAED,YAAY;QACV,OAAO,IAAI,CAAC,mBAAmB,CAAC;IAClC,CAAC;CACF,CAAA;AAhFY,4DAAwB;mCAAxB,wBAAwB;IADpC,IAAA,mBAAU,GAAE;qCAM0B,uBAAgB;QACvB,gBAAS;QACH,sBAAe;GAPxC,wBAAwB,CAgFpC"}

package/dist/discovery/index.d.ts

@@ -0,0 +1 @@
+export * from './consumer-discovery.service';

package/dist/discovery/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("./consumer-discovery.service"), exports);
+//# sourceMappingURL=index.js.map

package/dist/discovery/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../lib/discovery/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,+DAA6C"}

package/dist/health/index.d.ts

@@ -0,0 +1 @@
+export * from './kafka-health-indicator';

package/dist/health/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-health-indicator"), exports);
+//# sourceMappingURL=index.js.map

package/dist/health/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../lib/health/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,2DAAyC"}

package/dist/health/kafka-health-indicator.d.ts

@@ -0,0 +1,12 @@
+import { HealthIndicatorService, HealthIndicatorResult } from '@nestjs/terminus';
+import { KafkaClient } from '../services/kafka-client.service';
+import { KafkaCoreService } from '../services/kafka-core.service';
+export declare class KafkaHealthIndicator {
+    private readonly healthIndicatorService;
+    private readonly kafkaClient;
+    private readonly kafkaCore;
+    constructor(healthIndicatorService: HealthIndicatorService, kafkaClient: KafkaClient, kafkaCore: KafkaCoreService);
+    isHealthy(key: string): HealthIndicatorResult;
+    checkBrokers(key: string): Promise<HealthIndicatorResult>;
+    checkConsumerLag(key: string, groupId: string, maxLag?: number): Promise<HealthIndicatorResult>;
+}