kafka-ts 0.0.1-beta

package/dist/api/fetch.js

@@ -0,0 +1,106 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FETCH = void 0;
+const api_1 = require("../utils/api");
+const error_1 = require("../utils/error");
+exports.FETCH = (0, api_1.createApi)({
+    apiKey: 1,
+    apiVersion: 16,
+    request: (encoder, data) => encoder
+        .writeUVarInt(0)
+        .writeInt32(data.maxWaitMs)
+        .writeInt32(data.minBytes)
+        .writeInt32(data.maxBytes)
+        .writeInt8(data.isolationLevel)
+        .writeInt32(data.sessionId)
+        .writeInt32(data.sessionEpoch)
+        .writeCompactArray(data.topics, (encoder, topic) => encoder
+        .writeUUID(topic.topicId)
+        .writeCompactArray(topic.partitions, (encoder, partition) => encoder
+        .writeInt32(partition.partition)
+        .writeInt32(partition.currentLeaderEpoch)
+        .writeInt64(partition.fetchOffset)
+        .writeInt32(partition.lastFetchedEpoch)
+        .writeInt64(partition.logStartOffset)
+        .writeInt32(partition.partitionMaxBytes)
+        .writeUVarInt(0))
+        .writeUVarInt(0))
+        .writeCompactArray(data.forgottenTopicsData, (encoder, forgottenTopic) => encoder
+        .writeUUID(forgottenTopic.topicId)
+        .writeCompactArray(forgottenTopic.partitions, (encoder, partition) => encoder.writeInt32(partition))
+        .writeUVarInt(0))
+        .writeCompactString(data.rackId)
+        .writeUVarInt(0),
+    response: (decoder) => {
+        const result = {
+            _tag: decoder.readTagBuffer(),
+            throttleTimeMs: decoder.readInt32(),
+            errorCode: decoder.readInt16(),
+            sessionId: decoder.readInt32(),
+            responses: decoder.readCompactArray((response) => ({
+                topicId: response.readUUID(),
+                partitions: response.readCompactArray((partition) => ({
+                    partitionIndex: partition.readInt32(),
+                    errorCode: partition.readInt16(),
+                    highWatermark: partition.readInt64(),
+                    lastStableOffset: partition.readInt64(),
+                    logStartOffset: partition.readInt64(),
+                    abortedTransactions: partition.readCompactArray((abortedTransaction) => ({
+                        producerId: abortedTransaction.readInt64(),
+                        firstOffset: abortedTransaction.readInt64(),
+                        _tag: abortedTransaction.readTagBuffer(),
+                    })),
+                    preferredReadReplica: partition.readInt32(),
+                    records: decodeRecords(partition),
+                    _tag: partition.readTagBuffer(),
+                })),
+                _tag: response.readTagBuffer(),
+            })),
+            _tag2: decoder.readTagBuffer(),
+        };
+        if (result.errorCode)
+            throw new error_1.KafkaTSApiError(result.errorCode, null, result);
+        result.responses.forEach((response) => {
+            response.partitions.forEach((partition) => {
+                if (partition.errorCode)
+                    throw new error_1.KafkaTSApiError(partition.errorCode, null, result);
+            });
+        });
+        return result;
+    },
+});
+const decodeRecords = (decoder) => {
+    const size = decoder.readUVarInt() - 1;
+    if (size <= 0) {
+        return [];
+    }
+    const results = [];
+    while (decoder.getBufferLength() > decoder.getOffset() + 49) {
+        results.push({
+            baseOffset: decoder.readInt64(),
+            batchLength: decoder.readInt32(),
+            partitionLeaderEpoch: decoder.readInt32(),
+            magic: decoder.readInt8(),
+            crc: decoder.readUInt32(),
+            attributes: decoder.readInt16(),
+            lastOffsetDelta: decoder.readInt32(),
+            baseTimestamp: decoder.readInt64(),
+            maxTimestamp: decoder.readInt64(),
+            producerId: decoder.readInt64(),
+            producerEpoch: decoder.readInt16(),
+            baseSequence: decoder.readInt32(),
+            records: decoder.readRecords((record) => ({
+                attributes: record.readInt8(),
+                timestampDelta: record.readVarLong(),
+                offsetDelta: record.readVarInt(),
+                key: record.readVarIntString(),
+                value: record.readVarIntString(),
+                headers: record.readCompactArray((header) => ({
+                    key: header.readVarIntString(),
+                    value: header.readVarIntString(),
+                })),
+            })),
+        });
+    }
+    return results;
+};

