kafka-ts 0.0.1-beta

package/dist/src/consumer/consumer.js

@@ -0,0 +1,103 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startConsumer = void 0;
+const fetch_1 = require("../api/fetch");
+const broker_1 = require("../broker");
+const consumer_group_1 = require("./consumer-group");
+const metadata_1 = require("./metadata");
+const offset_manager_1 = require("./offset-manager");
+const startConsumer = async ({ brokers, clientId = null, groupId, topics, groupInstanceId = null, rackId = "", isolationLevel = 0 /* IsolationLevel.READ_UNCOMMITTED */, sessionTimeoutMs = 30_000, rebalanceTimeoutMs = 60_000, maxWaitMs = 5000, minBytes = 1, maxBytes = 1_000_000, partitionMaxBytes = 1_000_000, allowTopicAutoCreation = true, fromBeginning = false, ...options }) => {
+    let coordinator = await (0, broker_1.connectBroker)({ clientId, options: brokers[0] });
+    let stopHook;
+    const offsetManager = (0, offset_manager_1.createOffsetManager)();
+    const metadata = (0, metadata_1.createMetadata)({
+        topics,
+        isolationLevel,
+        allowTopicAutoCreation,
+        fromBeginning,
+        coordinator,
+        offsetManager,
+    });
+    const consumerGroup = groupId
+        ? (0, consumer_group_1.createConsumerGroup)({
+            topics,
+            groupId,
+            groupInstanceId,
+            sessionTimeoutMs,
+            rebalanceTimeoutMs,
+            coordinator,
+            metadata,
+            offsetManager,
+        })
+        : undefined;
+    const fetch = async () => {
+        const response = await coordinator.sendRequest(fetch_1.FETCH, {
+            maxWaitMs,
+            minBytes,
+            maxBytes,
+            isolationLevel,
+            sessionId: 0,
+            sessionEpoch: -1,
+            topics: Object.entries(metadata.getAssignment())
+                .flatMap(([topic, partitions]) => partitions.map((partition) => ({ topic, partition })))
+                .map(({ topic, partition }) => ({
+                topicId: metadata.getTopicIdByName(topic),
+                partitions: [
+                    {
+                        partition,
+                        currentLeaderEpoch: -1,
+                        fetchOffset: offsetManager.getCurrentOffset(topic, partition),
+                        lastFetchedEpoch: -1,
+                        logStartOffset: 0n,
+                        partitionMaxBytes,
+                    },
+                ],
+            })),
+            forgottenTopicsData: [],
+            rackId,
+        });
+        return response;
+    };
+    const fetchLoop = async () => {
+        while (!stopHook) {
+            const batch = await fetch();
+            const messages = batch.responses.flatMap(({ topicId, partitions }) => partitions.flatMap(({ partitionIndex, records }) => records.flatMap(({ baseTimestamp, baseOffset, records }) => records.map((message) => ({
+                topic: metadata.getTopicNameById(topicId),
+                partition: partitionIndex,
+                key: message.key ?? null,
+                value: message.value ?? null,
+                headers: Object.fromEntries(message.headers.map(({ key, value }) => [key, value])),
+                timestamp: baseTimestamp + BigInt(message.timestampDelta),
+                offset: baseOffset + BigInt(message.offsetDelta),
+            })))));
+            // TODO: Implement exponential backoff
+            try {
+                if ("onBatch" in options) {
+                    await options.onBatch(messages);
+                }
+                else if ("onMessage" in options) {
+                    for (const message of messages) {
+                        await options.onMessage(message);
+                    }
+                }
+            }
+            catch (error) {
+                console.error(error);
+                continue;
+            }
+            messages.forEach(({ topic, partition, offset }) => offsetManager.resolve(topic, partition, offset));
+            await consumerGroup?.commit();
+        }
+        stopHook();
+    };
+    const close = async () => {
+        await new Promise((resolve) => (stopHook = resolve));
+        await consumerGroup?.leave();
+        await coordinator.disconnect();
+    };
+    await metadata.init();
+    await consumerGroup?.join();
+    fetchLoop();
+    return { close };
+};
+exports.startConsumer = startConsumer;

