kafka-crab-js 1.4.0-beta.2 → 1.4.1

package/README.md

@@ -10,7 +10,7 @@ A lightweight, flexible, and reliable Kafka client for JavaScript/TypeScript. It
 
 ---
 
-## What's New in Version 1.4.x
+## What's New in Version 1.4.0
 
 ### Major Updates:
 1. **Enums Replaced by Unions**:

package/dist/index.cjs

@@ -0,0 +1,162 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// js-src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  CommitMode: () => import_js_binding2.CommitMode,
+  KafkaClient: () => KafkaClient,
+  KafkaClientConfig: () => import_js_binding2.KafkaClientConfig,
+  KafkaConsumer: () => import_js_binding2.KafkaConsumer,
+  KafkaEventName: () => import_js_binding2.KafkaEventName,
+  KafkaProducer: () => import_js_binding2.KafkaProducer,
+  KafkaStreamReadable: () => KafkaStreamReadable,
+  PartitionPosition: () => import_js_binding2.PartitionPosition,
+  SecurityProtocol: () => import_js_binding2.SecurityProtocol
+});
+module.exports = __toCommonJS(index_exports);
+var import_js_binding2 = require("../js-binding.cjs");
+
+// js-src/kafka-client.ts
+var import_js_binding = require("../js-binding.cjs");
+
+// js-src/kafka-stream-readable.ts
+var import_stream = require("stream");
+var KafkaStreamReadable = class extends import_stream.Readable {
+  /**
+   * Creates a KafkaStreamReadable instance
+   */
+  constructor(kafkaConsumer) {
+    super({ objectMode: true });
+    this.kafkaConsumer = kafkaConsumer;
+    if (!kafkaConsumer) {
+      throw new Error("A valid KafkaConsumer instance is required.");
+    }
+  }
+  /**
+   * Subscribes to topics
+   */
+  async subscribe(topics) {
+    if (!topics || Array.isArray(topics) && topics.length === 0) {
+      throw new Error("Topics must be a non-empty string or array.");
+    }
+    await this.kafkaConsumer.subscribe(topics);
+  }
+  seek(topic, partition, offsetModel, timeout) {
+    this.kafkaConsumer.seek(topic, partition, offsetModel, timeout);
+  }
+  commit(topic, partition, offset, commit) {
+    this.kafkaConsumer.commit(topic, partition, offset, commit);
+  }
+  /**
+   * Unsubscribe from topics
+   */
+  unsubscribe() {
+    this.kafkaConsumer.unsubscribe();
+  }
+  /**
+   * Disconnects the Kafka consumer
+   */
+  async disconnect() {
+    await this.kafkaConsumer.disconnect();
+  }
+  /**
+   * Returns the raw Kafka consumer
+   * @returns {KafkaConsumer} The Kafka consumer instance
+   */
+  rawConsumer() {
+    return this.kafkaConsumer;
+  }
+  /**
+   * Internal method called by the Readable stream to fetch data
+   * @private
+   */
+  async _read() {
+    try {
+      const message = await this.kafkaConsumer.recv();
+      if (message) {
+        this.push(message);
+      } else {
+        this.push(null);
+      }
+    } catch (error) {
+      if (error instanceof Error) {
+        this.destroy(error);
+      } else {
+        this.destroy();
+      }
+    }
+  }
+};
+
+// js-src/kafka-client.ts
+var KafkaClient = class {
+  /**
+   * Creates a KafkaClient instance
+   * @throws {Error} If the configuration is invalid
+   */
+  constructor(kafkaConfiguration) {
+    this.kafkaConfiguration = kafkaConfiguration;
+    this.kafkaClientConfig = new import_js_binding.KafkaClientConfig(this.kafkaConfiguration);
+  }
+  kafkaClientConfig;
+  /**
+   * Creates a KafkaProducer instance
+   * @param {ProducerConfiguration} [producerConfiguration] - Optional producer configuration
+   * @returns {KafkaProducer} A KafkaProducer instance
+   */
+  createProducer(producerConfiguration) {
+    if (producerConfiguration) {
+      return this.kafkaClientConfig.createProducer(producerConfiguration);
+    }
+    return this.kafkaClientConfig.createProducer({});
+  }
+  /**
+   * Creates a KafkaConsumer instance
+   * @param {ConsumerConfiguration} consumerConfiguration - Consumer configuration
+   * @returns {KafkaConsumer} A KafkaConsumer instance
+   * @throws {Error} If the configuration is invalid
+   */
+  createConsumer(consumerConfiguration) {
+    return this.kafkaClientConfig.createConsumer(consumerConfiguration);
+  }
+  /**
+   * Creates a KafkaStreamReadable instance
+   * @param {ConsumerConfiguration} consumerConfiguration - Consumer configuration
+   * @returns {KafkaStreamReadable} A KafkaStreamReadable instance
+   * @throws {Error} If the configuration is invalid
+   */
+  createStreamConsumer(consumerConfiguration) {
+    const consumer = this.kafkaClientConfig.createConsumer(consumerConfiguration);
+    return new KafkaStreamReadable(consumer);
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CommitMode,
+  KafkaClient,
+  KafkaClientConfig,
+  KafkaConsumer,
+  KafkaEventName,
+  KafkaProducer,
+  KafkaStreamReadable,
+  PartitionPosition,
+  SecurityProtocol
+});
+//# sourceMappingURL=index.cjs.map

