kafka-ts 1.1.7 → 1.1.8

package/dist/cluster.js

@@ -28,6 +28,7 @@ class Cluster {
     async connect() {
         this.seedBroker = await this.findSeedBroker();
         this.brokerById = {};
+        await this.refreshBrokerMetadata();
     }
     async disconnect() {
         await Promise.all([

package/dist/consumer/metadata.d.ts

@@ -0,0 +1,24 @@
+import { IsolationLevel } from "../api/fetch";
+import { Assignment } from "../api/sync-group";
+import { Cluster } from "../cluster";
+import { OffsetManager } from "./offset-manager";
+export type Metadata = ReturnType<typeof createMetadata>;
+type MetadataOptions = {
+    cluster: Cluster;
+    topics?: string[];
+    isolationLevel?: IsolationLevel;
+    allowTopicAutoCreation?: boolean;
+    fromBeginning?: boolean;
+    offsetManager?: OffsetManager;
+};
+export declare const createMetadata: ({ cluster, topics, isolationLevel, allowTopicAutoCreation, fromBeginning, offsetManager, }: MetadataOptions) => {
+    init: () => Promise<void>;
+    getTopicPartitions: () => Record<string, number[]>;
+    getTopicIdByName: (name: string) => string;
+    getTopicNameById: (id: string) => string;
+    getAssignment: () => Assignment;
+    setAssignment: (newAssignment: Assignment) => void;
+    getLeaderIdByTopicPartition: (topic: string, partition: number) => number;
+    getIsrNodeIdsByTopicPartition: (topic: string, partition: number) => number[];
+};
+export {};

package/dist/consumer/metadata.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createMetadata = void 0;
+const api_1 = require("../api");
+const createMetadata = ({ cluster, topics, isolationLevel = 0 /* IsolationLevel.READ_UNCOMMITTED */, allowTopicAutoCreation = true, fromBeginning = false, offsetManager, }) => {
+    let topicPartitions = {};
+    let topicNameById = {};
+    let topicIdByName = {};
+    let leaderIdByTopicPartition = {};
+    let isrNodesByTopicPartition;
+    let assignment = {};
+    const fetchMetadata = async () => {
+        const response = await cluster.sendRequest(api_1.API.METADATA, {
+            allowTopicAutoCreation,
+            includeTopicAuthorizedOperations: false,
+            topics: topics?.map((name) => ({ id: null, name })) ?? null,
+        });
+        topicPartitions = Object.fromEntries(response.topics.map((topic) => [topic.name, topic.partitions.map((partition) => partition.partitionIndex)]));
+        topicNameById = Object.fromEntries(response.topics.map((topic) => [topic.topicId, topic.name]));
+        topicIdByName = Object.fromEntries(response.topics.map((topic) => [topic.name, topic.topicId]));
+        leaderIdByTopicPartition = Object.fromEntries(response.topics.map((topic) => [
+            topic.name,
+            Object.fromEntries(topic.partitions.map((partition) => [partition.partitionIndex, partition.leaderId])),
+        ]));
+        isrNodesByTopicPartition = Object.fromEntries(response.topics.map((topic) => [
+            topic.name,
+            Object.fromEntries(topic.partitions.map((partition) => [partition.partitionIndex, partition.isrNodes])),
+        ]));
+        assignment = topicPartitions;
+    };
+    const listOffsets = async () => {
+        const offsets = await cluster.sendRequest(api_1.API.LIST_OFFSETS, {
+            replicaId: -1,
+            isolationLevel,
+            topics: Object.entries(assignment)
+                .flatMap(([topic, partitions]) => partitions.map((partition) => ({ topic, partition })))
+                .map(({ topic, partition }) => ({
+                name: topic,
+                partitions: [{ partitionIndex: partition, currentLeaderEpoch: -1, timestamp: -1n }],
+            })),
+        });
+        offsets.topics.forEach(({ name, partitions }) => {
+            partitions.forEach(({ partitionIndex, offset }) => {
+                offsetManager?.resolve(name, partitionIndex, fromBeginning ? 0n : offset);
+            });
+        });
+    };
+    return {
+        init: async () => {
+            await fetchMetadata();
+            await listOffsets();
+        },
+        getTopicPartitions: () => topicPartitions,
+        getTopicIdByName: (name) => topicIdByName[name],
+        getTopicNameById: (id) => topicNameById[id],
+        getAssignment: () => assignment,
+        setAssignment: (newAssignment) => {
+            assignment = newAssignment;
+        },
+        getLeaderIdByTopicPartition: (topic, partition) => leaderIdByTopicPartition[topic][partition],
+        getIsrNodeIdsByTopicPartition: (topic, partition) => isrNodesByTopicPartition[topic][partition],
+    };
+};
+exports.createMetadata = createMetadata;

package/dist/examples/src/replicator.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const kafkats_1 = require("kafkats");
+const json_1 = require("./utils/json");
+(async () => {
+    const brokers = [{ host: "localhost", port: 9092 }];
+    const topic = "playground-topic";
+    // const producer = createProducer({ brokers });
+    // const producerInterval = setInterval(async () => {
+    //     await producer.send([
+    //         {
+    //             topic,
+    //             partition: 0,
+    //             offset: 1n,
+    //             timestamp: BigInt(Date.now()),
+    //             key: null,
+    //             value: `PING ${Math.random()}`,
+    //             headers: { timestamp: Date.now().toString() }
+    //         }
+    //     ])
+    // }, 5000);
+    const consumer = await (0, kafkats_1.startConsumer)({
+        topics: [topic],
+        brokers,
+        onBatch: (messages) => {
+            console.log(JSON.stringify(messages, json_1.serializer, 2));
+        },
+    });
+    process.on("SIGINT", async () => {
+        await consumer.close();
+        // clearInterval(producerInterval);
+        // await producer.close();
+    });
+})();

package/dist/examples/src/utils/json.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.serializer = void 0;
+const serializer = (_, value) => (typeof value === "bigint" ? value.toString() : value);
+exports.serializer = serializer;

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