@orbit-stream/redpanda 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 santhoshk382
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,70 @@
+# orbit-stream-redpanda
+
+High-performance Redpanda transport adapter for Orbit Stream.
+
+# @orbit-stream/redpanda
+
+High-performance Redpanda transport adapter for Orbit Stream.
+
+Optimized for:
+
+- high-throughput telemetry
+- binary payloads
+- batching
+- low-latency streaming
+- backpressure-aware processing
+
+---
+
+# Installation
+
+```bash id="ygt1m4"
+npm install @orbit-stream/redpanda
+```
+
+---
+
+# Usage
+
+```js id="w9d4p7"
+const { RedpandaAdapter } = require("@orbit-stream/redpanda");
+
+const stream = new RedpandaAdapter({
+  brokers: ["localhost:9092"],
+
+  groupId: "telemetry-group",
+
+  batchSize: 5000,
+
+  flushInterval: 100,
+});
+
+await stream.connect();
+
+await stream.publish("telemetry", {
+  value: Buffer.from("hello"),
+});
+
+await stream.subscribe("telemetry", async (messages) => {
+  console.log(messages.length);
+});
+```
+
+---
+
+# Features
+
+- KafkaJS based
+- Redpanda optimized
+- Batch publishing
+- Batch consumption
+- Buffer-first architecture
+- Backpressure-aware
+- High throughput optimized
+- Binary payload support
+
+---
+
+# License
+
+MIT

package/index.d.ts

@@ -0,0 +1,40 @@
+import { BaseAdapter, Message } from "@orbit-stream/core";
+
+export interface RedpandaConfig {
+  clientId?: string;
+
+  brokers?: string[];
+
+  ssl?: boolean;
+
+  sasl?: any;
+
+  groupId?: string;
+
+  batchSize?: number;
+
+  flushInterval?: number;
+
+  maxInFlightRequests?: number;
+}
+
+export class RedpandaAdapter extends BaseAdapter {
+  constructor(config?: RedpandaConfig);
+
+  connect(): Promise<void>;
+
+  disconnect(): Promise<void>;
+
+  publish(topic: string, message: Message): Promise<void>;
+
+  publishBatch(topic: string, messages: Message[]): Promise<void>;
+
+  subscribe(
+    topic: string,
+    handler: (messages: Message[]) => Promise<void> | void,
+    options?: {
+      fromBeginning?: boolean;
+      partitionsConsumedConcurrently?: number;
+    },
+  ): Promise<void>;
+}

package/package.json

@@ -0,0 +1,24 @@
+{
+  "name": "@orbit-stream/redpanda",
+  "version": "1.0.0",
+  "description": "High-performance Redpanda transport adapter for Orbit Stream.",
+  "main": "src/index.js",
+  "types": "index.d.ts",
+  "files": [
+    "src",
+    "index.d.ts"
+  ],
+  "dependencies": {
+    "@orbit-stream/core": "^1.0.0",
+    "kafkajs": "^2.2.4"
+  },
+  "keywords": [
+    "redpanda",
+    "kafka",
+    "stream",
+    "streaming",
+    "telemetry",
+    "orbit-stream"
+  ],
+  "license": "MIT"
+}

package/src/adapters/RedpandaAdapter.js

@@ -0,0 +1,67 @@
+const { BaseAdapter, BatchProcessor } = require("@orbit-stream/core");
+
+const createKafka = require("../utils/createKafka");
+
+const Producer = require("../producer/Producer");
+
+const Consumer = require("../consumer/Consumer");
+
+class RedpandaAdapter extends BaseAdapter {
+  constructor(config = {}) {
+    super(config);
+
+    this.kafka = createKafka(config);
+
+    this.producer = new Producer(this.kafka, config);
+
+    this.consumer = new Consumer(this.kafka, config);
+
+    this.batchProcessor = new BatchProcessor({
+      batchSize: config.batchSize || 5000,
+
+      flushInterval: config.flushInterval || 100,
+    });
+  }
+
+  async connect() {
+    await Promise.all([this.producer.connect(), this.consumer.connect()]);
+
+    this.emitConnected();
+  }
+
+  async disconnect() {
+    await Promise.all([this.producer.disconnect(), this.consumer.disconnect()]);
+
+    this.emitDisconnected();
+  }
+
+  async publish(topic, message) {
+    this.batchProcessor.add(
+      message,
+
+      async (batch) => {
+        await this.publishBatch(topic, batch);
+      },
+    );
+  }
+
+  async publishBatch(topic, messages) {
+    return this.producer.publishBatch(
+      topic,
+
+      messages,
+    );
+  }
+
+  async subscribe(topic, handler, options = {}) {
+    return this.consumer.subscribe(
+      topic,
+
+      handler,
+
+      options,
+    );
+  }
+}
+
+module.exports = RedpandaAdapter;

