@drarzter/kafka-client 0.2.1 → 0.3.0

package/dist/index.mjs

@@ -1,582 +1,26 @@
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __decorateClass = (decorators, target, key, kind) => {
-  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
-  for (var i = decorators.length - 1, decorator; i >= 0; i--)
-    if (decorator = decorators[i])
-      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
-  if (kind && result) __defProp(target, key, result);
-  return result;
-};
-var __decorateParam = (index, decorator) => (target, key) => decorator(target, key, index);
+import {
+  KafkaClient,
+  KafkaProcessingError,
+  KafkaRetryExhaustedError,
+  KafkaValidationError,
+  __decorateClass,
+  __decorateParam,
+  topic
+} from "./chunk-UDOHIMAZ.mjs";
 
-// src/module/kafka.module.ts
-import { Module } from "@nestjs/common";
+// src/nest/kafka.module.ts
+import { Module, Logger as Logger2 } from "@nestjs/common";
 import { DiscoveryModule } from "@nestjs/core";
 
-// src/client/kafka.client.ts
-import { Kafka, Partitioners } from "kafkajs";
-import { Logger } from "@nestjs/common";
-
-// src/client/errors.ts
-var KafkaProcessingError = class extends Error {
-  constructor(message, topic2, originalMessage, options) {
-    super(message, options);
-    this.topic = topic2;
-    this.originalMessage = originalMessage;
-    this.name = "KafkaProcessingError";
-    if (options?.cause) this.cause = options.cause;
-  }
-};
-var KafkaValidationError = class extends Error {
-  constructor(topic2, originalMessage, options) {
-    super(`Schema validation failed for topic "${topic2}"`, options);
-    this.topic = topic2;
-    this.originalMessage = originalMessage;
-    this.name = "KafkaValidationError";
-    if (options?.cause) this.cause = options.cause;
-  }
-};
-var KafkaRetryExhaustedError = class extends KafkaProcessingError {
-  constructor(topic2, originalMessage, attempts, options) {
-    super(
-      `Message processing failed after ${attempts} attempts on topic "${topic2}"`,
-      topic2,
-      originalMessage,
-      options
-    );
-    this.attempts = attempts;
-    this.name = "KafkaRetryExhaustedError";
-  }
-};
-
-// src/client/kafka.client.ts
-var KafkaClient = class {
-  kafka;
-  producer;
-  consumers = /* @__PURE__ */ new Map();
-  admin;
-  logger;
-  autoCreateTopicsEnabled;
-  strictSchemasEnabled;
-  ensuredTopics = /* @__PURE__ */ new Set();
-  defaultGroupId;
-  schemaRegistry = /* @__PURE__ */ new Map();
-  runningConsumers = /* @__PURE__ */ new Map();
-  isAdminConnected = false;
-  clientId;
-  constructor(clientId, groupId, brokers, options) {
-    this.clientId = clientId;
-    this.defaultGroupId = groupId;
-    this.logger = new Logger(`KafkaClient:${clientId}`);
-    this.autoCreateTopicsEnabled = options?.autoCreateTopics ?? false;
-    this.strictSchemasEnabled = options?.strictSchemas ?? true;
-    this.kafka = new Kafka({
-      clientId: this.clientId,
-      brokers
-    });
-    this.producer = this.kafka.producer({
-      createPartitioner: Partitioners.DefaultPartitioner,
-      idempotent: true,
-      transactionalId: `${clientId}-tx`,
-      maxInFlightRequests: 1
-    });
-    this.admin = this.kafka.admin();
-  }
-  getOrCreateConsumer(groupId) {
-    const gid = groupId || this.defaultGroupId;
-    if (!this.consumers.has(gid)) {
-      this.consumers.set(gid, this.kafka.consumer({ groupId: gid }));
-    }
-    return this.consumers.get(gid);
-  }
-  resolveTopicName(topicOrDescriptor) {
-    if (typeof topicOrDescriptor === "string") return topicOrDescriptor;
-    if (topicOrDescriptor && typeof topicOrDescriptor === "object" && "__topic" in topicOrDescriptor) {
-      return topicOrDescriptor.__topic;
-    }
-    return String(topicOrDescriptor);
-  }
-  async ensureTopic(topic2) {
-    if (!this.autoCreateTopicsEnabled || this.ensuredTopics.has(topic2)) return;
-    if (!this.isAdminConnected) {
-      await this.admin.connect();
-      this.isAdminConnected = true;
-    }
-    await this.admin.createTopics({
-      topics: [{ topic: topic2, numPartitions: 1 }]
-    });
-    this.ensuredTopics.add(topic2);
-  }
-  validateMessage(topicOrDesc, message) {
-    if (topicOrDesc?.__schema) {
-      const topic2 = this.resolveTopicName(topicOrDesc);
-      this.schemaRegistry.set(topic2, topicOrDesc.__schema);
-      return topicOrDesc.__schema.parse(message);
-    }
-    if (this.strictSchemasEnabled && typeof topicOrDesc === "string") {
-      const schema = this.schemaRegistry.get(topicOrDesc);
-      if (schema) return schema.parse(message);
-    }
-    return message;
-  }
-  async sendMessage(topicOrDesc, message, options = {}) {
-    const validated = this.validateMessage(topicOrDesc, message);
-    const topic2 = this.resolveTopicName(topicOrDesc);
-    await this.ensureTopic(topic2);
-    await this.producer.send({
-      topic: topic2,
-      messages: [
-        {
-          value: JSON.stringify(validated),
-          key: options.key ?? null,
-          headers: options.headers
-        }
-      ],
-      acks: -1
-    });
-  }
-  async sendBatch(topicOrDesc, messages) {
-    const topic2 = this.resolveTopicName(topicOrDesc);
-    await this.ensureTopic(topic2);
-    await this.producer.send({
-      topic: topic2,
-      messages: messages.map((m) => ({
-        value: JSON.stringify(this.validateMessage(topicOrDesc, m.value)),
-        key: m.key ?? null,
-        headers: m.headers
-      })),
-      acks: -1
-    });
-  }
-  /** Execute multiple sends atomically. Commits on success, aborts on error. */
-  async transaction(fn) {
-    const tx = await this.producer.transaction();
-    try {
-      const ctx = {
-        send: async (topicOrDesc, message, options = {}) => {
-          const validated = this.validateMessage(topicOrDesc, message);
-          const topic2 = this.resolveTopicName(topicOrDesc);
-          await this.ensureTopic(topic2);
-          await tx.send({
-            topic: topic2,
-            messages: [
-              {
-                value: JSON.stringify(validated),
-                key: options.key ?? null,
-                headers: options.headers
-              }
-            ],
-            acks: -1
-          });
-        },
-        sendBatch: async (topicOrDesc, messages) => {
-          const topic2 = this.resolveTopicName(topicOrDesc);
-          await this.ensureTopic(topic2);
-          await tx.send({
-            topic: topic2,
-            messages: messages.map((m) => ({
-              value: JSON.stringify(this.validateMessage(topicOrDesc, m.value)),
-              key: m.key ?? null,
-              headers: m.headers
-            })),
-            acks: -1
-          });
-        }
-      };
-      await fn(ctx);
-      await tx.commit();
-    } catch (error) {
-      await tx.abort();
-      throw error;
-    }
-  }
-  /** Connect the idempotent producer. Called automatically by `KafkaModule.register()`. */
-  async connectProducer() {
-    await this.producer.connect();
-    this.logger.log("Producer connected");
-  }
-  async disconnectProducer() {
-    await this.producer.disconnect();
-    this.logger.log("Producer disconnected");
-  }
-  async startConsumer(topics, handleMessage, options = {}) {
-    const {
-      groupId: optGroupId,
-      fromBeginning = false,
-      autoCommit = true,
-      retry,
-      dlq = false,
-      interceptors = [],
-      schemas: optionSchemas
-    } = options;
-    const gid = optGroupId || this.defaultGroupId;
-    const existingMode = this.runningConsumers.get(gid);
-    if (existingMode === "eachBatch") {
-      throw new Error(
-        `Cannot use eachMessage on consumer group "${gid}" \u2014 it is already running with eachBatch. Use a different groupId for this consumer.`
-      );
-    }
-    const consumer = this.getOrCreateConsumer(optGroupId);
-    const schemaMap = this.buildSchemaMap(topics, optionSchemas);
-    const topicNames = topics.map(
-      (t) => this.resolveTopicName(t)
-    );
-    await consumer.connect();
-    await this.subscribeWithRetry(consumer, topicNames, fromBeginning, options.subscribeRetry);
-    this.logger.log(`Consumer subscribed to topics: ${topicNames.join(", ")}`);
-    await consumer.run({
-      autoCommit,
-      eachMessage: async ({ topic: topic2, message }) => {
-        if (!message.value) {
-          this.logger.warn(`Received empty message from topic ${topic2}`);
-          return;
-        }
-        const raw = message.value.toString();
-        let parsedMessage;
-        try {
-          parsedMessage = JSON.parse(raw);
-        } catch (error) {
-          this.logger.error(
-            `Failed to parse message from topic ${topic2}:`,
-            error instanceof Error ? error.stack : String(error)
-          );
-          return;
-        }
-        const schema = schemaMap.get(topic2);
-        if (schema) {
-          try {
-            parsedMessage = schema.parse(parsedMessage);
-          } catch (error) {
-            const err = error instanceof Error ? error : new Error(String(error));
-            const validationError = new KafkaValidationError(
-              topic2,
-              parsedMessage,
-              { cause: err }
-            );
-            this.logger.error(
-              `Schema validation failed for topic ${topic2}:`,
-              err.message
-            );
-            if (dlq) await this.sendToDlq(topic2, raw);
-            for (const interceptor of interceptors) {
-              await interceptor.onError?.(
-                parsedMessage,
-                topic2,
-                validationError
-              );
-            }
-            return;
-          }
-        }
-        await this.processMessage(parsedMessage, raw, topic2, handleMessage, {
-          retry,
-          dlq,
-          interceptors
-        });
-      }
-    });
-    this.runningConsumers.set(gid, "eachMessage");
-  }
-  async startBatchConsumer(topics, handleBatch, options = {}) {
-    const {
-      groupId: optGroupId,
-      fromBeginning = false,
-      autoCommit = true,
-      retry,
-      dlq = false,
-      interceptors = [],
-      schemas: optionSchemas
-    } = options;
-    const gid = optGroupId || this.defaultGroupId;
-    const existingMode = this.runningConsumers.get(gid);
-    if (existingMode === "eachMessage") {
-      throw new Error(
-        `Cannot use eachBatch on consumer group "${gid}" \u2014 it is already running with eachMessage. Use a different groupId for this consumer.`
-      );
-    }
-    const consumer = this.getOrCreateConsumer(optGroupId);
-    const schemaMap = this.buildSchemaMap(topics, optionSchemas);
-    const topicNames = topics.map(
-      (t) => this.resolveTopicName(t)
-    );
-    await consumer.connect();
-    await this.subscribeWithRetry(consumer, topicNames, fromBeginning, options.subscribeRetry);
-    this.logger.log(
-      `Batch consumer subscribed to topics: ${topicNames.join(", ")}`
-    );
-    await consumer.run({
-      autoCommit,
-      eachBatch: async ({
-        batch,
-        heartbeat,
-        resolveOffset,
-        commitOffsetsIfNecessary
-      }) => {
-        const validMessages = [];
-        for (const message of batch.messages) {
-          if (!message.value) {
-            this.logger.warn(
-              `Received empty message from topic ${batch.topic}`
-            );
-            continue;
-          }
-          const raw = message.value.toString();
-          let parsedMessage;
-          try {
-            parsedMessage = JSON.parse(raw);
-          } catch (error) {
-            this.logger.error(
-              `Failed to parse message from topic ${batch.topic}:`,
-              error instanceof Error ? error.stack : String(error)
-            );
-            continue;
-          }
-          const schema = schemaMap.get(batch.topic);
-          if (schema) {
-            try {
-              parsedMessage = schema.parse(parsedMessage);
-            } catch (error) {
-              const err = error instanceof Error ? error : new Error(String(error));
-              const validationError = new KafkaValidationError(
-                batch.topic,
-                parsedMessage,
-                { cause: err }
-              );
-              this.logger.error(
-                `Schema validation failed for topic ${batch.topic}:`,
-                err.message
-              );
-              if (dlq) await this.sendToDlq(batch.topic, raw);
-              for (const interceptor of interceptors) {
-                await interceptor.onError?.(
-                  parsedMessage,
-                  batch.topic,
-                  validationError
-                );
-              }
-              continue;
-            }
-          }
-          validMessages.push(parsedMessage);
-        }
-        if (validMessages.length === 0) return;
-        const meta = {
-          partition: batch.partition,
-          highWatermark: batch.highWatermark,
-          heartbeat,
-          resolveOffset,
-          commitOffsetsIfNecessary
-        };
-        const maxAttempts = retry ? retry.maxRetries + 1 : 1;
-        const backoffMs = retry?.backoffMs ?? 1e3;
-        for (let attempt = 1; attempt <= maxAttempts; attempt++) {
-          try {
-            for (const interceptor of interceptors) {
-              for (const msg of validMessages) {
-                await interceptor.before?.(msg, batch.topic);
-              }
-            }
-            await handleBatch(validMessages, batch.topic, meta);
-            for (const interceptor of interceptors) {
-              for (const msg of validMessages) {
-                await interceptor.after?.(msg, batch.topic);
-              }
-            }
-            return;
-          } catch (error) {
-            const err = error instanceof Error ? error : new Error(String(error));
-            const isLastAttempt = attempt === maxAttempts;
-            if (isLastAttempt && maxAttempts > 1) {
-              const exhaustedError = new KafkaRetryExhaustedError(
-                batch.topic,
-                validMessages,
-                maxAttempts,
-                { cause: err }
-              );
-              for (const interceptor of interceptors) {
-                await interceptor.onError?.(
-                  validMessages,
-                  batch.topic,
-                  exhaustedError
-                );
-              }
-            } else {
-              for (const interceptor of interceptors) {
-                await interceptor.onError?.(
-                  validMessages,
-                  batch.topic,
-                  err
-                );
-              }
-            }
-            this.logger.error(
-              `Error processing batch from topic ${batch.topic} (attempt ${attempt}/${maxAttempts}):`,
-              err.stack
-            );
-            if (isLastAttempt) {
-              if (dlq) {
-                for (const msg of batch.messages) {
-                  if (msg.value) {
-                    await this.sendToDlq(batch.topic, msg.value.toString());
-                  }
-                }
-              }
-            } else {
-              await this.sleep(backoffMs * attempt);
-            }
-          }
-        }
-      }
-    });
-    this.runningConsumers.set(gid, "eachBatch");
-  }
-  async stopConsumer() {
-    const tasks = [];
-    for (const consumer of this.consumers.values()) {
-      tasks.push(consumer.disconnect());
-    }
-    await Promise.allSettled(tasks);
-    this.consumers.clear();
-    this.runningConsumers.clear();
-    this.logger.log("All consumers disconnected");
-  }
-  /** Check broker connectivity and return available topics. */
-  async checkStatus() {
-    if (!this.isAdminConnected) {
-      await this.admin.connect();
-      this.isAdminConnected = true;
-    }
-    const topics = await this.admin.listTopics();
-    return { topics };
-  }
-  getClientId() {
-    return this.clientId;
-  }
-  /** Gracefully disconnect producer, all consumers, and admin. */
-  async disconnect() {
-    const tasks = [this.producer.disconnect()];
-    for (const consumer of this.consumers.values()) {
-      tasks.push(consumer.disconnect());
-    }
-    if (this.isAdminConnected) {
-      tasks.push(this.admin.disconnect());
-      this.isAdminConnected = false;
-    }
-    await Promise.allSettled(tasks);
-    this.consumers.clear();
-    this.runningConsumers.clear();
-    this.logger.log("All connections closed");
-  }
-  // --- Private helpers ---
-  buildSchemaMap(topics, optionSchemas) {
-    const schemaMap = /* @__PURE__ */ new Map();
-    for (const t of topics) {
-      if (t?.__schema) {
-        const name = this.resolveTopicName(t);
-        schemaMap.set(name, t.__schema);
-        this.schemaRegistry.set(name, t.__schema);
-      }
-    }
-    if (optionSchemas) {
-      for (const [k, v] of optionSchemas) {
-        schemaMap.set(k, v);
-        this.schemaRegistry.set(k, v);
-      }
-    }
-    return schemaMap;
-  }
-  async processMessage(parsedMessage, raw, topic2, handleMessage, opts) {
-    const { retry, dlq = false, interceptors = [] } = opts;
-    const maxAttempts = retry ? retry.maxRetries + 1 : 1;
-    const backoffMs = retry?.backoffMs ?? 1e3;
-    for (let attempt = 1; attempt <= maxAttempts; attempt++) {
-      try {
-        for (const interceptor of interceptors) {
-          await interceptor.before?.(parsedMessage, topic2);
-        }
-        await handleMessage(parsedMessage, topic2);
-        for (const interceptor of interceptors) {
-          await interceptor.after?.(parsedMessage, topic2);
-        }
-        return;
-      } catch (error) {
-        const err = error instanceof Error ? error : new Error(String(error));
-        const isLastAttempt = attempt === maxAttempts;
-        if (isLastAttempt && maxAttempts > 1) {
-          const exhaustedError = new KafkaRetryExhaustedError(
-            topic2,
-            parsedMessage,
-            maxAttempts,
-            { cause: err }
-          );
-          for (const interceptor of interceptors) {
-            await interceptor.onError?.(parsedMessage, topic2, exhaustedError);
-          }
-        } else {
-          for (const interceptor of interceptors) {
-            await interceptor.onError?.(parsedMessage, topic2, err);
-          }
-        }
-        this.logger.error(
-          `Error processing message from topic ${topic2} (attempt ${attempt}/${maxAttempts}):`,
-          err.stack
-        );
-        if (isLastAttempt) {
-          if (dlq) await this.sendToDlq(topic2, raw);
-        } else {
-          await this.sleep(backoffMs * attempt);
-        }
-      }
-    }
-  }
-  async sendToDlq(topic2, rawMessage) {
-    const dlqTopic = `${topic2}.dlq`;
-    try {
-      await this.producer.send({
-        topic: dlqTopic,
-        messages: [{ value: rawMessage }],
-        acks: -1
-      });
-      this.logger.warn(`Message sent to DLQ: ${dlqTopic}`);
-    } catch (error) {
-      this.logger.error(
-        `Failed to send message to DLQ ${dlqTopic}:`,
-        error instanceof Error ? error.stack : String(error)
-      );
-    }
-  }
-  async subscribeWithRetry(consumer, topics, fromBeginning, retryOpts) {
-    const maxAttempts = retryOpts?.retries ?? 5;
-    const backoffMs = retryOpts?.backoffMs ?? 5e3;
-    for (let attempt = 1; attempt <= maxAttempts; attempt++) {
-      try {
-        await consumer.subscribe({ topics, fromBeginning });
-        return;
-      } catch (error) {
-        if (attempt === maxAttempts) throw error;
-        const msg = error instanceof Error ? error.message : String(error);
-        this.logger.warn(
-          `Failed to subscribe to [${topics.join(", ")}] (attempt ${attempt}/${maxAttempts}): ${msg}. Retrying in ${backoffMs}ms...`
-        );
-        await this.sleep(backoffMs);
-      }
-    }
-  }
-  sleep(ms) {
-    return new Promise((resolve) => setTimeout(resolve, ms));
-  }
-};
-
-// src/module/kafka.constants.ts
+// src/nest/kafka.constants.ts
 var KAFKA_CLIENT = "KAFKA_CLIENT";
 var getKafkaClientToken = (name) => name ? `KAFKA_CLIENT_${name}` : KAFKA_CLIENT;
 