package/dist/index.cjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../js-src/index.ts", "../js-src/kafka-client.ts", "../js-src/kafka-stream-readable.ts"],
+  "sourcesContent": ["export type {\n  ConsumerConfiguration,\n  KafkaConfiguration,\n  KafkaCrabError,\n  KafkaEvent,\n  KafkaEventPayload,\n  Message,\n  MessageProducer,\n  OffsetModel,\n  PartitionOffset,\n  ProducerConfiguration,\n  ProducerRecord,\n  RecordMetadata,\n  RetryStrategy,\n  TopicPartition,\n  TopicPartitionConfig,\n} from '../js-binding.js'\n\nexport {\n  CommitMode,\n  KafkaClientConfig,\n  KafkaConsumer,\n  KafkaEventName,\n  KafkaProducer,\n  PartitionPosition,\n  SecurityProtocol,\n} from '../js-binding.js'\nexport { KafkaClient } from './kafka-client.js'\nexport { KafkaStreamReadable } from './kafka-stream-readable.js'\n", "import { ConsumerConfiguration, KafkaClientConfig, KafkaConfiguration, ProducerConfiguration } from '../js-binding.js'\n\nimport { KafkaStreamReadable } from './kafka-stream-readable.js'\n\n/**\n * KafkaClient class\n */\nexport class KafkaClient {\n  private readonly kafkaClientConfig: KafkaClientConfig\n  /**\n   * Creates a KafkaClient instance\n   * @throws {Error} If the configuration is invalid\n   */\n  constructor(private readonly kafkaConfiguration: KafkaConfiguration) {\n    this.kafkaClientConfig = new KafkaClientConfig(this.kafkaConfiguration)\n  }\n\n  /**\n   * Creates a KafkaProducer instance\n   * @param {ProducerConfiguration} [producerConfiguration] - Optional producer configuration\n   * @returns {KafkaProducer} A KafkaProducer instance\n   */\n  createProducer(producerConfiguration: ProducerConfiguration) {\n    if (producerConfiguration) {\n      return this.kafkaClientConfig.createProducer(producerConfiguration)\n    }\n    return this.kafkaClientConfig.createProducer({})\n  }\n\n  /**\n   * Creates a KafkaConsumer instance\n   * @param {ConsumerConfiguration} consumerConfiguration - Consumer configuration\n   * @returns {KafkaConsumer} A KafkaConsumer instance\n   * @throws {Error} If the configuration is invalid\n   */\n  createConsumer(consumerConfiguration: ConsumerConfiguration) {\n    return this.kafkaClientConfig.createConsumer(consumerConfiguration)\n  }\n\n  /**\n   * Creates a KafkaStreamReadable instance\n   * @param {ConsumerConfiguration} consumerConfiguration - Consumer configuration\n   * @returns {KafkaStreamReadable} A KafkaStreamReadable instance\n   * @throws {Error} If the configuration is invalid\n   */\n  createStreamConsumer(consumerConfiguration: ConsumerConfiguration) {\n    const consumer = this.kafkaClientConfig.createConsumer(consumerConfiguration)\n    return new KafkaStreamReadable(consumer)\n  }\n}\n", "import { Readable } from 'stream'\n\nimport { KafkaConsumer, OffsetModel, TopicPartitionConfig } from '../js-binding.js'\nimport { CommitMode } from '../js-binding.js'\n\n/**\n * KafkaStreamReadable class\n * @extends Readable\n */\nexport class KafkaStreamReadable extends Readable {\n  /**\n   * Creates a KafkaStreamReadable instance\n   */\n  constructor(private readonly kafkaConsumer: KafkaConsumer) {\n    super({ objectMode: true })\n    if (!kafkaConsumer) {\n      throw new Error('A valid KafkaConsumer instance is required.')\n    }\n  }\n\n  /**\n   * Subscribes to topics\n   */\n  async subscribe(topics: string | Array<TopicPartitionConfig>) {\n    if (!topics || (Array.isArray(topics) && topics.length === 0)) {\n      throw new Error('Topics must be a non-empty string or array.')\n    }\n    await this.kafkaConsumer.subscribe(topics)\n  }\n\n  seek(topic: string, partition: number, offsetModel: OffsetModel, timeout?: number | undefined) {\n    this.kafkaConsumer.seek(topic, partition, offsetModel, timeout)\n  }\n\n  commit(topic: string, partition: number, offset: number, commit: CommitMode) {\n    this.kafkaConsumer.commit(topic, partition, offset, commit)\n  }\n\n  /**\n   * Unsubscribe from topics\n   */\n  unsubscribe() {\n    this.kafkaConsumer.unsubscribe()\n  }\n\n  /**\n   * Disconnects the Kafka consumer\n   */\n  async disconnect() {\n    await this.kafkaConsumer.disconnect()\n  }\n\n  /**\n   * Returns the raw Kafka consumer\n   * @returns {KafkaConsumer} The Kafka consumer instance\n   */\n  rawConsumer() {\n    return this.kafkaConsumer\n  }\n\n  /**\n   * Internal method called by the Readable stream to fetch data\n   * @private\n   */\n  async _read() {\n    try {\n      const message = await this.kafkaConsumer.recv() // Call the napi-rs method\n      if (message) {\n        this.push(message) // Push message into the stream\n      } else {\n        this.push(null) // No more data, end of stream\n      }\n    } catch (error) {\n      if (error instanceof Error) {\n        this.destroy(error)\n      } else {\n        this.destroy()\n      }\n    }\n  }\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAkBA,IAAAA,qBAQO;;;AC1BP,wBAAoG;;;ACApG,oBAAyB;AASlB,IAAM,sBAAN,cAAkC,uBAAS;AAAA;AAAA;AAAA;AAAA,EAIhD,YAA6B,eAA8B;AACzD,UAAM,EAAE,YAAY,KAAK,CAAC;AADC;AAE3B,QAAI,CAAC,eAAe;AAClB,YAAM,IAAI,MAAM,6CAA6C;AAAA,IAC/D;AAAA,EACF;AAAA;AAAA;AAAA;AAAA,EAKA,MAAM,UAAU,QAA8C;AAC5D,QAAI,CAAC,UAAW,MAAM,QAAQ,MAAM,KAAK,OAAO,WAAW,GAAI;AAC7D,YAAM,IAAI,MAAM,6CAA6C;AAAA,IAC/D;AACA,UAAM,KAAK,cAAc,UAAU,MAAM;AAAA,EAC3C;AAAA,EAEA,KAAK,OAAe,WAAmB,aAA0B,SAA8B;AAC7F,SAAK,cAAc,KAAK,OAAO,WAAW,aAAa,OAAO;AAAA,EAChE;AAAA,EAEA,OAAO,OAAe,WAAmB,QAAgB,QAAoB;AAC3E,SAAK,cAAc,OAAO,OAAO,WAAW,QAAQ,MAAM;AAAA,EAC5D;AAAA;AAAA;AAAA;AAAA,EAKA,cAAc;AACZ,SAAK,cAAc,YAAY;AAAA,EACjC;AAAA;AAAA;AAAA;AAAA,EAKA,MAAM,aAAa;AACjB,UAAM,KAAK,cAAc,WAAW;AAAA,EACtC;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA,cAAc;AACZ,WAAO,KAAK;AAAA,EACd;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA,MAAM,QAAQ;AACZ,QAAI;AACF,YAAM,UAAU,MAAM,KAAK,cAAc,KAAK;AAC9C,UAAI,SAAS;AACX,aAAK,KAAK,OAAO;AAAA,MACnB,OAAO;AACL,aAAK,KAAK,IAAI;AAAA,MAChB;AAAA,IACF,SAAS,OAAO;AACd,UAAI,iBAAiB,OAAO;AAC1B,aAAK,QAAQ,KAAK;AAAA,MACpB,OAAO;AACL,aAAK,QAAQ;AAAA,MACf;AAAA,IACF;AAAA,EACF;AACF;;;ADzEO,IAAM,cAAN,MAAkB;AAAA;AAAA;AAAA;AAAA;AAAA,EAMvB,YAA6B,oBAAwC;AAAxC;AAC3B,SAAK,oBAAoB,IAAI,oCAAkB,KAAK,kBAAkB;AAAA,EACxE;AAAA,EAPiB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAcjB,eAAe,uBAA8C;AAC3D,QAAI,uBAAuB;AACzB,aAAO,KAAK,kBAAkB,eAAe,qBAAqB;AAAA,IACpE;AACA,WAAO,KAAK,kBAAkB,eAAe,CAAC,CAAC;AAAA,EACjD;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQA,eAAe,uBAA8C;AAC3D,WAAO,KAAK,kBAAkB,eAAe,qBAAqB;AAAA,EACpE;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQA,qBAAqB,uBAA8C;AACjE,UAAM,WAAW,KAAK,kBAAkB,eAAe,qBAAqB;AAC5E,WAAO,IAAI,oBAAoB,QAAQ;AAAA,EACzC;AACF;",
+  "names": ["import_js_binding"]
+}

