kafka-ts 0.0.1-beta → 0.0.2-beta

package/dist/request-handler.js

@@ -1,67 +0,0 @@
-"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

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

package/dist/request-handler.test.js

@@ -1,340 +0,0 @@
-"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: "kafkats",
-    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 === "kafkats-test-topic")) {
-            await cluster.sendRequest(api_1.API.DELETE_TOPICS, {
-                topics: [{ name: "kafkats-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: "kafkats-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: "kafkats-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: "kafkats-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: ["kafkats-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: ["kafkats-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: "kafkats-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: "kafkats-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: "kafkats-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

@@ -1,18 +0,0 @@
-"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

@@ -1,46 +0,0 @@
-"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

@@ -1,26 +0,0 @@
-"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

@@ -1,95 +0,0 @@
-"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

@@ -1,34 +0,0 @@
-"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

@@ -1,22 +0,0 @@
-"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(),
-    }),
-});