package/dist/src/consumer/metadata.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createMetadata = void 0;
+const api_1 = require("../api");
+const createMetadata = ({ topics, isolationLevel, allowTopicAutoCreation, fromBeginning, coordinator, offsetManager, }) => {
+    let topicPartitions = {};
+    let topicNameById = {};
+    let topicIdByName = {};
+    let assignment = {};
+    const fetchMetadata = async () => {
+        const response = await coordinator.sendRequest(api_1.API.METADATA, {
+            allowTopicAutoCreation,
+            includeTopicAuthorizedOperations: false,
+            topics: topics.map((name) => ({ id: null, name })),
+        });
+        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]));
+        assignment = topicPartitions;
+    };
+    const listOffsets = async () => {
+        const offsets = await coordinator.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 - 1n);
+            });
+        });
+    };
+    return {
+        init: async () => {
+            await fetchMetadata();
+            await listOffsets();
+        },
+        getTopicPartitions: () => topicPartitions,
+        getTopicIdByName: (name) => topicIdByName[name],
+        getTopicNameById: (id) => topicNameById[id],
+        getAssignment: () => assignment,
+        setAssignment: (newAssignment) => {
+            assignment = newAssignment;
+        },
+    };
+};
+exports.createMetadata = createMetadata;

package/dist/src/consumer/offset-manager.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createOffsetManager = void 0;
+const createOffsetManager = () => {
+    let currentOffsets = {};
+    let pendingOffsets = {};
+    const resolve = (topic, partition, offset) => {
+        pendingOffsets[topic] ??= {};
+        pendingOffsets[topic][partition] = offset + 1n;
+        currentOffsets[topic] ??= {};
+        currentOffsets[topic][partition] = offset + 1n;
+    };
+    const flush = () => {
+        pendingOffsets = {};
+    };
+    return {
+        getCurrentOffset: (topic, partition) => currentOffsets[topic]?.[partition] ?? 0n,
+        resolve,
+        flush,
+        getPendingOffsets: () => pendingOffsets,
+    };
+};
+exports.createOffsetManager = createOffsetManager;

package/dist/src/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./consumer/consumer"), exports);
+__exportStar(require("./producer/producer"), exports);
+__exportStar(require("./types"), exports);

package/dist/src/producer/producer.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createProducer = void 0;
+const api_1 = require("../api");
+const broker_1 = require("../broker");
+const createProducer = ({ clientId = null, brokers }) => {
+    let producerId = 0n;
+    let producerEpoch = 0;
+    let sequences = {};
+    let connect = (async () => {
+        const broker = await (0, broker_1.connectBroker)({ clientId, options: brokers[0] });
+        const result = await broker.sendRequest(api_1.API.INIT_PRODUCER_ID, {
+            transactionalId: null,
+            transactionTimeoutMs: 0,
+            producerId,
+            producerEpoch,
+        });
+        producerId = result.producerId;
+        producerEpoch = result.producerEpoch;
+        sequences = {};
+        return broker;
+    })();
+    const getSequence = (topic, partition) => {
+        sequences[topic] ??= {};
+        sequences[topic][partition] ??= 0;
+        return sequences[topic][partition]++;
+    };
+    const send = async (messages) => {
+        const { sendRequest } = await connect;
+        const topicPartitionMessages = {};
+        messages.forEach((message) => {
+            topicPartitionMessages[message.topic] ??= {};
+            topicPartitionMessages[message.topic][message.partition] ??= [];
+            topicPartitionMessages[message.topic][message.partition].push(message);
+        });
+        await sendRequest(api_1.API.PRODUCE, {
+            transactionalId: null,
+            acks: 1,
+            timeoutMs: 5000,
+            topicData: Object.entries(topicPartitionMessages).map(([topic, partitionMessages]) => ({
+                name: topic,
+                partitionData: Object.entries(partitionMessages).map(([partition, messages]) => {
+                    let baseTimestamp;
+                    let maxTimestamp;
+                    messages.forEach(message => {
+                        if (!baseTimestamp || message.timestamp < baseTimestamp) {
+                            baseTimestamp = message.timestamp;
+                        }
+                        if (!maxTimestamp || message.timestamp > maxTimestamp) {
+                            maxTimestamp = message.timestamp;
+                        }
+                    });
+                    return ({
+                        index: parseInt(partition),
+                        baseOffset: 0n,
+                        partitionLeaderEpoch: -1,
+                        attributes: 0,
+                        lastOffsetDelta: messages.length - 1,
+                        baseTimestamp: baseTimestamp ?? 0n,
+                        maxTimestamp: maxTimestamp ?? 0n,
+                        producerId,
+                        producerEpoch: 0,
+                        baseSequence: getSequence(topic, parseInt(partition)),
+                        records: messages.map((message, index) => ({
+                            attributes: 0,
+                            timestampDelta: message.timestamp - (baseTimestamp ?? 0n),
+                            offsetDelta: index,
+                            key: message.key,
+                            value: message.value,
+                            headers: Object.entries(message.headers).map(([key, value]) => ({ key, value })),
+                        })),
+                    });
+                }),
+            })),
+        });
+    };
+    const close = async () => {
+        const { disconnect } = await connect;
+        // TODO: wait for inflight requests to complete
+        await disconnect();
+    };
+    return { send, close };
+};
+exports.createProducer = createProducer;