package/src/consumer/Consumer.js

@@ -0,0 +1,91 @@
+const { serializer, logger } = require("@orbit-stream/core");
+
+class Consumer {
+  constructor(kafka, config = {}) {
+    this.consumer = kafka.consumer({
+      groupId: config.groupId || "orbit-stream-group",
+
+      sessionTimeout: 30000,
+
+      heartbeatInterval: 3000,
+
+      maxBytesPerPartition: 10485760,
+
+      minBytes: 1,
+
+      maxBytes: 52428800,
+    });
+
+    this.connected = false;
+  }
+
+  async connect() {
+    if (this.connected) {
+      return;
+    }
+
+    await this.consumer.connect();
+
+    this.connected = true;
+  }
+
+  async disconnect() {
+    if (!this.connected) {
+      return;
+    }
+
+    await this.consumer.disconnect();
+
+    this.connected = false;
+  }
+
+  async subscribe(topic, handler, options = {}) {
+    await this.consumer.subscribe({
+      topic,
+
+      fromBeginning: options.fromBeginning || false,
+    });
+
+    await this.consumer.run({
+      autoCommit: true,
+
+      partitionsConsumedConcurrently:
+        options.partitionsConsumedConcurrently || 3,
+
+      eachBatchAutoResolve: true,
+
+      eachBatch: async ({
+        batch,
+        resolveOffset,
+        heartbeat,
+        commitOffsetsIfNecessary,
+      }) => {
+        const messages = new Array(batch.messages.length);
+
+        for (let i = 0; i < batch.messages.length; i++) {
+          const msg = batch.messages[i];
+
+          messages[i] = {
+            key: msg.key,
+
+            value: serializer.deserialize(msg.value),
+
+            headers: msg.headers,
+
+            timestamp: Number(msg.timestamp),
+          };
+
+          resolveOffset(msg.offset);
+        }
+
+        await handler(messages);
+
+        await heartbeat();
+
+        await commitOffsetsIfNecessary();
+      },
+    });
+  }
+}
+
+module.exports = Consumer;

package/src/producer/Producer.js

@@ -0,0 +1,69 @@
+const { serializer, logger } = require("@orbit-stream/core");
+
+class Producer {
+  constructor(kafka, config = {}) {
+    this.producer = kafka.producer({
+      allowAutoTopicCreation: true,
+
+      transactionTimeout: 30000,
+
+      maxInFlightRequests: config.maxInFlightRequests || 5,
+
+      idempotent: true,
+    });
+
+    this.connected = false;
+  }
+
+  async connect() {
+    if (this.connected) {
+      return;
+    }
+
+    await this.producer.connect();
+
+    this.connected = true;
+  }
+
+  async disconnect() {
+    if (!this.connected) {
+      return;
+    }
+
+    await this.producer.disconnect();
+
+    this.connected = false;
+  }
+
+  async publishBatch(topic, messages) {
+    const kafkaMessages = new Array(messages.length);
+
+    for (let i = 0; i < messages.length; i++) {
+      const msg = messages[i];
+
+      kafkaMessages[i] = {
+        key: msg.key,
+
+        value: serializer.serialize(msg.value),
+
+        headers: msg.headers,
+
+        timestamp: msg.timestamp ? String(msg.timestamp) : undefined,
+      };
+    }
+
+    await this.producer.send({
+      topic,
+
+      compression: 1,
+
+      acks: -1,
+
+      timeout: 30000,
+
+      messages: kafkaMessages,
+    });
+  }
+}
+
+module.exports = Producer;

package/src/utils/createKafka.js

@@ -0,0 +1,23 @@
+const { Kafka } = require("kafkajs");
+
+function createKafka(config = {}) {
+  return new Kafka({
+    clientId: config.clientId || "orbit-stream",
+
+    brokers: config.brokers || ["localhost:9092"],
+
+    ssl: config.ssl || false,
+
+    sasl: config.sasl,
+
+    retry: {
+      retries: 10,
+    },
+
+    connectionTimeout: 30000,
+
+    requestTimeout: 30000,
+  });
+}
+
+module.exports = createKafka;