kafka-ts 1.1.6 → 1.1.8

package/dist/request-handler.d.ts

@@ -0,0 +1,16 @@
+import { Connection } from "./connection";
+import { Api } from "./utils/api";
+type RequestHandlerOptions = {
+    clientId: string | null;
+};
+export declare class RequestHandler {
+    private connection;
+    private options;
+    private queue;
+    private currentBuffer;
+    constructor(connection: Connection, options: RequestHandlerOptions);
+    private handleData;
+    sendRequest<Request, Response>(api: Api<Request, Response>, args: Request): Promise<Response>;
+}
+export type SendRequest = typeof RequestHandler.prototype.sendRequest;
+export {};

package/dist/request-handler.js

@@ -0,0 +1,67 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RequestHandler = void 0;
+const node_assert_1 = __importDefault(require("node:assert"));
+const decoder_1 = require("./utils/decoder");
+const encoder_1 = require("./utils/encoder");
+class RequestHandler {
+    connection;
+    options;
+    queue = {};
+    currentBuffer = null;
+    constructor(connection, options) {
+        this.connection = connection;
+        this.options = options;
+        this.connection.on("data", this.handleData);
+    }
+    handleData(buffer) {
+        this.currentBuffer = this.currentBuffer ? Buffer.concat([this.currentBuffer, buffer]) : buffer;
+        if (this.currentBuffer.length < 4) {
+            return;
+        }
+        const decoder = (0, decoder_1.createDecoder)({ buffer: this.currentBuffer });
+        const size = decoder.readInt32();
+        if (size > decoder.buffer.length) {
+            return;
+        }
+        const correlationId = decoder.readInt32();
+        const request = this.queue[correlationId];
+        delete this.queue[correlationId];
+        request.callback(decoder);
+        // debug(handleData.name, 'Response offsets', {
+        //     offset: decoder.offset,
+        //     length: decoder.buffer.length,
+        //     rest: decoder.buffer.subarray(decoder.offset, decoder.buffer.length)?.toString(),
+        // });
+        (0, node_assert_1.default)(decoder.offset - 4 === size, `Buffer not correctly consumed: ${decoder.offset - 4} !== ${buffer.length}`);
+        this.currentBuffer = null;
+    }
+    async sendRequest(api, args) {
+        const correlationId = Math.floor(Math.random() * 1000000);
+        const encoder = (0, encoder_1.createEncoder)()
+            .writeInt16(api.apiKey)
+            .writeInt16(api.apiVersion)
+            .writeInt32(correlationId)
+            .writeString(this.options.clientId);
+        const request = api.request(encoder, args).value();
+        const buffer = (0, encoder_1.createEncoder)().writeInt32(request.length).write(request).value();
+        return new Promise(async (resolve, reject) => {
+            await this.connection.write(buffer);
+            this.queue[correlationId] = {
+                callback: (decoder) => {
+                    try {
+                        const response = api.response(decoder);
+                        resolve(response);
+                    }
+                    catch (error) {
+                        reject(error);
+                    }
+                },
+            };
+        });
+    }
+}
+exports.RequestHandler = RequestHandler;

package/dist/request-handler.test.d.ts

@@ -0,0 +1 @@
+export declare const kafka: import("./client").Client;

package/dist/request-handler.test.js