package/{index.d.ts → dist/index.d.ts}

@@ -1,4 +1,4 @@
-export type { ConsumerConfiguration, KafkaConfiguration, KafkaCrabError, KafkaEvent, KafkaEventPayload, Message, MessageProducer, OffsetModel, PartitionOffset, ProducerConfiguration, ProducerRecord, RecordMetadata, RetryStrategy, TopicPartition, TopicPartitionConfig, } from './js-binding';
-export { CommitMode, KafkaClientConfig, KafkaConsumer, KafkaEventName, KafkaProducer, PartitionPosition, SecurityProtocol, } from './js-binding';
-export { KafkaClient } from './kafka-client';
-export { KafkaStreamReadable } from './kafka-stream-readable';
+export type { ConsumerConfiguration, KafkaConfiguration, KafkaCrabError, KafkaEvent, KafkaEventPayload, Message, MessageProducer, OffsetModel, PartitionOffset, ProducerConfiguration, ProducerRecord, RecordMetadata, RetryStrategy, TopicPartition, TopicPartitionConfig, } from '../js-binding.js';
+export { CommitMode, KafkaClientConfig, KafkaConsumer, KafkaEventName, KafkaProducer, PartitionPosition, SecurityProtocol, } from '../js-binding.js';
+export { KafkaClient } from './kafka-client.js';
+export { KafkaStreamReadable } from './kafka-stream-readable.js';

package/dist/index.js