-// src/module/kafka.explorer.ts
-import { Inject as Inject2, Injectable, Logger as Logger2 } from "@nestjs/common";
+// src/nest/kafka.explorer.ts
+import { Inject as Inject2, Injectable, Logger } from "@nestjs/common";
 import { DiscoveryService, ModuleRef } from "@nestjs/core";
 
-// src/decorators/kafka.decorator.ts
+// src/nest/kafka.decorator.ts
 import { Inject } from "@nestjs/common";
 var KAFKA_SUBSCRIBER_METADATA = "KAFKA_SUBSCRIBER_METADATA";
 var InjectKafkaClient = (name) => Inject(getKafkaClientToken(name));
@@ -610,13 +54,13 @@ var SubscribeTo = (topics, options) => {
   };
 };
 
-// src/module/kafka.explorer.ts
+// src/nest/kafka.explorer.ts
 var KafkaExplorer = class {
   constructor(discoveryService, moduleRef) {
     this.discoveryService = discoveryService;
     this.moduleRef = moduleRef;
   }
-  logger = new Logger2(KafkaExplorer.name);
+  logger = new Logger(KafkaExplorer.name);
   async onModuleInit() {
     const providers = this.discoveryService.getProviders();
     for (const wrapper of providers) {
@@ -673,7 +117,7 @@ KafkaExplorer = __decorateClass([
   __decorateParam(1, Inject2(ModuleRef))
 ], KafkaExplorer);
 
-// src/module/kafka.module.ts
+// src/nest/kafka.module.ts
 var KafkaModule = class {
   /** Register a Kafka client with static options. */
   static register(options) {
@@ -685,7 +129,10 @@ var KafkaModule = class {
           options.clientId,
           options.groupId,
           options.brokers,
-          { autoCreateTopics: options.autoCreateTopics }
+          {
+            autoCreateTopics: options.autoCreateTopics,
+            logger: new Logger2(`KafkaClient:${options.clientId}`)
+          }
         );
         await client.connectProducer();
         return client;
@@ -717,7 +164,10 @@ var KafkaModule = class {
           options.clientId,
           options.groupId,
           options.brokers,
-          { autoCreateTopics: options.autoCreateTopics }
+          {
+            autoCreateTopics: options.autoCreateTopics,
+            logger: new Logger2(`KafkaClient:${options.clientId}`)
+          }
         );
         await client.connectProducer();
         return client;
@@ -744,21 +194,7 @@ KafkaModule = __decorateClass([
   Module({})
 ], KafkaModule);
 
-// src/client/topic.ts
-function topic(name) {
-  const fn = () => ({
-    __topic: name,
-    __type: void 0
-  });
-  fn.schema = (schema) => ({
-    __topic: name,
-    __type: void 0,
-    __schema: schema
-  });
-  return fn;
-}
-
-// src/health/kafka.health.ts
+// src/nest/kafka.health.ts
 import { Injectable as Injectable2 } from "@nestjs/common";
 var KafkaHealthIndicator = class {
   async check(client) {