@@ -0,0 +1,340 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.kafka = void 0;
+const crypto_1 = require("crypto");
+const fs_1 = require("fs");
+const vitest_1 = require("vitest");
+const api_1 = require("./api");
+const find_coordinator_1 = require("./api/find-coordinator");
+const client_1 = require("./client");
+exports.kafka = (0, client_1.createKafkaClient)({
+    clientId: "kafka-ts",
+    bootstrapServers: [{ host: "localhost", port: 9092 }],
+    sasl: { mechanism: "PLAIN", username: "admin", password: "admin" },
+    ssl: { ca: (0, fs_1.readFileSync)("./certs/ca.crt").toString() },
+});
+vitest_1.describe.sequential("Request handler", () => {
+    const groupId = (0, crypto_1.randomBytes)(16).toString("hex");
+    let cluster;
+    (0, vitest_1.beforeAll)(async () => {
+        cluster = await exports.kafka.createCluster().connect();
+        const metadataResult = await cluster.sendRequest(api_1.API.METADATA, {
+            topics: null,
+            allowTopicAutoCreation: false,
+            includeTopicAuthorizedOperations: false,
+        });
+        if (metadataResult.topics.some((topic) => topic.name === "kafka-ts-test-topic")) {
+            await cluster.sendRequest(api_1.API.DELETE_TOPICS, {
+                topics: [{ name: "kafka-ts-test-topic", topicId: null }],
+                timeoutMs: 10000,
+            });
+        }
+    });
+    (0, vitest_1.afterAll)(async () => {
+        await cluster.disconnect();
+    });
+    (0, vitest_1.it)("should request api versions", async () => {
+        const result = await cluster.sendRequest(api_1.API.API_VERSIONS, {});
+        (0, vitest_1.expect)(result).toMatchSnapshot();
+    });
+    let topicId = "d6718d178e1b47c886441ad2d19faea5";
+    (0, vitest_1.it)("should create topics", async () => {
+        const result = await cluster.sendRequest(api_1.API.CREATE_TOPICS, {
+            topics: [
+                {
+                    name: "kafka-ts-test-topic",
+                    numPartitions: 1,
+                    replicationFactor: 1,
+                    assignments: [],
+                    configs: [],
+                },
+            ],
+            timeoutMs: 10000,
+            validateOnly: false,
+        });
+        topicId = result.topics[0].topicId;
+        result.topics.forEach((topic) => {
+            topic.topicId = "Any<UUID>";
+        });
+        (0, vitest_1.expect)(result).toMatchSnapshot();
+        await new Promise((resolve) => setTimeout(resolve, 1000));
+    });
+    (0, vitest_1.it)("should request metadata for all topics", async () => {
+        const result = await cluster.sendRequest(api_1.API.METADATA, {
+            topics: null,
+            allowTopicAutoCreation: false,
+            includeTopicAuthorizedOperations: false,
+        });
+        result.controllerId = 0;
+        result.topics.forEach((topic) => {
+            topic.topicId = "Any<UUID>";
+            topic.partitions.forEach((partition) => {
+                partition.leaderId = 0;
+                partition.isrNodes = [0];
+                partition.replicaNodes = [0];
+            });
+        });
+        (0, vitest_1.expect)(result).toMatchSnapshot();
+    });
+    let leaderId = 0;
+    (0, vitest_1.it)("should request metadata for a topic", async () => {
+        const result = await cluster.sendRequest(api_1.API.METADATA, {
+            topics: [{ id: topicId, name: "kafka-ts-test-topic" }],
+            allowTopicAutoCreation: false,
+            includeTopicAuthorizedOperations: false,
+        });
+        leaderId = result.topics[0].partitions[0].leaderId;
+        result.controllerId = 0;
+        result.topics.forEach((topic) => {
+            topic.topicId = "Any<UUID>";
+            topic.partitions.forEach((partition) => {
+                partition.leaderId = 0;
+                partition.isrNodes = [0];
+                partition.replicaNodes = [0];
+            });
+        });
+        (0, vitest_1.expect)(result).toMatchSnapshot();
+    });
+    (0, vitest_1.it)("should init producer id", async () => {
+        const result = await cluster.sendRequest(api_1.API.INIT_PRODUCER_ID, {
+            transactionalId: null,
+            transactionTimeoutMs: 0,
+            producerId: 0n,
+            producerEpoch: 0,
+        });
+        result.producerId = 0n;
+        (0, vitest_1.expect)(result).toMatchSnapshot();
+    });
+    (0, vitest_1.it)("should produce messages", async () => {
+        const now = Date.now();
+        const result = await cluster.sendRequestToNode(leaderId)(api_1.API.PRODUCE, {
+            transactionalId: null,
+            timeoutMs: 10000,
+            acks: 1,
+            topicData: [
+                {
+                    name: "kafka-ts-test-topic",
+                    partitionData: [
+                        {
+                            index: 0,
+                            baseOffset: 0n,
+                            partitionLeaderEpoch: 0,
+                            attributes: 0,
+                            baseSequence: 0,
+                            baseTimestamp: BigInt(now),
+                            lastOffsetDelta: 0,
+                            maxTimestamp: BigInt(now),
+                            producerEpoch: 0,
+                            producerId: 9n,
+                            records: [
+                                {
+                                    attributes: 0,
+                                    offsetDelta: 0,
+                                    timestampDelta: 0n,
+                                    key: "key",
+                                    value: "value",
+                                    headers: [
+                                        {
+                                            key: "header-key",
+                                            value: "header-value",
+                                        },
+                                    ],
+                                },
+                            ],
+                        },
+                    ],
+                },
+            ],
+        });
+        (0, vitest_1.expect)(result).toMatchSnapshot();
+    });
+    (0, vitest_1.it)("should fetch messages", async () => {
+        const result = await cluster.sendRequestToNode(leaderId)(api_1.API.FETCH, {
+            maxWaitMs: 100,
+            minBytes: 1,
+            maxBytes: 10485760,
+            isolationLevel: 1,
+            sessionId: 0,
+            sessionEpoch: -1,
+            topics: [
+                {
+                    topicId,
+                    partitions: [
+                        {
+                            partition: 0,
+                            currentLeaderEpoch: -1,
+                            fetchOffset: 0n,
+                            lastFetchedEpoch: 0,
+                            logStartOffset: -1n,
+                            partitionMaxBytes: 10485760,
+                        },
+                    ],
+                },
+            ],
+            forgottenTopicsData: [],
+            rackId: "",
+        });
+        result.responses.forEach((response) => {
+            response.topicId = "Any<UUID>";
+            response.partitions.forEach((partition) => {
+                partition.records.forEach((record) => {
+                    (0, vitest_1.expect)(record.baseTimestamp).toBeGreaterThan(1721926744730n);
+                    (0, vitest_1.expect)(record.maxTimestamp).toBeGreaterThan(1721926744730n);
+                    (0, vitest_1.expect)(record.crc).toBeGreaterThan(0);
+                    record.baseTimestamp = 0n;
+                    record.maxTimestamp = 0n;
+                    record.crc = 0;
+                });
+            });
+        });
+        (0, vitest_1.expect)(result).toMatchSnapshot();
+    });
+    let coordinatorId = -1;
+    (0, vitest_1.it)("should find coordinator", async () => {
+        const result = await cluster.sendRequest(api_1.API.FIND_COORDINATOR, { keyType: find_coordinator_1.KEY_TYPE.GROUP, keys: [groupId] });
+        result.coordinators.forEach((coordinator) => {
+            coordinator.key = "Any<String>";
+        });
+        coordinatorId = result.coordinators[0].nodeId;
+        result.coordinators.forEach((coordinator) => {
+            coordinator.nodeId = 1;
+            coordinator.port = 9093;
+        });
+        (0, vitest_1.expect)(result).toMatchSnapshot();
+    });
+    let memberId = "";
+    (0, vitest_1.it)("should fail join group request with new memberId", async () => {
+        try {
+            const result = await cluster.sendRequestToNode(coordinatorId)(api_1.API.JOIN_GROUP, {
+                groupId,
+                sessionTimeoutMs: 30000,
+                rebalanceTimeoutMs: 60000,
+                memberId,
+                groupInstanceId: null,
+                protocolType: "consumer",
+                protocols: [
+                    {
+                        name: "RoundRobinAssigner",
+                        metadata: { version: 0, topics: ["kafka-ts-test-topic"] },
+                    },
+                ],
+                reason: null,
+            });
+            (0, vitest_1.expect)(false, "Should throw an error").toBe(true);
+        }
+        catch (error) {
+            const { response } = error;
+            memberId = response.memberId;
+            response.memberId = "Any<UUID>";
+            (0, vitest_1.expect)(response).toMatchSnapshot();
+        }
+    });
+    (0, vitest_1.it)("should join group", async () => {
+        const result = await cluster.sendRequestToNode(coordinatorId)(api_1.API.JOIN_GROUP, {
+            groupId,
+            sessionTimeoutMs: 30000,
+            rebalanceTimeoutMs: 60000,
+            memberId,
+            groupInstanceId: null,
+            protocolType: "consumer",
+            protocols: [
+                {
+                    name: "RoundRobinAssigner",
+                    metadata: { version: 0, topics: ["kafka-ts-test-topic"] },
+                },
+            ],
+            reason: null,
+        });
+        result.memberId = "Any<UUID>";
+        result.leader = "Any<UUID>";
+        result.members.forEach((member) => {
+            member.memberId = "Any<UUID>";
+        });
+        (0, vitest_1.expect)(result).toMatchSnapshot();
+    });
+    (0, vitest_1.it)("should sync group", async () => {
+        const result = await cluster.sendRequestToNode(coordinatorId)(api_1.API.SYNC_GROUP, {
+            groupId,
+            generationId: 1,
+            memberId,
+            groupInstanceId: null,
+            protocolType: "consumer",
+            protocolName: "RoundRobinAssigner",
+            assignments: [
+                {
+                    memberId,
+                    assignment: { "kafka-test-topic": [0] },
+                },
+            ],
+        });
+        (0, vitest_1.expect)(result).toMatchSnapshot();
+    });
+    (0, vitest_1.it)("should commit offsets", async () => {
+        const result = await cluster.sendRequestToNode(coordinatorId)(api_1.API.OFFSET_COMMIT, {
+            groupId,
+            generationIdOrMemberEpoch: 1,
+            memberId,
+            groupInstanceId: null,
+            topics: [
+                {
+                    name: "kafka-ts-test-topic",
+                    partitions: [
+                        { partitionIndex: 0, committedOffset: 1n, committedLeaderEpoch: 0, committedMetadata: null },
+                    ],
+                },
+            ],
+        });
+        (0, vitest_1.expect)(result).toMatchSnapshot();
+    });
+    (0, vitest_1.it)("should fetch offsets", async () => {
+        const result = await cluster.sendRequestToNode(coordinatorId)(api_1.API.OFFSET_FETCH, {
+            groups: [
+                {
+                    groupId,
+                    memberId,
+                    memberEpoch: 0,
+                    topics: [
+                        {
+                            name: "kafka-ts-test-topic",
+                            partitionIndexes: [0],
+                        },
+                    ],
+                },
+            ],
+            requireStable: false,
+        });
+        result.groups.forEach((group) => {
+            group.groupId = "Any<String>";
+        });
+        (0, vitest_1.expect)(result).toMatchSnapshot();
+    });
+    (0, vitest_1.it)("should heartbeat", async () => {
+        const result = await cluster.sendRequestToNode(coordinatorId)(api_1.API.HEARTBEAT, {
+            groupId,
+            generationId: 1,
+            memberId,
+            groupInstanceId: null,
+        });
+        (0, vitest_1.expect)(result).toMatchSnapshot();
+    });
+    (0, vitest_1.it)("should leave group", async () => {
+        const result = await cluster.sendRequestToNode(coordinatorId)(api_1.API.LEAVE_GROUP, {
+            groupId,
+            members: [{ memberId, groupInstanceId: null, reason: null }],
+        });
+        result.members.forEach((member) => {
+            member.memberId = "Any<UUID>";
+        });
+        (0, vitest_1.expect)(result).toMatchSnapshot();
+    });
+    (0, vitest_1.it)("should delete topics", async () => {
+        const result = await cluster.sendRequest(api_1.API.DELETE_TOPICS, {
+            topics: [{ name: "kafka-ts-test-topic", topicId: null }],
+            timeoutMs: 10000,
+        });
+        result.responses.forEach((response) => {
+            response.topicId = "Any<UUID>";
+        });
+        (0, vitest_1.expect)(result).toMatchSnapshot();
+    });
+});

