@eventferry/kafka 2.0.0 → 3.1.0

package/README.md

@@ -35,6 +35,146 @@ const publisher = new KafkaPublisher({
 
 You can also pass a `customDriver` implementing the `KafkaDriver` interface.
 
+## Authentication & TLS
+
+### One-way TLS
+
+```ts
+new KafkaPublisher({
+  brokers: ["broker:9093"],
+  ssl: true, // uses the driver's default trust store
+});
+```
+
+### mTLS (mutual TLS)
+
+```ts
+import { readFileSync } from "node:fs";
+
+new KafkaPublisher({
+  brokers: ["broker:9093"],
+  ssl: {
+    ca: readFileSync("/etc/ssl/kafka-ca.pem"),
+    cert: readFileSync("/etc/ssl/client.pem"),
+    key: readFileSync("/etc/ssl/client-key.pem"),
+    passphrase: "optional",
+    // servername: "broker.example.com",   // SNI override if cert SAN differs
+  },
+});
+```
+
+> `rejectUnauthorized` is intentionally NOT a knob. TLS verification is
+> non-negotiable. For dev clusters with self-signed certs, pass the cluster
+> CA via `ca` so verification succeeds.
+
+### SASL — username + password (PLAIN / SCRAM)
+
+```ts
+new KafkaPublisher({
+  brokers: ["broker:9093"],
+  ssl: true,
+  sasl: {
+    mechanism: "scram-sha-512", // or "plain" | "scram-sha-256"
+    username: process.env.KAFKA_USER!,
+    password: process.env.KAFKA_PASSWORD!,
+  },
+});
+```
+
+### SASL/OAUTHBEARER (Azure Event Hubs, OIDC, MSK IAM)
+
+```ts
+new KafkaPublisher({
+  brokers: ["broker:9093"],
+  ssl: true,
+  sasl: {
+    mechanism: "oauthbearer",
+    oauthBearerProvider: async () => {
+      const token = await myTokenIssuer();
+      return {
+        value: token.value,           // required for both drivers
+        principal: token.principal,   // required for confluent driver
+        lifetime: token.expiresInMs,  // required for confluent driver
+        extensions: token.extensions, // optional
+      };
+    },
+  },
+});
+```
+
+> **Driver asymmetry:** `kafkajs` reads only `value`; `@confluentinc/kafka-javascript` requires `value` + `principal` + `lifetime` (in milliseconds) and accepts an optional `extensions` map. Cross-driver portable providers should populate all four fields.
+
+## Producer tuning
+
+The high-throughput recipe (confluent driver):
+
+```ts
+new KafkaPublisher({
+  driver: "confluent",
+  brokers: ["broker:9092"],
+  idempotent: true,
+  compression: "zstd",
+  lingerMs: 25,        // batch up to 25ms for higher throughput
+  batchSize: 131_072,  // 128 KB per partition batch
+  maxInFlightRequests: 5,
+  maxRequestSize: 2_000_000,
+});
+```
+
+Driver support matrix:
+
+| Knob | `kafkajs` | `confluent` |
+|---|:--:|:--:|
+| `transactionTimeoutMs` | ✅ | ✅ |
+| `requestTimeoutMs` | ✅ | ✅ |
+| `maxInFlightRequests` | ✅ | ✅ |
+| `lingerMs` | ⚠️ warn + ignore | ✅ |
+| `batchSize` | ⚠️ warn + ignore | ✅ |
+| `deliveryTimeoutMs` | ⚠️ warn + ignore | ✅ |
+| `maxRequestSize` | ⚠️ warn + ignore | ✅ |
+
+`kafkajs` has no equivalent producer-level config for the last four — its batching is sticky-partitioner + hardcoded internals. The typed API accepts them for portability; on the kafkajs driver they log a one-time warning and are otherwise ignored. Use the confluent driver when you need fine-grained tuning.
+
+## Partitioning
+
+### Default (key-based, java-compatible)
+
+By default a record's `key` is hashed (murmur2, matching the Java client) and the partition derived from it. Same key → same partition → ordered stream per aggregate. No config needed.
+
+### Explicit partition override
+
+Pin a record to a specific partition by setting `partition` on the
+`PublishableMessage` — for compacted topics with application-managed sharding, tenant-affinity routing, or geo-pinning:
+
+```ts
+const msg: PublishableMessage = {
+  topic: "orders.created",
+  key: "tenant-a:order-42",
+  value: encoded,
+  headers: {},
+  recordId: row.id,
+  messageId: row.message_id,
+  partition: 3, // ← pins this record to partition 3
+};
+```
+
+### kafkajs partitioner choice
+
+The kafkajs driver exposes the v2 partitioner selection (and silences the
+`KafkaJSPartitionerNotSpecified` warning):
+
+```ts
+new KafkaPublisher({
+  driver: "kafkajs",
+  brokers: ["broker:9092"],
+  partitioner: "java-compatible", // (default) | "legacy" | "default"
+});
+```
+
+- `"java-compatible"` — kafkajs's `JavaCompatiblePartitioner`; greenfield recommendation, matches the Java client's murmur2.
+- `"legacy"` — pre-v2 hashing. Use when migrating an existing topic to keep hash continuity.
+- `"default"` — kafkajs's current default. May change in future major versions.
+
 📖 **Full documentation:** [github.com/SametGoktepe/eventferry](https://github.com/SametGoktepe/eventferry#readme)
 
 ## License

package/dist/index.cjs

@@ -32,11 +32,108 @@ var index_exports = {};
 __export(index_exports, {
   ConfluentDriver: () => ConfluentDriver,
   KafkaJsDriver: () => KafkaJsDriver,
-  KafkaPublisher: () => KafkaPublisher
+  KafkaPublisher: () => KafkaPublisher,
+  _resetKafkajsWarnDedup: () => _resetKafkajsWarnDedup,
+  buildConfluentClientConfig: () => buildConfluentClientConfig,
+  classifyConfluentError: () => classifyConfluentError,
+  classifyKafkajsError: () => classifyKafkajsError
 });
 module.exports = __toCommonJS(index_exports);
 
+// src/kafkajs-classifier.ts
+function classifyKafkajsError(err) {
+  if (!err || typeof err !== "object") return "retriable";
+  const e = err;
+  if (e.name === "KafkaJSConnectionError") return "retriable";
+  if (e.name === "KafkaJSRequestTimeoutError") return "retriable";
+  if (e.name === "KafkaJSNonRetriableError") return "fatal";
+  const type = typeof e.type === "string" ? e.type : void 0;
+  if (type) {
+    if (RETRIABLE_TYPES.has(type)) return "retriable";
+    if (POISON_TYPES.has(type)) return "poison";
+    if (FATAL_TYPES.has(type)) return "fatal";
+  }
+  if (typeof e.code === "number") {
+    const k = CODE_TO_KIND.get(e.code);
+    if (k) return k;
+  }
+  return "retriable";
+}
+var RETRIABLE_TYPES = /* @__PURE__ */ new Set([
+  "NOT_LEADER_FOR_PARTITION",
+  "LEADER_NOT_AVAILABLE",
+  "UNKNOWN_TOPIC_OR_PARTITION",
+  "NETWORK_EXCEPTION",
+  "REQUEST_TIMED_OUT",
+  "REPLICA_NOT_AVAILABLE",
+  "NOT_ENOUGH_REPLICAS",
+  "NOT_ENOUGH_REPLICAS_AFTER_APPEND",
+  "FENCED_LEADER_EPOCH",
+  "UNKNOWN_LEADER_EPOCH",
+  "BROKER_NOT_AVAILABLE",
+  "COORDINATOR_LOAD_IN_PROGRESS",
+  "COORDINATOR_NOT_AVAILABLE"
+]);
+var POISON_TYPES = /* @__PURE__ */ new Set([
+  "CORRUPT_MESSAGE",
+  "MESSAGE_TOO_LARGE",
+  "INVALID_RECORD",
+  "UNSUPPORTED_COMPRESSION_TYPE",
+  "INVALID_REQUIRED_ACKS",
+  "INVALID_PARTITIONS"
+]);
+var FATAL_TYPES = /* @__PURE__ */ new Set([
+  "INVALID_PRODUCER_EPOCH",
+  "PRODUCER_FENCED",
+  "TOPIC_AUTHORIZATION_FAILED",
+  "CLUSTER_AUTHORIZATION_FAILED",
+  "TRANSACTIONAL_ID_AUTHORIZATION_FAILED",
+  "SASL_AUTHENTICATION_FAILED",
+  "INVALID_TRANSACTION_STATE",
+  "UNSUPPORTED_VERSION"
+]);
+var CODE_TO_KIND = /* @__PURE__ */ new Map([
+  [2, "poison"],
+  // CORRUPT_MESSAGE
+  [3, "retriable"],
+  // UNKNOWN_TOPIC_OR_PARTITION
+  [5, "retriable"],
+  // LEADER_NOT_AVAILABLE
+  [6, "retriable"],
+  // NOT_LEADER_FOR_PARTITION
+  [7, "retriable"],
+  // REQUEST_TIMED_OUT
+  [9, "retriable"],
+  // REPLICA_NOT_AVAILABLE
+  [10, "poison"],
+  // MESSAGE_TOO_LARGE
+  [13, "retriable"],
+  // NETWORK_EXCEPTION
+  [19, "retriable"],
+  // NOT_ENOUGH_REPLICAS
+  [29, "fatal"],
+  // TOPIC_AUTHORIZATION_FAILED
+  [31, "fatal"],
+  // CLUSTER_AUTHORIZATION_FAILED
+  [47, "fatal"],
+  // INVALID_PRODUCER_EPOCH
+  [58, "fatal"],
+  // SASL_AUTHENTICATION_FAILED
+  [74, "retriable"],
+  // FENCED_LEADER_EPOCH
+  [76, "poison"],
+  // UNSUPPORTED_COMPRESSION_TYPE
+  [87, "poison"]
+  // INVALID_RECORD
+]);
+
 // src/kafkajs-driver.ts
+var UNSUPPORTED_BY_KAFKAJS = [
+  "lingerMs",
+  "batchSize",
+  "deliveryTimeoutMs",
+  "maxRequestSize"
+];
 var KafkaJsDriver = class {
   transactional;
   producer = null;
@@ -49,6 +146,7 @@ var KafkaJsDriver = class {
         "KafkaJsDriver: transactionalId is required when transactional=true"
       );
     }
+    warnUnsupportedKafkajsOptions(opts);
   }
   async connect() {
     this.producer = await this.createProducer();
@@ -63,13 +161,36 @@ var KafkaJsDriver = class {
     const kafka = new mod.Kafka({
       clientId: this.opts.clientId ?? "eventferry",
       brokers: this.opts.brokers,
+      // kafkajs accepts `ssl: tls.ConnectionOptions` directly — Buffer + PEM
+      // string both supported. Our TlsConfig is a structural subset of that
+      // (`rejectUnauthorized` intentionally omitted; the cluster CA goes via
+      // `ca`). No translation needed.
       ssl: this.opts.ssl,
+      // SASL: PLAIN / SCRAM-SHA-256 / SCRAM-SHA-512 / OAUTHBEARER. kafkajs's
+      // shape matches ours; for OAUTHBEARER kafkajs reads only `value` from
+      // the provider's returned token (other fields are ignored).
       sasl: this.opts.sasl
     });
+    const createPartitioner = resolveCreatePartitioner(
+      mod.Partitioners,
+      this.opts.partitioner,
+      this.transactional
+    );
     return kafka.producer({
       idempotent: this.opts.idempotent ?? true,
-      maxInFlightRequests: this.transactional ? 1 : void 0,
-      transactionalId: this.transactional ? this.opts.transactionalId : void 0
+      // Idempotent / transactional producers cap maxInFlight at 5. When the
+      // user picks transactional we force 1 to keep strict ordering across
+      // retries on classic (non-idempotent) clusters that haven't migrated
+      // to the broker-side fence.
+      maxInFlightRequests: this.transactional ? 1 : this.opts.maxInFlightRequests,
+      transactionalId: this.transactional ? this.opts.transactionalId : void 0,
+      // kafkajs accepts these directly when set; undefined falls through to
+      // the kafkajs default.
+      requestTimeout: this.opts.requestTimeoutMs,
+      transactionTimeout: this.opts.transactionTimeoutMs,
+      // Setting any partitioner choice silences kafkajs's
+      // KafkaJSPartitionerNotSpecified warning.
+      createPartitioner
     });
   }
   async disconnect() {
@@ -87,19 +208,27 @@ var KafkaJsDriver = class {
         return messages.map((m) => ({ recordId: m.recordId, ok: true }));
       } catch (err) {
         await txn.abort().catch(() => void 0);
-        const error = err instanceof Error ? err : new Error(String(err));
-        return messages.map((m) => ({ recordId: m.recordId, ok: false, error }));
+        return failedResults(messages, err);
       }
     }
     try {
       await this.producer.sendBatch({ topicMessages, acks: this.opts.acks ?? -1 });
       return messages.map((m) => ({ recordId: m.recordId, ok: true }));
     } catch (err) {
-      const error = err instanceof Error ? err : new Error(String(err));
-      return messages.map((m) => ({ recordId: m.recordId, ok: false, error }));
+      return failedResults(messages, err);
     }
   }
 };
+function failedResults(messages, err) {
+  const error = err instanceof Error ? err : new Error(String(err));
+  const errorKind = classifyKafkajsError(err);
+  return messages.map((m) => ({
+    recordId: m.recordId,
+    ok: false,
+    error,
+    errorKind
+  }));
+}
 function groupByTopic(messages, compression) {
   const byTopic = /* @__PURE__ */ new Map();
   for (const m of messages) {
@@ -107,7 +236,12 @@ function groupByTopic(messages, compression) {
     arr.push({
       key: m.key,
       value: m.value,
-      headers: m.headers
+      headers: m.headers,
+      // Per-message partition override. When set, kafkajs routes the record
+      // to this exact partition; when undefined, the configured partitioner
+      // chooses. We keep the key here too because compacted topics need it
+      // even when partition is pinned.
+      ...m.partition !== void 0 ? { partition: m.partition } : {}
     });
     byTopic.set(m.topic, arr);
   }
@@ -117,6 +251,32 @@ function groupByTopic(messages, compression) {
     ...compression && compression !== "none" ? { compression } : {}
   }));
 }