package/dist/src/request-handler.js

@@ -0,0 +1,57 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createRequestHandler = void 0;
+const node_assert_1 = __importDefault(require("node:assert"));
+const api_1 = require("./api");
+const decoder_1 = require("./utils/decoder");
+const encoder_1 = require("./utils/encoder");
+const createRequestHandler = ({ clientId, connection }) => {
+    const requestQueue = {};
+    let currentBuffer = null;
+    const handleData = (buffer) => {
+        currentBuffer = currentBuffer ? Buffer.concat([currentBuffer, buffer]) : buffer;
+        const decoder = (0, decoder_1.createDecoder)({ buffer: currentBuffer });
+        const size = decoder.readInt32();
+        if (size > decoder.buffer.length) {
+            return;
+        }
+        const correlationId = decoder.readInt32();
+        const request = requestQueue[correlationId];
+        delete requestQueue[correlationId];
+        request.callback(decoder);
+        // console.log({
+        //     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}`);
+        currentBuffer = null;
+    };
+    const sendRequest = (api, args) => {
+        const [apiName] = Object.entries(api_1.API).find(([, value]) => value === api) ?? ["UNKNOWN"];
+        console.log(`[sendRequest] ${apiName}`);
+        const correlationId = Math.floor(Math.random() * 1000000);
+        const encoder = (0, encoder_1.createEncoder)()
+            .writeInt16(api.apiKey)
+            .writeInt16(api.apiVersion)
+            .writeInt32(correlationId)
+            .writeString(clientId);
+        const request = api.request(encoder, args);
+        const buffer = (0, encoder_1.createEncoder)()
+            .writeInt32(request.length)
+            .write(request)
+            .value();
+        return new Promise((resolve, reject) => {
+            requestQueue[correlationId] = {
+                callback: (decoder) => resolve(api.response(decoder)),
+            };
+            connection.socket.write(buffer, (err) => (err ? reject(err) : undefined));
+        });
+    };
+    connection.socket.on("data", handleData);
+    return { sendRequest };
+};
+exports.createRequestHandler = createRequestHandler;

package/dist/src/request-handler.test.js