package/dist/src/api/api-versions.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.API_VERSIONS = void 0;
+const api_js_1 = require("../utils/api.js");
+exports.API_VERSIONS = (0, api_js_1.createApi)({
+    apiKey: 18,
+    apiVersion: 2,
+    request: (encoder) => encoder.value(),
+    response: (decoder) => ({
+        errorCode: decoder.readInt16(),
+        versions: decoder.readArray((version) => ({
+            apiKey: version.readInt16(),
+            minVersion: version.readInt16(),
+            maxVersion: version.readInt16(),
+        })),
+        throttleTimeMs: decoder.readInt32(),
+    }),
+});

package/dist/src/api/create-topics.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CREATE_TOPICS = void 0;
+const api_1 = require("../utils/api");
+exports.CREATE_TOPICS = (0, api_1.createApi)({
+    apiKey: 19,
+    apiVersion: 7,
+    request: (encoder, data) => encoder
+        .writeUVarInt(0)
+        .writeCompactArray(data.topics, (encoder, topic) => encoder
+        .writeCompactString(topic.name)
+        .writeInt32(topic.numPartitions)
+        .writeInt16(topic.replicationFactor)
+        .writeCompactArray(topic.assignments, (encoder, assignment) => encoder
+        .writeInt32(assignment.partitionIndex)
+        .writeCompactArray(assignment.brokerIds, (encoder, brokerId) => encoder.writeInt32(brokerId))
+        .writeUVarInt(0))
+        .writeCompactArray(topic.configs, (encoder, config) => encoder.writeCompactString(config.name).writeCompactString(config.value).writeUVarInt(0))
+        .writeUVarInt(0))
+        .writeInt32(data.timeoutMs)
+        .writeBoolean(data.validateOnly)
+        .writeUVarInt(0)
+        .value(),
+    response: (decoder) => ({
+        _tag: decoder.readTagBuffer(),
+        throttleTimeMs: decoder.readInt32(),
+        topics: decoder.readCompactArray((topic) => ({
+            name: topic.readCompactString(),
+            topicId: topic.readUUID(),
+            errorCode: topic.readInt16(),
+            errorMessage: topic.readCompactString(),
+            numPartitions: topic.readInt32(),
+            replicationFactor: topic.readInt16(),
+            configs: topic.readCompactArray((config) => ({
+                name: config.readCompactString(),
+                value: config.readCompactString(),
+                readOnly: config.readBoolean(),
+                configSource: config.readInt8(),
+                isSensitive: config.readBoolean(),
+                _tag: config.readTagBuffer(),
+            })),
+            _tag: topic.readTagBuffer(),
+        })),
+        _tag2: decoder.readTagBuffer(),
+    }),
+});