@@ -0,0 +1,137 @@
+// js-src/index.ts
+import {
+  CommitMode,
+  KafkaClientConfig as KafkaClientConfig2,
+  KafkaConsumer,
+  KafkaEventName,
+  KafkaProducer,
+  PartitionPosition,
+  SecurityProtocol
+} from "../js-binding.js";
+
+// js-src/kafka-client.ts
+import { KafkaClientConfig } from "../js-binding.js";
+
+// js-src/kafka-stream-readable.ts
+import { Readable } from "stream";
+var KafkaStreamReadable = class extends Readable {
+  /**
+   * Creates a KafkaStreamReadable instance
+   */
+  constructor(kafkaConsumer) {
+    super({ objectMode: true });
+    this.kafkaConsumer = kafkaConsumer;
+    if (!kafkaConsumer) {
+      throw new Error("A valid KafkaConsumer instance is required.");
+    }
+  }
+  /**
+   * Subscribes to topics
+   */
+  async subscribe(topics) {
+    if (!topics || Array.isArray(topics) && topics.length === 0) {
+      throw new Error("Topics must be a non-empty string or array.");
+    }
+    await this.kafkaConsumer.subscribe(topics);
+  }
+  seek(topic, partition, offsetModel, timeout) {
+    this.kafkaConsumer.seek(topic, partition, offsetModel, timeout);
+  }
+  commit(topic, partition, offset, commit) {
+    this.kafkaConsumer.commit(topic, partition, offset, commit);
+  }
+  /**
+   * Unsubscribe from topics
+   */
+  unsubscribe() {
+    this.kafkaConsumer.unsubscribe();
+  }
+  /**
+   * Disconnects the Kafka consumer
+   */
+  async disconnect() {
+    await this.kafkaConsumer.disconnect();
+  }
+  /**
+   * Returns the raw Kafka consumer
+   * @returns {KafkaConsumer} The Kafka consumer instance
+   */
+  rawConsumer() {
+    return this.kafkaConsumer;
+  }
+  /**
+   * Internal method called by the Readable stream to fetch data
+   * @private
+   */
+  async _read() {
+    try {
+      const message = await this.kafkaConsumer.recv();
+      if (message) {
+        this.push(message);
+      } else {
+        this.push(null);
+      }
+    } catch (error) {
+      if (error instanceof Error) {
+        this.destroy(error);
+      } else {
+        this.destroy();
+      }
+    }
+  }
+};
+
+// js-src/kafka-client.ts
+var KafkaClient = class {
+  /**
+   * Creates a KafkaClient instance
+   * @throws {Error} If the configuration is invalid
+   */
+  constructor(kafkaConfiguration) {
+    this.kafkaConfiguration = kafkaConfiguration;
+    this.kafkaClientConfig = new KafkaClientConfig(this.kafkaConfiguration);
+  }
+  kafkaClientConfig;
+  /**
+   * Creates a KafkaProducer instance
+   * @param {ProducerConfiguration} [producerConfiguration] - Optional producer configuration
+   * @returns {KafkaProducer} A KafkaProducer instance
+   */
+  createProducer(producerConfiguration) {
+    if (producerConfiguration) {
+      return this.kafkaClientConfig.createProducer(producerConfiguration);
+    }
+    return this.kafkaClientConfig.createProducer({});
+  }
+  /**
+   * Creates a KafkaConsumer instance
+   * @param {ConsumerConfiguration} consumerConfiguration - Consumer configuration
+   * @returns {KafkaConsumer} A KafkaConsumer instance
+   * @throws {Error} If the configuration is invalid
+   */
+  createConsumer(consumerConfiguration) {
+    return this.kafkaClientConfig.createConsumer(consumerConfiguration);
+  }
+  /**
+   * Creates a KafkaStreamReadable instance
+   * @param {ConsumerConfiguration} consumerConfiguration - Consumer configuration
+   * @returns {KafkaStreamReadable} A KafkaStreamReadable instance
+   * @throws {Error} If the configuration is invalid
+   */
+  createStreamConsumer(consumerConfiguration) {
+    const consumer = this.kafkaClientConfig.createConsumer(consumerConfiguration);
+    return new KafkaStreamReadable(consumer);
+  }
+};
+export {
+  CommitMode,
+  KafkaClient,
+  KafkaClientConfig2 as KafkaClientConfig,
+  KafkaConsumer,
+  KafkaEventName,
+  KafkaProducer,
+  KafkaStreamReadable,
+  PartitionPosition,
+  SecurityProtocol
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../js-src/index.ts", "../js-src/kafka-client.ts", "../js-src/kafka-stream-readable.ts"],
+  "sourcesContent": ["export type {\n  ConsumerConfiguration,\n  KafkaConfiguration,\n  KafkaCrabError,\n  KafkaEvent,\n  KafkaEventPayload,\n  Message,\n  MessageProducer,\n  OffsetModel,\n  PartitionOffset,\n  ProducerConfiguration,\n  ProducerRecord,\n  RecordMetadata,\n  RetryStrategy,\n  TopicPartition,\n  TopicPartitionConfig,\n} from '../js-binding.js'\n\nexport {\n  CommitMode,\n  KafkaClientConfig,\n  KafkaConsumer,\n  KafkaEventName,\n  KafkaProducer,\n  PartitionPosition,\n  SecurityProtocol,\n} from '../js-binding.js'\nexport { KafkaClient } from './kafka-client.js'\nexport { KafkaStreamReadable } from './kafka-stream-readable.js'\n", "import { ConsumerConfiguration, KafkaClientConfig, KafkaConfiguration, ProducerConfiguration } from '../js-binding.js'\n\nimport { KafkaStreamReadable } from './kafka-stream-readable.js'\n\n/**\n * KafkaClient class\n */\nexport class KafkaClient {\n  private readonly kafkaClientConfig: KafkaClientConfig\n  /**\n   * Creates a KafkaClient instance\n   * @throws {Error} If the configuration is invalid\n   */\n  constructor(private readonly kafkaConfiguration: KafkaConfiguration) {\n    this.kafkaClientConfig = new KafkaClientConfig(this.kafkaConfiguration)\n  }\n\n  /**\n   * Creates a KafkaProducer instance\n   * @param {ProducerConfiguration} [producerConfiguration] - Optional producer configuration\n   * @returns {KafkaProducer} A KafkaProducer instance\n   */\n  createProducer(producerConfiguration: ProducerConfiguration) {\n    if (producerConfiguration) {\n      return this.kafkaClientConfig.createProducer(producerConfiguration)\n    }\n    return this.kafkaClientConfig.createProducer({})\n  }\n\n  /**\n   * Creates a KafkaConsumer instance\n   * @param {ConsumerConfiguration} consumerConfiguration - Consumer configuration\n   * @returns {KafkaConsumer} A KafkaConsumer instance\n   * @throws {Error} If the configuration is invalid\n   */\n  createConsumer(consumerConfiguration: ConsumerConfiguration) {\n    return this.kafkaClientConfig.createConsumer(consumerConfiguration)\n  }\n\n  /**\n   * Creates a KafkaStreamReadable instance\n   * @param {ConsumerConfiguration} consumerConfiguration - Consumer configuration\n   * @returns {KafkaStreamReadable} A KafkaStreamReadable instance\n   * @throws {Error} If the configuration is invalid\n   */\n  createStreamConsumer(consumerConfiguration: ConsumerConfiguration) {\n    const consumer = this.kafkaClientConfig.createConsumer(consumerConfiguration)\n    return new KafkaStreamReadable(consumer)\n  }\n}\n", "import { Readable } from 'stream'\n\nimport { KafkaConsumer, OffsetModel, TopicPartitionConfig } from '../js-binding.js'\nimport { CommitMode } from '../js-binding.js'\n\n/**\n * KafkaStreamReadable class\n * @extends Readable\n */\nexport class KafkaStreamReadable extends Readable {\n  /**\n   * Creates a KafkaStreamReadable instance\n   */\n  constructor(private readonly kafkaConsumer: KafkaConsumer) {\n    super({ objectMode: true })\n    if (!kafkaConsumer) {\n      throw new Error('A valid KafkaConsumer instance is required.')\n    }\n  }\n\n  /**\n   * Subscribes to topics\n   */\n  async subscribe(topics: string | Array<TopicPartitionConfig>) {\n    if (!topics || (Array.isArray(topics) && topics.length === 0)) {\n      throw new Error('Topics must be a non-empty string or array.')\n    }\n    await this.kafkaConsumer.subscribe(topics)\n  }\n\n  seek(topic: string, partition: number, offsetModel: OffsetModel, timeout?: number | undefined) {\n    this.kafkaConsumer.seek(topic, partition, offsetModel, timeout)\n  }\n\n  commit(topic: string, partition: number, offset: number, commit: CommitMode) {\n    this.kafkaConsumer.commit(topic, partition, offset, commit)\n  }\n\n  /**\n   * Unsubscribe from topics\n   */\n  unsubscribe() {\n    this.kafkaConsumer.unsubscribe()\n  }\n\n  /**\n   * Disconnects the Kafka consumer\n   */\n  async disconnect() {\n    await this.kafkaConsumer.disconnect()\n  }\n\n  /**\n   * Returns the raw Kafka consumer\n   * @returns {KafkaConsumer} The Kafka consumer instance\n   */\n  rawConsumer() {\n    return this.kafkaConsumer\n  }\n\n  /**\n   * Internal method called by the Readable stream to fetch data\n   * @private\n   */\n  async _read() {\n    try {\n      const message = await this.kafkaConsumer.recv() // Call the napi-rs method\n      if (message) {\n        this.push(message) // Push message into the stream\n      } else {\n        this.push(null) // No more data, end of stream\n      }\n    } catch (error) {\n      if (error instanceof Error) {\n        this.destroy(error)\n      } else {\n        this.destroy()\n      }\n    }\n  }\n}\n"],
+  "mappings": ";AAkBA;AAAA,EACE;AAAA,EACA,qBAAAA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OACK;;;AC1BP,SAAgC,yBAAoE;;;ACApG,SAAS,gBAAgB;AASlB,IAAM,sBAAN,cAAkC,SAAS;AAAA;AAAA;AAAA;AAAA,EAIhD,YAA6B,eAA8B;AACzD,UAAM,EAAE,YAAY,KAAK,CAAC;AADC;AAE3B,QAAI,CAAC,eAAe;AAClB,YAAM,IAAI,MAAM,6CAA6C;AAAA,IAC/D;AAAA,EACF;AAAA;AAAA;AAAA;AAAA,EAKA,MAAM,UAAU,QAA8C;AAC5D,QAAI,CAAC,UAAW,MAAM,QAAQ,MAAM,KAAK,OAAO,WAAW,GAAI;AAC7D,YAAM,IAAI,MAAM,6CAA6C;AAAA,IAC/D;AACA,UAAM,KAAK,cAAc,UAAU,MAAM;AAAA,EAC3C;AAAA,EAEA,KAAK,OAAe,WAAmB,aAA0B,SAA8B;AAC7F,SAAK,cAAc,KAAK,OAAO,WAAW,aAAa,OAAO;AAAA,EAChE;AAAA,EAEA,OAAO,OAAe,WAAmB,QAAgB,QAAoB;AAC3E,SAAK,cAAc,OAAO,OAAO,WAAW,QAAQ,MAAM;AAAA,EAC5D;AAAA;AAAA;AAAA;AAAA,EAKA,cAAc;AACZ,SAAK,cAAc,YAAY;AAAA,EACjC;AAAA;AAAA;AAAA;AAAA,EAKA,MAAM,aAAa;AACjB,UAAM,KAAK,cAAc,WAAW;AAAA,EACtC;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA,cAAc;AACZ,WAAO,KAAK;AAAA,EACd;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA,MAAM,QAAQ;AACZ,QAAI;AACF,YAAM,UAAU,MAAM,KAAK,cAAc,KAAK;AAC9C,UAAI,SAAS;AACX,aAAK,KAAK,OAAO;AAAA,MACnB,OAAO;AACL,aAAK,KAAK,IAAI;AAAA,MAChB;AAAA,IACF,SAAS,OAAO;AACd,UAAI,iBAAiB,OAAO;AAC1B,aAAK,QAAQ,KAAK;AAAA,MACpB,OAAO;AACL,aAAK,QAAQ;AAAA,MACf;AAAA,IACF;AAAA,EACF;AACF;;;ADzEO,IAAM,cAAN,MAAkB;AAAA;AAAA;AAAA;AAAA;AAAA,EAMvB,YAA6B,oBAAwC;AAAxC;AAC3B,SAAK,oBAAoB,IAAI,kBAAkB,KAAK,kBAAkB;AAAA,EACxE;AAAA,EAPiB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAcjB,eAAe,uBAA8C;AAC3D,QAAI,uBAAuB;AACzB,aAAO,KAAK,kBAAkB,eAAe,qBAAqB;AAAA,IACpE;AACA,WAAO,KAAK,kBAAkB,eAAe,CAAC,CAAC;AAAA,EACjD;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQA,eAAe,uBAA8C;AAC3D,WAAO,KAAK,kBAAkB,eAAe,qBAAqB;AAAA,EACpE;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQA,qBAAqB,uBAA8C;AACjE,UAAM,WAAW,KAAK,kBAAkB,eAAe,qBAAqB;AAC5E,WAAO,IAAI,oBAAoB,QAAQ;AAAA,EACzC;AACF;",
+  "names": ["KafkaClientConfig"]
+}