@@ -0,0 +1,321 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const api_versions_1 = require("./api/api-versions");
+const create_topics_1 = require("./api/create-topics");
+const fetch_1 = require("./api/fetch");
+const metadata_1 = require("./api/metadata");
+const connection_1 = require("./connection");
+const request_handler_1 = require("./request-handler");
+const delete_topics_1 = require("./api/delete-topics");
+const produce_1 = require("./api/produce");
+const find_coordinator_1 = require("./api/find-coordinator");
+const join_group_1 = require("./api/join-group");
+const crypto_1 = require("crypto");
+const sync_group_1 = require("./api/sync-group");
+const offset_commit_1 = require("./api/offset-commit");
+const offset_fetch_1 = require("./api/offset-fetch");
+const heartbeat_1 = require("./api/heartbeat");
+const leave_group_1 = require("./api/leave-group");
+const init_producer_id_1 = require("./api/init-producer-id");
+vitest_1.describe.sequential("Request handler", () => {
+    const connection = (0, connection_1.createConnection)({ host: "localhost", port: 9092 });
+    let sendRequest;
+    const groupId = (0, crypto_1.randomBytes)(16).toString("hex");
+    (0, vitest_1.beforeAll)(async () => {
+        await connection.connect();
+        const handler = (0, request_handler_1.createRequestHandler)({ clientId: 'kafkats', connection });
+        sendRequest = handler.sendRequest;
+        const metadataResult = await sendRequest(metadata_1.METADATA, {
+            topics: null,
+            allowTopicAutoCreation: false,
+            includeTopicAuthorizedOperations: false,
+        });
+        if (metadataResult.topics.some((topic) => topic.name === "kafkats-test-topic")) {
+            await sendRequest(delete_topics_1.DELETE_TOPICS, {
+                topics: [{ name: "kafkats-test-topic", topicId: null }],
+                timeoutMs: 10000,
+            });
+        }
+    });
+    (0, vitest_1.afterAll)(async () => {
+        await connection.disconnect();
+    });
+    (0, vitest_1.it)("should request api versions", async () => {
+        const result = await sendRequest(api_versions_1.API_VERSIONS, {});
+        (0, vitest_1.expect)(result).toMatchSnapshot();
+    });
+    let topicId = "d6718d178e1b47c886441ad2d19faea5";
+    (0, vitest_1.it)("should create topics", async () => {
+        const result = await sendRequest(create_topics_1.CREATE_TOPICS, {
+            topics: [
+                {
+                    name: "kafkats-test-topic",
+                    numPartitions: 1,
+                    replicationFactor: 1,
+                    assignments: [],
+                    configs: [],
+                },
+            ],
+            timeoutMs: 10000,
+            validateOnly: false,
+        });
+        topicId = result.topics[0].topicId;
+        console.log({ topicId });
+        result.topics.forEach((topic) => {
+            topic.topicId = "Any<UUID>";
+        });
+        (0, vitest_1.expect)(result).toMatchSnapshot();
+    });
+    (0, vitest_1.it)("should request metadata for all topics", async () => {
+        const result = await sendRequest(metadata_1.METADATA, {
+            topics: null,
+            allowTopicAutoCreation: false,
+            includeTopicAuthorizedOperations: false,
+        });
+        result.topics.forEach((topic) => {
+            topic.topicId = "Any<UUID>";
+        });
+        (0, vitest_1.expect)(result).toMatchSnapshot();
+    });
+    (0, vitest_1.it)("should request metadata for a topic", async () => {
+        const result = await sendRequest(metadata_1.METADATA, {
+            topics: [{ id: topicId, name: "kafkats-test-topic" }],
+            allowTopicAutoCreation: false,
+            includeTopicAuthorizedOperations: false,
+        });
+        result.topics.forEach((topic) => {
+            topic.topicId = "Any<UUID>";
+        });
+        (0, vitest_1.expect)(result).toMatchSnapshot();
+    });
+    (0, vitest_1.it)('should init producer id', async () => {
+        const result = await sendRequest(init_producer_id_1.INIT_PRODUCER_ID, {
+            transactionalId: null,
+            transactionTimeoutMs: 0,
+            producerId: 0n,
+            producerEpoch: 0,
+        });
+        (0, vitest_1.expect)(result).toMatchSnapshot();
+    });
+    (0, vitest_1.it)("should produce messages", async () => {
+        const now = Date.now();
+        const result = await sendRequest(produce_1.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 sendRequest(fetch_1.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();
+    });
+    (0, vitest_1.it)("should find coordinator", async () => {
+        const result = await sendRequest(find_coordinator_1.FIND_COORDINATOR, { keyType: find_coordinator_1.KEY_TYPE.GROUP, keys: [groupId] });
+        result.coordinators.forEach((coordinator) => {
+            coordinator.key = "Any<String>";
+        });
+        (0, vitest_1.expect)(result).toMatchSnapshot();
+    });
+    let memberId = "";
+    (0, vitest_1.it)("should fail join group request with new memberId", async () => {
+        const result = await sendRequest(join_group_1.JOIN_GROUP, {
+            groupId: groupId,
+            sessionTimeoutMs: 30000,
+            rebalanceTimeoutMs: 60000,
+            memberId,
+            groupInstanceId: null,
+            protocolType: "consumer",
+            protocols: [
+                {
+                    name: "RoundRobinAssigner",
+                    metadata: { version: 0, topics: ["kafkats-test-topic"] },
+                },
+            ],
+            reason: null,
+        });
+        memberId = String(result.memberId ?? "");
+        result.memberId = "Any<UUID>";
+        (0, vitest_1.expect)(result).toMatchSnapshot();
+    });
+    (0, vitest_1.it)("should join group", async () => {
+        const result = await sendRequest(join_group_1.JOIN_GROUP, {
+            groupId: 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 sendRequest(sync_group_1.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 sendRequest(offset_commit_1.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 sendRequest(offset_fetch_1.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 sendRequest(heartbeat_1.HEARTBEAT, {
+            groupId,
+            generationId: 1,
+            memberId,
+            groupInstanceId: null,
+        });
+        (0, vitest_1.expect)(result).toMatchSnapshot();
+    });
+    (0, vitest_1.it)("should leave group", async () => {
+        const result = await sendRequest(leave_group_1.LEAVE_GROUP, {
+            groupId,
+            members: [{ memberId, groupInstanceId: null, reason: null }],
+        });
+        result.members.forEach((member) => {
+            member.memberId = "Any<UUID>";
+        });
+        (0, vitest_1.expect)(result).toMatchSnapshot();
+    });
+    vitest_1.it.skip("should delete topics", async () => {
+        const result = await sendRequest(delete_topics_1.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/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/src/utils/api.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createApi = void 0;
+const createApi = (api) => api;
+exports.createApi = createApi;