package/dist/api/find-coordinator.d.ts

@@ -0,0 +1,21 @@
+export declare const KEY_TYPE: {
+    GROUP: number;
+    TRANSACTION: number;
+};
+export declare const FIND_COORDINATOR: import("../utils/api").Api<{
+    keyType: number;
+    keys: string[];
+}, {
+    _tag: void;
+    throttleTimeMs: number;
+    coordinators: {
+        key: string | null;
+        nodeId: number;
+        host: string;
+        port: number;
+        errorCode: number;
+        errorMessage: string | null;
+        _tag: void;
+    }[];
+    _tag2: void;
+}>;

package/dist/api/find-coordinator.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FIND_COORDINATOR = exports.KEY_TYPE = void 0;
+const api_1 = require("../utils/api");
+const error_1 = require("../utils/error");
+exports.KEY_TYPE = {
+    GROUP: 0,
+    TRANSACTION: 1,
+};
+exports.FIND_COORDINATOR = (0, api_1.createApi)({
+    apiKey: 10,
+    apiVersion: 4,
+    request: (encoder, data) => encoder
+        .writeUVarInt(0)
+        .writeInt8(data.keyType)
+        .writeCompactArray(data.keys, (encoder, key) => encoder.writeCompactString(key))
+        .writeUVarInt(0),
+    response: (decoder) => {
+        const result = {
+            _tag: decoder.readTagBuffer(),
+            throttleTimeMs: decoder.readInt32(),
+            coordinators: decoder.readCompactArray((decoder) => ({
+                key: decoder.readCompactString(),
+                nodeId: decoder.readInt32(),
+                host: decoder.readCompactString(),
+                port: decoder.readInt32(),
+                errorCode: decoder.readInt16(),
+                errorMessage: decoder.readCompactString(),
+                _tag: decoder.readTagBuffer(),
+            })),
+            _tag2: decoder.readTagBuffer(),
+        };
+        result.coordinators.forEach((coordinator) => {
+            if (coordinator.errorCode)
+                throw new error_1.KafkaTSApiError(coordinator.errorCode, coordinator.errorMessage, result);
+        });
+        return result;
+    },
+});

package/dist/api/heartbeat.d.ts

@@ -0,0 +1,11 @@
+export declare const HEARTBEAT: import("../utils/api").Api<{
+    groupId: string;
+    generationId: number;
+    memberId: string;
+    groupInstanceId: string | null;
+}, {
+    _tag: void;
+    throttleTimeMs: number;
+    errorCode: number;
+    _tag2: void;
+}>;

package/dist/api/heartbeat.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HEARTBEAT = void 0;
+const api_1 = require("../utils/api");
+const error_1 = require("../utils/error");
+exports.HEARTBEAT = (0, api_1.createApi)({
+    apiKey: 12,
+    apiVersion: 4,
+    request: (encoder, data) => encoder
+        .writeUVarInt(0)
+        .writeCompactString(data.groupId)
+        .writeInt32(data.generationId)
+        .writeCompactString(data.memberId)
+        .writeCompactString(data.groupInstanceId)
+        .writeUVarInt(0),
+    response: (decoder) => {
+        const result = {
+            _tag: decoder.readTagBuffer(),
+            throttleTimeMs: decoder.readInt32(),
+            errorCode: decoder.readInt16(),
+            _tag2: decoder.readTagBuffer(),
+        };
+        if (result.errorCode)
+            throw new error_1.KafkaTSApiError(result.errorCode, null, result);
+        return result;
+    },
+});