kafka-ts 1.1.8 → 1.1.9

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: "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

@@ -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(),
-    }),
-});

package/dist/src/api/index.js

@@ -1,38 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.API_ERROR = exports.API = void 0;
-const api_versions_1 = require("./api-versions");
-const create_topics_1 = require("./create-topics");
-const delete_topics_1 = require("./delete-topics");
-const fetch_1 = require("./fetch");
-const find_coordinator_1 = require("./find-coordinator");
-const heartbeat_1 = require("./heartbeat");
-const init_producer_id_1 = require("./init-producer-id");
-const join_group_1 = require("./join-group");
-const leave_group_1 = require("./leave-group");
-const list_offsets_1 = require("./list-offsets");
-const metadata_1 = require("./metadata");
-const offset_commit_1 = require("./offset-commit");
-const offset_fetch_1 = require("./offset-fetch");
-const produce_1 = require("./produce");
-const sync_group_1 = require("./sync-group");
-exports.API = {
-    API_VERSIONS: api_versions_1.API_VERSIONS,
-    CREATE_TOPICS: create_topics_1.CREATE_TOPICS,
-    DELETE_TOPICS: delete_topics_1.DELETE_TOPICS,
-    FETCH: fetch_1.FETCH,
-    FIND_COORDINATOR: find_coordinator_1.FIND_COORDINATOR,
-    HEARTBEAT: heartbeat_1.HEARTBEAT,
-    INIT_PRODUCER_ID: init_producer_id_1.INIT_PRODUCER_ID,
-    JOIN_GROUP: join_group_1.JOIN_GROUP,
-    LEAVE_GROUP: leave_group_1.LEAVE_GROUP,
-    LIST_OFFSETS: list_offsets_1.LIST_OFFSETS,
-    METADATA: metadata_1.METADATA,
-    OFFSET_COMMIT: offset_commit_1.OFFSET_COMMIT,
-    OFFSET_FETCH: offset_fetch_1.OFFSET_FETCH,
-    PRODUCE: produce_1.PRODUCE,
-    SYNC_GROUP: sync_group_1.SYNC_GROUP
-};
-exports.API_ERROR = {
-    MEMBER_ID_REQUIRED: 79
-};

package/dist/src/api/init-producer-id.js

@@ -1,24 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.INIT_PRODUCER_ID = void 0;
-const api_1 = require("../utils/api");
-exports.INIT_PRODUCER_ID = (0, api_1.createApi)({
-    apiKey: 22,
-    apiVersion: 4,
-    request: (encoder, body) => encoder
-        .writeUVarInt(0)
-        .writeCompactString(body.transactionalId)
-        .writeInt32(body.transactionTimeoutMs)
-        .writeInt64(body.producerId)
-        .writeInt16(body.producerEpoch)
-        .writeUVarInt(0)
-        .value(),
-    response: (decoder) => ({
-        _tag: decoder.readTagBuffer(),
-        throttleTimeMs: decoder.readInt32(),
-        errorCode: decoder.readInt16(),
-        producerId: decoder.readInt64(),
-        producerEpoch: decoder.readInt16(),
-        _tag2: decoder.readTagBuffer(),
-    })
-});