package/{kafka-client.d.ts → dist/kafka-client.d.ts}

@@ -1,5 +1,5 @@
-import { ConsumerConfiguration, KafkaConfiguration, ProducerConfiguration } from './js-binding.js';
-import { KafkaStreamReadable } from './kafka-stream-readable';
+import { ConsumerConfiguration, KafkaConfiguration, ProducerConfiguration } from '../js-binding.js';
+import { KafkaStreamReadable } from './kafka-stream-readable.js';
 /**
  * KafkaClient class
  */
@@ -16,14 +16,14 @@ export declare class KafkaClient {
      * @param {ProducerConfiguration} [producerConfiguration] - Optional producer configuration
      * @returns {KafkaProducer} A KafkaProducer instance
      */
-    createProducer(producerConfiguration: ProducerConfiguration): import("./js-binding.js").KafkaProducer;
+    createProducer(producerConfiguration: ProducerConfiguration): import("../js-binding.js").KafkaProducer;
     /**
      * Creates a KafkaConsumer instance
      * @param {ConsumerConfiguration} consumerConfiguration - Consumer configuration
      * @returns {KafkaConsumer} A KafkaConsumer instance
      * @throws {Error} If the configuration is invalid
      */
-    createConsumer(consumerConfiguration: ConsumerConfiguration): import("./js-binding.js").KafkaConsumer;
+    createConsumer(consumerConfiguration: ConsumerConfiguration): import("../js-binding.js").KafkaConsumer;
     /**
      * Creates a KafkaStreamReadable instance
      * @param {ConsumerConfiguration} consumerConfiguration - Consumer configuration

package/{kafka-stream-readable.d.ts → dist/kafka-stream-readable.d.ts}

@@ -1,6 +1,6 @@
 import { Readable } from 'stream';
-import { CommitMode } from './js-binding';
-import { KafkaConsumer, OffsetModel, TopicPartitionConfig } from './js-binding';
+import { KafkaConsumer, OffsetModel, TopicPartitionConfig } from '../js-binding.js';
+import { CommitMode } from '../js-binding.js';
 /**
  * KafkaStreamReadable class
  * @extends Readable

package/js-binding.cjs

@@ -0,0 +1,383 @@
+// prettier-ignore
+/* eslint-disable */
+// @ts-nocheck
+/* auto-generated by NAPI-RS */
+
+const { createRequire } = require('node:module')
+require = createRequire(__filename)
+
+const { readFileSync } = require('node:fs')
+let nativeBinding = null
+const loadErrors = []
+
+const isMusl = () => {
+  let musl = false
+  if (process.platform === 'linux') {
+    musl = isMuslFromFilesystem()
+    if (musl === null) {
+      musl = isMuslFromReport()
+    }
+    if (musl === null) {
+      musl = isMuslFromChildProcess()
+    }
+  }
+  return musl
+}
+
+const isFileMusl = (f) => f.includes('libc.musl-') || f.includes('ld-musl-')
+
+const isMuslFromFilesystem = () => {
+  try {
+    return readFileSync('/usr/bin/ldd', 'utf-8').includes('musl')
+  } catch {
+    return null
+  }
+}
+
+const isMuslFromReport = () => {
+  let report = null
+  if (typeof process.report?.getReport === 'function') {
+    process.report.excludeNetwork = true
+    report = process.report.getReport()
+  }
+  if (!report) {
+    return null
+  }
+  if (report.header && report.header.glibcVersionRuntime) {
+    return false
+  }
+  if (Array.isArray(report.sharedObjects)) {
+    if (report.sharedObjects.some(isFileMusl)) {
+      return true
+    }
+  }
+  return false
+}
+
+const isMuslFromChildProcess = () => {
+  try {
+    return require('child_process').execSync('ldd --version', { encoding: 'utf8' }).includes('musl')
+  } catch (e) {
+    // If we reach this case, we don't know if the system is musl or not, so is better to just fallback to false
+    return false
+  }
+}
+
+function requireNative() {
+  if (process.env.NAPI_RS_NATIVE_LIBRARY_PATH) {
+    try {
+      nativeBinding = require(process.env.NAPI_RS_NATIVE_LIBRARY_PATH);
+    } catch (err) {
+      loadErrors.push(err);
+    }
+  } else if (process.platform === 'android') {
+    if (process.arch === 'arm64') {
+      try {
+        return require('./kafka-crab-js.android-arm64.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        return require('kafka-crab-js-android-arm64')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+
+    } else if (process.arch === 'arm') {
+      try {
+        return require('./kafka-crab-js.android-arm-eabi.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        return require('kafka-crab-js-android-arm-eabi')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+
+    } else {
+      loadErrors.push(new Error(`Unsupported architecture on Android ${process.arch}`))
+    }
+  } else if (process.platform === 'win32') {
+    if (process.arch === 'x64') {
+      try {
+        return require('./kafka-crab-js.win32-x64-msvc.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        return require('kafka-crab-js-win32-x64-msvc')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+
+    } else if (process.arch === 'ia32') {
+      try {
+        return require('./kafka-crab-js.win32-ia32-msvc.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        return require('kafka-crab-js-win32-ia32-msvc')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+
+    } else if (process.arch === 'arm64') {
+      try {
+        return require('./kafka-crab-js.win32-arm64-msvc.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        return require('kafka-crab-js-win32-arm64-msvc')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+
+    } else {
+      loadErrors.push(new Error(`Unsupported architecture on Windows: ${process.arch}`))
+    }
+  } else if (process.platform === 'darwin') {
+    try {
+        return require('./kafka-crab-js.darwin-universal.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        return require('kafka-crab-js-darwin-universal')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+
+    if (process.arch === 'x64') {
+      try {
+        return require('./kafka-crab-js.darwin-x64.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        return require('kafka-crab-js-darwin-x64')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+
+    } else if (process.arch === 'arm64') {
+      try {
+        return require('./kafka-crab-js.darwin-arm64.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        return require('kafka-crab-js-darwin-arm64')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+
+    } else {
+      loadErrors.push(new Error(`Unsupported architecture on macOS: ${process.arch}`))
+    }
+  } else if (process.platform === 'freebsd') {
+    if (process.arch === 'x64') {
+      try {
+        return require('./kafka-crab-js.freebsd-x64.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        return require('kafka-crab-js-freebsd-x64')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+
+    } else if (process.arch === 'arm64') {
+      try {
+        return require('./kafka-crab-js.freebsd-arm64.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        return require('kafka-crab-js-freebsd-arm64')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+
+    } else {
+      loadErrors.push(new Error(`Unsupported architecture on FreeBSD: ${process.arch}`))
+    }
+  } else if (process.platform === 'linux') {
+    if (process.arch === 'x64') {
+      if (isMusl()) {
+        try {
+        return require('./kafka-crab-js.linux-x64-musl.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        return require('kafka-crab-js-linux-x64-musl')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+
+      } else {
+        try {
+        return require('./kafka-crab-js.linux-x64-gnu.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        return require('kafka-crab-js-linux-x64-gnu')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+
+      }
+    } else if (process.arch === 'arm64') {
+      if (isMusl()) {
+        try {
+        return require('./kafka-crab-js.linux-arm64-musl.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        return require('kafka-crab-js-linux-arm64-musl')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+
+      } else {
+        try {
+        return require('./kafka-crab-js.linux-arm64-gnu.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        return require('kafka-crab-js-linux-arm64-gnu')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+
+      }
+    } else if (process.arch === 'arm') {
+      if (isMusl()) {
+        try {
+        return require('./kafka-crab-js.linux-arm-musleabihf.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        return require('kafka-crab-js-linux-arm-musleabihf')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+
+      } else {
+        try {
+        return require('./kafka-crab-js.linux-arm-gnueabihf.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        return require('kafka-crab-js-linux-arm-gnueabihf')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+
+      }
+    } else if (process.arch === 'riscv64') {
+      if (isMusl()) {
+        try {
+        return require('./kafka-crab-js.linux-riscv64-musl.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        return require('kafka-crab-js-linux-riscv64-musl')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+
+      } else {
+        try {
+        return require('./kafka-crab-js.linux-riscv64-gnu.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        return require('kafka-crab-js-linux-riscv64-gnu')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+
+      }
+    } else if (process.arch === 'ppc64') {
+      try {
+        return require('./kafka-crab-js.linux-ppc64-gnu.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        return require('kafka-crab-js-linux-ppc64-gnu')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+
+    } else if (process.arch === 's390x') {
+      try {
+        return require('./kafka-crab-js.linux-s390x-gnu.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        return require('kafka-crab-js-linux-s390x-gnu')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+
+    } else {
+      loadErrors.push(new Error(`Unsupported architecture on Linux: ${process.arch}`))
+    }
+  } else {
+    loadErrors.push(new Error(`Unsupported OS: ${process.platform}, architecture: ${process.arch}`))
+  }
+}
+
+nativeBinding = requireNative()
+
+if (!nativeBinding || process.env.NAPI_RS_FORCE_WASI) {
+  try {
+    nativeBinding = require('./kafka-crab-js.wasi.cjs')
+  } catch (err) {
+    if (process.env.NAPI_RS_FORCE_WASI) {
+      loadErrors.push(err)
+    }
+  }
+  if (!nativeBinding) {
+    try {
+      nativeBinding = require('kafka-crab-js-wasm32-wasi')
+    } catch (err) {
+      if (process.env.NAPI_RS_FORCE_WASI) {
+        loadErrors.push(err)
+      }
+    }
+  }
+}
+
+if (!nativeBinding) {
+  if (loadErrors.length > 0) {
+    // TODO Link to documentation with potential fixes
+    //  - The package owner could build/publish bindings for this arch
+    //  - The user may need to bundle the correct files
+    //  - The user may need to re-install node_modules to get new packages
+    throw new Error('Failed to load native binding', { cause: loadErrors })
+  }
+  throw new Error(`Failed to load native binding`)
+}
+
+module.exports.KafkaClientConfig = nativeBinding.KafkaClientConfig
+module.exports.KafkaConsumer = nativeBinding.KafkaConsumer
+module.exports.KafkaProducer = nativeBinding.KafkaProducer
+module.exports.CommitMode = nativeBinding.CommitMode
+module.exports.KafkaEventName = nativeBinding.KafkaEventName
+module.exports.PartitionPosition = nativeBinding.PartitionPosition
+module.exports.SecurityProtocol = nativeBinding.SecurityProtocol

package/js-binding.d.ts

@@ -1,5 +1,3 @@
-/* auto-generated by NAPI-RS */
-/* eslint-disable */
 export declare class KafkaClientConfig {
   constructor(kafkaConfiguration: KafkaConfiguration)
   get configuration(): KafkaConfiguration

package/package.json

@@ -1,18 +1,22 @@
 {
   "name": "kafka-crab-js",
-  "version": "1.4.0-beta.2",
-  "main": "index.js",
-  "types": "index.d.ts",
-  "module": "module",
+  "version": "1.4.1",
+  "type": "module",
+  "engines": {
+    "node": ">=20"
+  },
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    }
+  },
+  "types": "./dist/index.d.ts",
   "files": [
-    "index.d.ts",
-    "index.js",
-    "kafka-client.js",
-    "kafka-client.d.ts",
-    "kafka-stream-readable.js",
-    "kafka-stream-readable.d.ts",
+    "dist",
     "js-binding.js",
-    "js-binding.d.ts"
+    "js-binding.d.ts",
+    "js-binding.cjs"
   ],
   "napi": {
     "binaryName": "kafka-crab-js",
@@ -42,33 +46,36 @@
   "devDependencies": {
     "@faker-js/faker": "^9.7.0",
     "@napi-rs/cli": "^3.0.0-alpha.78",
-    "@types/node": "^22.15.3",
+    "@types/copyfiles": "^2.4.4",
+    "@types/node": "^22.15.12",
+    "copyfiles": "^2.4.1",
     "dprint": "^0.49.1",
+    "esbuild": "^0.25.4",
     "nanoid": "^5.1",
-    "typescript": "^5.8.3",
-    "copyfiles": "^2.4.1",
-    "@types/copyfiles": "^2.4.4",
-    "rimraf": "^6.0.1"
+    "oxlint": "^0.16.9",
+    "rimraf": "^6.0.1",
+    "typescript": "^5.8.3"
   },
   "scripts": {
     "artifacts": "napi artifacts",
-    "build": "napi build --esm --js js-src/js-binding.js --dts js-src/js-binding.d.ts --no-const-enum --platform --release",
-    "postbuild": "rimraf dist && tsc && copyfiles -f js-src/js-binding.d.ts js-src/js-binding.js ./dist/*.js ./dist/*.d.ts .",
+    "prebuild": "rimraf dist",
+    "build": "node build.mjs",
+    "postbuild": "tsc --emitDeclarationOnly --declaration --outDir dist",
     "build:debug": "napi build --platform",
     "prepublishOnly": "napi prepublish -t npm",
     "test": "node --test __test__/*.test.*",
     "test:integration": "node --test __test__/integration/*.test.*",
     "version": "napi version",
     "fmt": "dprint fmt",
-    "lint": "true"
+    "lint": "oxlint ."
   },
   "packageManager": "pnpm@10.10.0",
   "optionalDependencies": {
-    "kafka-crab-js-darwin-x64": "1.4.0-beta.2",
-    "kafka-crab-js-darwin-arm64": "1.4.0-beta.2",
-    "kafka-crab-js-linux-x64-gnu": "1.4.0-beta.2",
-    "kafka-crab-js-linux-x64-musl": "1.4.0-beta.2",
-    "kafka-crab-js-linux-arm64-gnu": "1.4.0-beta.2",
-    "kafka-crab-js-linux-arm64-musl": "1.4.0-beta.2"
+    "kafka-crab-js-darwin-x64": "1.4.1",
+    "kafka-crab-js-darwin-arm64": "1.4.1",
+    "kafka-crab-js-linux-x64-gnu": "1.4.1",
+    "kafka-crab-js-linux-x64-musl": "1.4.1",
+    "kafka-crab-js-linux-arm64-gnu": "1.4.1",
+    "kafka-crab-js-linux-arm64-musl": "1.4.1"
   }
 }

package/index.js

@@ -1,11 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.KafkaStreamReadable = exports.KafkaClient = exports.KafkaProducer = exports.KafkaConsumer = exports.KafkaClientConfig = void 0;
-var js_binding_1 = require("./js-binding");
-Object.defineProperty(exports, "KafkaClientConfig", { enumerable: true, get: function () { return js_binding_1.KafkaClientConfig; } });
-Object.defineProperty(exports, "KafkaConsumer", { enumerable: true, get: function () { return js_binding_1.KafkaConsumer; } });
-Object.defineProperty(exports, "KafkaProducer", { enumerable: true, get: function () { return js_binding_1.KafkaProducer; } });
-var kafka_client_1 = require("./kafka-client");
-Object.defineProperty(exports, "KafkaClient", { enumerable: true, get: function () { return kafka_client_1.KafkaClient; } });
-var kafka_stream_readable_1 = require("./kafka-stream-readable");
-Object.defineProperty(exports, "KafkaStreamReadable", { enumerable: true, get: function () { return kafka_stream_readable_1.KafkaStreamReadable; } });

package/kafka-client.js

@@ -1,49 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.KafkaClient = void 0;
-const js_binding_js_1 = require("./js-binding.js");
-const kafka_stream_readable_1 = require("./kafka-stream-readable");
-/**
- * KafkaClient class
- */
-class KafkaClient {
-    /**
-     * Creates a KafkaClient instance
-     * @throws {Error} If the configuration is invalid
-     */
-    constructor(kafkaConfiguration) {
-        this.kafkaConfiguration = kafkaConfiguration;
-        this.kafkaClientConfig = new js_binding_js_1.KafkaClientConfig(this.kafkaConfiguration);
-    }
-    /**
-     * Creates a KafkaProducer instance
-     * @param {ProducerConfiguration} [producerConfiguration] - Optional producer configuration
-     * @returns {KafkaProducer} A KafkaProducer instance
-     */
-    createProducer(producerConfiguration) {
-        if (producerConfiguration) {
-            return this.kafkaClientConfig.createProducer(producerConfiguration);
-        }
-        return this.kafkaClientConfig.createProducer({});
-    }
-    /**
-     * Creates a KafkaConsumer instance
-     * @param {ConsumerConfiguration} consumerConfiguration - Consumer configuration
-     * @returns {KafkaConsumer} A KafkaConsumer instance
-     * @throws {Error} If the configuration is invalid
-     */
-    createConsumer(consumerConfiguration) {
-        return this.kafkaClientConfig.createConsumer(consumerConfiguration);
-    }
-    /**
-     * Creates a KafkaStreamReadable instance
-     * @param {ConsumerConfiguration} consumerConfiguration - Consumer configuration
-     * @returns {KafkaStreamReadable} A KafkaStreamReadable instance
-     * @throws {Error} If the configuration is invalid
-     */
-    createStreamConsumer(consumerConfiguration) {
-        const consumer = this.kafkaClientConfig.createConsumer(consumerConfiguration);
-        return new kafka_stream_readable_1.KafkaStreamReadable(consumer);
-    }
-}
-exports.KafkaClient = KafkaClient;

package/kafka-stream-readable.js

@@ -1,79 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.KafkaStreamReadable = void 0;
-const stream_1 = require("stream");
-/**
- * KafkaStreamReadable class
- * @extends Readable
- */
-class KafkaStreamReadable extends stream_1.Readable {
-    /**
-     * Creates a KafkaStreamReadable instance
-     */
-    constructor(kafkaConsumer) {
-        super({ objectMode: true });
-        this.kafkaConsumer = kafkaConsumer;
-        if (!kafkaConsumer) {
-            throw new Error('A valid KafkaConsumer instance is required.');
-        }
-        this.kafkaConsumer = kafkaConsumer;
-    }
-    /**
-     * Subscribes to topics
-     */
-    async subscribe(topics) {
-        if (!topics || (Array.isArray(topics) && topics.length === 0)) {
-            throw new Error('Topics must be a non-empty string or array.');
-        }
-        await this.kafkaConsumer.subscribe(topics);
-    }
-    seek(topic, partition, offsetModel, timeout) {
-        this.kafkaConsumer.seek(topic, partition, offsetModel, timeout);
-    }
-    commit(topic, partition, offset, commit) {
-        this.kafkaConsumer.commit(topic, partition, offset, commit);
-    }
-    /**
-     * Unsubscribe from topics
-     */
-    unsubscribe() {
-        this.kafkaConsumer.unsubscribe();
-    }
-    /**
-     * Disconnects the Kafka consumer
-     */
-    async disconnect() {
-        await this.kafkaConsumer.disconnect();
-    }
-    /**
-     * Returns the raw Kafka consumer
-     * @returns {KafkaConsumer} The Kafka consumer instance
-     */
-    rawConsumer() {
-        return this.kafkaConsumer;
-    }
-    /**
-     * Internal method called by the Readable stream to fetch data
-     * @private
-     */
-    async _read() {
-        try {
-            const message = await this.kafkaConsumer.recv(); // Call the napi-rs method
-            if (message) {
-                this.push(message); // Push message into the stream
-            }
-            else {
-                this.push(null); // No more data, end of stream
-            }
-        }
-        catch (error) {
-            if (error instanceof Error) {
-                this.destroy(error);
-            }
-            else {
-                this.destroy();
-            }
-        }
-    }
-}
-exports.KafkaStreamReadable = KafkaStreamReadable;