+function resolveCreatePartitioner(partitioners, choice, transactional) {
+  if (!partitioners) return void 0;
+  const effective = choice ?? (transactional ? "default" : "java-compatible");
+  switch (effective) {
+    case "java-compatible":
+      return partitioners.JavaCompatiblePartitioner;
+    case "legacy":
+      return partitioners.LegacyPartitioner;
+    case "default":
+      return partitioners.DefaultPartitioner;
+  }
+}
+var warnedKafkajsKeys = /* @__PURE__ */ new Set();
+function warnUnsupportedKafkajsOptions(opts) {
+  for (const key of UNSUPPORTED_BY_KAFKAJS) {
+    if (opts[key] === void 0) continue;
+    if (warnedKafkajsKeys.has(key)) continue;
+    warnedKafkajsKeys.add(key);
+    console.warn(
+      `[@eventferry/kafka] '${key}' is not configurable on the kafkajs driver and was ignored. Switch to the confluent driver (driver: "confluent") for fine-grained tuning, or remove the option to silence this warning.`
+    );
+  }
+}
+function _resetKafkajsWarnDedup() {
+  warnedKafkajsKeys.clear();
+}
 async function importKafkaJs() {
   try {
     return await import("kafkajs");
@@ -127,6 +287,169 @@ async function importKafkaJs() {
   }
 }
 
+// src/confluent-classifier.ts
+function classifyConfluentError(err) {
+  if (!err || typeof err !== "object") return "retriable";
+  const e = err;
+  if (typeof e.code === "number") {
+    const k = CODE_TO_KIND2.get(e.code);
+    if (k) return k;
+  }
+  if (typeof e.name === "string") {
+    const k = NAME_TO_KIND.get(e.name);
+    if (k) return k;
+  }
+  return "retriable";
+}
+var CODE_TO_KIND2 = /* @__PURE__ */ new Map([
+  // Library-internal (negative codes)
+  [-184, "backpressure"],
+  // ERR__QUEUE_FULL — our outbound buffer is full
+  [-185, "retriable"],
+  // ERR__TIMED_OUT
+  [-187, "retriable"],
+  // ERR__ALL_BROKERS_DOWN
+  [-188, "poison"],
+  // ERR__UNKNOWN_TOPIC — topic doesn't exist on broker
+  [-190, "poison"],
+  // ERR__UNKNOWN_PARTITION
+  [-192, "retriable"],
+  // ERR__MSG_TIMED_OUT
+  [-195, "retriable"],
+  // ERR__TRANSPORT
+  [-198, "poison"],
+  // ERR__BAD_COMPRESSION
+  [-144, "fatal"],
+  // ERR__FENCED — producer fenced by another with same txn id
+  [-150, "fatal"],
+  // ERR__FATAL — unrecoverable librdkafka error
+  [-169, "fatal"],
+  // ERR__AUTHENTICATION
+  [-181, "fatal"],
+  // ERR__SSL
+  [-196, "retriable"],
+  // ERR__FAIL — catch-all, safe-default to retriable
+  // Wire-protocol (non-negative codes — Kafka error-code registry)
+  [2, "poison"],
+  // CORRUPT_MESSAGE
+  [3, "retriable"],
+  // UNKNOWN_TOPIC_OR_PARTITION
+  [5, "retriable"],
+  // LEADER_NOT_AVAILABLE
+  [6, "retriable"],
+  // NOT_LEADER_FOR_PARTITION
+  [7, "retriable"],
+  // REQUEST_TIMED_OUT
+  [9, "retriable"],
+  // REPLICA_NOT_AVAILABLE
+  [10, "poison"],
+  // MESSAGE_TOO_LARGE
+  [13, "retriable"],
+  // NETWORK_EXCEPTION
+  [19, "retriable"],
+  // NOT_ENOUGH_REPLICAS
+  [29, "fatal"],
+  // TOPIC_AUTHORIZATION_FAILED
+  [31, "fatal"],
+  // CLUSTER_AUTHORIZATION_FAILED
+  [47, "fatal"],
+  // INVALID_PRODUCER_EPOCH
+  [58, "fatal"],
+  // SASL_AUTHENTICATION_FAILED
+  [74, "retriable"],
+  // FENCED_LEADER_EPOCH
+  [76, "poison"],
+  // UNSUPPORTED_COMPRESSION_TYPE
+  [87, "poison"],
+  // INVALID_RECORD
+  [89, "quota"]
+  // THROTTLING_QUOTA_EXCEEDED
+]);
+var NAME_TO_KIND = /* @__PURE__ */ new Map([
+  ["ERR__QUEUE_FULL", "backpressure"],
+  ["ERR__FENCED", "fatal"],
+  ["ERR__FATAL", "fatal"],
+  ["ERR__AUTHENTICATION", "fatal"],
+  ["ERR__SSL", "fatal"],
+  ["ERR__UNKNOWN_TOPIC", "poison"],
+  ["ERR__UNKNOWN_PARTITION", "poison"],
+  ["ERR__BAD_COMPRESSION", "poison"],
+  ["ERR_TOPIC_AUTHORIZATION_FAILED", "fatal"],
+  ["ERR_CLUSTER_AUTHORIZATION_FAILED", "fatal"],
+  ["ERR_INVALID_PRODUCER_EPOCH", "fatal"],
+  ["ERR_SASL_AUTHENTICATION_FAILED", "fatal"],
+  ["ERR_CORRUPT_MESSAGE", "poison"],
+  ["ERR_MSG_SIZE_TOO_LARGE", "poison"],
+  ["ERR_INVALID_RECORD", "poison"],
+  ["ERR_UNSUPPORTED_COMPRESSION_TYPE", "poison"],
+  ["ERR_THROTTLING_QUOTA_EXCEEDED", "quota"]
+]);
+
+// src/confluent-config.ts
+function buildConfluentClientConfig(opts) {
+  const kafkaJS = {
+    clientId: opts.clientId ?? "eventferry",
+    brokers: opts.brokers
+  };
+  const librdkafka = {};
+  if (opts.lingerMs !== void 0) librdkafka["linger.ms"] = opts.lingerMs;
+  if (opts.batchSize !== void 0) librdkafka["batch.size"] = opts.batchSize;
+  if (opts.maxInFlightRequests !== void 0) {
+    librdkafka["max.in.flight.requests.per.connection"] = opts.maxInFlightRequests;
+  }
+  if (opts.requestTimeoutMs !== void 0) {
+    librdkafka["request.timeout.ms"] = opts.requestTimeoutMs;
+  }
+  if (opts.deliveryTimeoutMs !== void 0) {
+    librdkafka["delivery.timeout.ms"] = opts.deliveryTimeoutMs;
+  }
+  if (opts.maxRequestSize !== void 0) {
+    librdkafka["message.max.bytes"] = opts.maxRequestSize;
+  }
+  if (opts.transactionTimeoutMs !== void 0) {
+    librdkafka["transaction.timeout.ms"] = opts.transactionTimeoutMs;
+  }
+  const tlsRequested = opts.ssl === true || isTlsConfig(opts.ssl);
+  const saslRequested = !!opts.sasl;
+  if (saslRequested && tlsRequested) {
+    librdkafka["security.protocol"] = "sasl_ssl";
+  } else if (tlsRequested) {
+    librdkafka["security.protocol"] = "ssl";
+  } else if (saslRequested) {
+    librdkafka["security.protocol"] = "sasl_plaintext";
+  }
+  if (isTlsConfig(opts.ssl)) {
+    const tls = opts.ssl;
+    if (tls.ca !== void 0) {
+      librdkafka["ssl.ca.pem"] = stringifyPem(tls.ca);
+    }
+    if (tls.cert !== void 0) {
+      librdkafka["ssl.certificate.pem"] = stringifyPem(tls.cert);
+    }
+    if (tls.key !== void 0) {
+      librdkafka["ssl.key.pem"] = stringifyPem(tls.key);
+    }
+    if (tls.passphrase !== void 0) {
+      librdkafka["ssl.key.password"] = tls.passphrase;
+    }
+  } else if (opts.ssl === true) {
+    kafkaJS["ssl"] = true;
+  }
+  if (opts.sasl) {
+    kafkaJS["sasl"] = opts.sasl;
+  }
+  return { kafkaJS, librdkafka };
+}
+function isTlsConfig(v) {
+  return typeof v === "object" && v !== null;
+}
+function stringifyPem(input) {
+  if (Array.isArray(input)) {
+    return input.map((x) => typeof x === "string" ? x : x.toString("utf8")).join("\n");
+  }
+  return typeof input === "string" ? input : input.toString("utf8");
+}
+
 // src/confluent-driver.ts
 var ConfluentDriver = class {
   transactional;
@@ -151,13 +474,10 @@ var ConfluentDriver = class {
    */
   async createProducer() {
     const mod = await importConfluent();
+    const { kafkaJS, librdkafka } = buildConfluentClientConfig(this.opts);
     const kafka = new mod.KafkaJS.Kafka({
-      kafkaJS: {
-        clientId: this.opts.clientId ?? "eventferry",
-        brokers: this.opts.brokers,
-        ssl: this.opts.ssl,
-        sasl: this.opts.sasl
-      }
+      kafkaJS,
+      ...librdkafka
     });
     return kafka.producer({
       kafkaJS: {
@@ -193,24 +513,39 @@ var ConfluentDriver = class {
         return messages.map((m) => ({ recordId: m.recordId, ok: true }));
       } catch (err) {
         await txn.abort().catch(() => void 0);
-        const error = err instanceof Error ? err : new Error(String(err));
-        return messages.map((m) => ({ recordId: m.recordId, ok: false, error }));
+        return failedResults2(messages, err);
       }
     }
     try {
       await doSends(this.producer);
       return messages.map((m) => ({ recordId: m.recordId, ok: true }));
     } catch (err) {
-      const error = err instanceof Error ? err : new Error(String(err));
-      return messages.map((m) => ({ recordId: m.recordId, ok: false, error }));
+      return failedResults2(messages, err);
     }
   }
 };
+function failedResults2(messages, err) {
+  const error = err instanceof Error ? err : new Error(String(err));
+  const errorKind = classifyConfluentError(err);
+  return messages.map((m) => ({
+    recordId: m.recordId,
+    ok: false,
+    error,
+    errorKind
+  }));
+}
 function groupByTopic2(messages) {
   const byTopic = /* @__PURE__ */ new Map();
   for (const m of messages) {
     const arr = byTopic.get(m.topic) ?? [];
-    arr.push({ key: m.key, value: m.value, headers: m.headers });
+    arr.push({
+      key: m.key,
+      value: m.value,
+      headers: m.headers,
+      // Per-message partition override. librdkafka honors an explicit
+      // partition value; undefined leaves the default partitioner in charge.
+      ...m.partition !== void 0 ? { partition: m.partition } : {}
+    });
     byTopic.set(m.topic, arr);
   }
   return [...byTopic.entries()].map(([topic, msgs]) => ({
@@ -282,6 +617,10 @@ function selectDriver(opts) {
 0 && (module.exports = {
   ConfluentDriver,
   KafkaJsDriver,
-  KafkaPublisher
+  KafkaPublisher,
+  _resetKafkajsWarnDedup,
+  buildConfluentClientConfig,
+  classifyConfluentError,
+  classifyKafkajsError
 });
 //# sourceMappingURL=index.cjs.map