kafka-ts 0.0.1-beta → 0.0.3-beta

package/dist/src/consumer/consumer.js

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

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

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

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

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

@@ -1,57 +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.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

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

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

package/dist/src/utils/api.js

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