package/dist/src/api/delete-topics.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DELETE_TOPICS = void 0;
+const api_1 = require("../utils/api");
+exports.DELETE_TOPICS = (0, api_1.createApi)({
+    apiKey: 20,
+    apiVersion: 6,
+    request: (encoder, data) => encoder
+        .writeUVarInt(0)
+        .writeCompactArray(data.topics, (encoder, topic) => encoder.writeCompactString(topic.name).writeUUID(topic.topicId).writeUVarInt(0))
+        .writeInt32(data.timeoutMs)
+        .writeUVarInt(0)
+        .value(),
+    response: (decoder) => ({
+        _tag: decoder.readTagBuffer(),
+        throttleTimeMs: decoder.readInt32(),
+        responses: decoder.readCompactArray((decoder) => ({
+            name: decoder.readCompactString(),
+            topicId: decoder.readUUID(),
+            errorCode: decoder.readInt16(),
+            errorMessage: decoder.readCompactString(),
+            _tag: decoder.readTagBuffer(),
+        })),
+        _tag2: decoder.readTagBuffer(),
+    }),
+});

package/dist/src/api/fetch.js

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FETCH = void 0;
+const api_1 = require("../utils/api");
+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)
+        .value(),
+    response: (decoder) => ({
+        _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(),
+    }),
+});
+const decodeRecords = (decoder) => {
+    const size = decoder.readUVarInt() - 1;
+    if (size <= 0) {
+        return [];
+    }
+    const results = [];
+    while (decoder.buffer.length > decoder.offset + 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.read(Math.ceil((record.readVarInt() - 1) / 2))?.toString() || null,
+                value: record.read(Math.ceil((record.readVarInt() - 1) / 2))?.toString() || null,
+                headers: record.readCompactArray((header) => ({
+                    key: header.read(Math.ceil((header.readVarInt() - 1) / 2))?.toString(),
+                    value: header.read(Math.ceil((header.readVarInt() - 1) / 2))?.toString(),
+                })),
+            })),
+        });
+    }
+    return results;
+};

package/dist/src/api/find-coordinator.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FIND_COORDINATOR = exports.KEY_TYPE = void 0;
+const api_1 = require("../utils/api");
+exports.KEY_TYPE = {
+    GROUP: 0,
+    TRANSACTION: 1,
+};
+exports.FIND_COORDINATOR = (0, api_1.createApi)({
+    apiKey: 10,
+    apiVersion: 4,
+    request: (encoder, data) => {
+        return encoder
+            .writeUVarInt(0)
+            .writeInt8(data.keyType)
+            .writeCompactArray(data.keys, (encoder, key) => encoder.writeCompactString(key))
+            .writeUVarInt(0)
+            .value();
+    },
+    response: (decoder) => ({
+        _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(),
+    }),
+});

package/dist/src/api/heartbeat.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HEARTBEAT = void 0;
+const api_1 = require("../utils/api");
+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)
+        .value(),
+    response: (decoder) => ({
+        _tag: decoder.readTagBuffer(),
+        throttleTimeMs: decoder.readInt32(),
+        errorCode: decoder.readInt16(),
+        _tag2: decoder.readTagBuffer(),
+    }),
+});