kafka-ts 0.0.1-beta

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/consumer/offset-manager.d.ts

@@ -0,0 +1,22 @@
+import { IsolationLevel } from "../api/fetch";
+import { Cluster } from "../cluster";
+import { ConsumerMetadata } from "./consumer-metadata";
+type OffsetManagerOptions = {
+    cluster: Cluster;
+    metadata: ConsumerMetadata;
+    isolationLevel: IsolationLevel;
+};
+export declare class OffsetManager {
+    private options;
+    private currentOffsets;
+    pendingOffsets: Record<string, Record<number, bigint>>;
+    constructor(options: OffsetManagerOptions);
+    getCurrentOffset(topic: string, partition: number): bigint;
+    resolve(topic: string, partition: number, offset: bigint): void;
+    flush(): void;
+    fetchOffsets(options: {
+        fromBeginning: boolean;
+    }): Promise<void>;
+    private listOffsets;
+}
+export {};

package/dist/consumer/offset-manager.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OffsetManager = void 0;
+const api_1 = require("../api");
+const messages_to_topic_partition_leaders_1 = require("../distributors/messages-to-topic-partition-leaders");
+class OffsetManager {
+    options;
+    currentOffsets = {};
+    pendingOffsets = {};
+    constructor(options) {
+        this.options = options;
+    }
+    getCurrentOffset(topic, partition) {
+        return this.currentOffsets[topic]?.[partition] ?? 0n;
+    }
+    resolve(topic, partition, offset) {
+        this.pendingOffsets[topic] ??= {};
+        this.pendingOffsets[topic][partition] = offset;
+        this.currentOffsets[topic] ??= {};
+        this.currentOffsets[topic][partition] = offset;
+    }
+    flush() {
+        this.pendingOffsets = {};
+    }
+    async fetchOffsets(options) {
+        const { metadata } = this.options;
+        const topicPartitions = Object.entries(metadata.getAssignment()).flatMap(([topic, partitions]) => partitions.map((partition) => ({ topic, partition })));
+        const nodeTopicPartitions = (0, messages_to_topic_partition_leaders_1.distributeMessagesToTopicPartitionLeaders)(topicPartitions, metadata.getTopicPartitionLeaderIds());
+        await Promise.all(Object.entries(nodeTopicPartitions).map(([nodeId, topicPartitions]) => this.listOffsets({
+            ...options,
+            nodeId: parseInt(nodeId),
+            nodeAssignment: Object.fromEntries(Object.entries(topicPartitions).map(([topicName, partitions]) => [topicName, Object.keys(partitions).map(Number)])),
+        })));
+        this.flush();
+    }
+    async listOffsets({ nodeId, nodeAssignment, fromBeginning, }) {
+        const { cluster, isolationLevel } = this.options;
+        const offsets = await cluster.sendRequestToNode(nodeId)(api_1.API.LIST_OFFSETS, {
+            replicaId: -1,
+            isolationLevel,
+            topics: Object.entries(nodeAssignment)
+                .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 }) => {
+                this.resolve(name, partitionIndex, fromBeginning ? 0n : offset);
+            });
+        });
+        this.flush();
+    }
+}
+exports.OffsetManager = OffsetManager;

package/dist/distributors/assignments-to-replicas.d.ts

@@ -0,0 +1,17 @@
+type Assignment = {
+    [topicName: string]: number[];
+};
+type TopicPartitionReplicaIds = {
+    [topicName: string]: {
+        [partition: number]: number[];
+    };
+};
+export type NodeAssignment = {
+    [replicaId: number]: Assignment;
+};
+/** From replica ids pick the one with fewest assignments to balance the load across brokers */
+export declare const distributeAssignmentsToNodesBalanced: (assignment: Assignment, topicPartitionReplicaIds: TopicPartitionReplicaIds) => NodeAssignment;
+/** Minimize the total number of replicas in the result to reduce the number of requests to different brokers */
+export declare const distributeAssignmentsToNodesOptimized: (assignment: Assignment, topicPartitionReplicaIds: TopicPartitionReplicaIds) => NodeAssignment;
+export declare const distributeAssignmentsToNodes: (assignment: Assignment, topicPartitionReplicaIds: TopicPartitionReplicaIds) => NodeAssignment;
+export {};

package/dist/distributors/assignments-to-replicas.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.distributeAssignmentsToNodes = exports.distributeAssignmentsToNodesOptimized = exports.distributeAssignmentsToNodesBalanced = void 0;
+/** From replica ids pick the one with fewest assignments to balance the load across brokers */
+const distributeAssignmentsToNodesBalanced = (assignment, topicPartitionReplicaIds) => {
+    const replicaPartitions = getPartitionsByReplica(assignment, topicPartitionReplicaIds);
+    const result = {};
+    for (const [topicName, partitions] of Object.entries(assignment)) {
+        for (const partition of partitions) {
+            const replicaIds = topicPartitionReplicaIds[topicName][partition];
+            const replicaId = replicaIds.reduce((prev, curr) => {
+                if (!prev) {
+                    return curr;
+                }
+                return (replicaPartitions[prev]?.length ?? 0) < (replicaPartitions[curr]?.length ?? 0) ? prev : curr;
+            });
+            result[replicaId] ??= {};
+            result[replicaId][topicName] ??= [];
+            result[replicaId][topicName].push(partition);
+        }
+    }
+    return result;
+};
+exports.distributeAssignmentsToNodesBalanced = distributeAssignmentsToNodesBalanced;
+/** Minimize the total number of replicas in the result to reduce the number of requests to different brokers */
+const distributeAssignmentsToNodesOptimized = (assignment, topicPartitionReplicaIds) => {
+    const result = {};
+    const sortFn = ([, partitionsA], [, partitionsB]) => partitionsB.length - partitionsA.length;
+    let replicaPartitions = getPartitionsByReplica(assignment, topicPartitionReplicaIds);
+    while (replicaPartitions.length) {
+        replicaPartitions.sort(sortFn);
+        const [replicaId, partitions] = replicaPartitions.shift();
+        if (!partitions.length) {
+            continue;
+        }
+        result[parseInt(replicaId)] = partitions.reduce((acc, partition) => {
+            const [topicName, partitionId] = partition.split(":");
+            acc[topicName] ??= [];
+            acc[topicName].push(parseInt(partitionId));
+            return acc;
+        }, {});
+        replicaPartitions = replicaPartitions.map(([replicaId, replicaPartitions]) => [replicaId, replicaPartitions.filter((partition) => !partitions.includes(partition))]);
+    }
+    return result;
+};
+exports.distributeAssignmentsToNodesOptimized = distributeAssignmentsToNodesOptimized;
+const getPartitionsByReplica = (assignment, topicPartitionReplicaIds) => {
+    const partitionsByReplicaId = {};
+    for (const [topicName, partitions] of Object.entries(assignment)) {
+        for (const partition of partitions) {
+            const replicaIds = topicPartitionReplicaIds[topicName][partition];
+            for (const replicaId of replicaIds) {
+                partitionsByReplicaId[replicaId] ??= [];
+                partitionsByReplicaId[replicaId].push(`${topicName}:${partition}`);
+            }
+        }
+    }
+    return Object.entries(partitionsByReplicaId);
+};
+exports.distributeAssignmentsToNodes = exports.distributeAssignmentsToNodesBalanced;

package/dist/distributors/assignments-to-replicas.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/distributors/assignments-to-replicas.test.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const assignments_to_replicas_1 = require("./assignments-to-replicas");
+(0, vitest_1.describe)("Distribute assignments to replica ids", () => {
+    (0, vitest_1.describe)("distributeAssignmentsToNodesBalanced", () => {
+        (0, vitest_1.it)("smoke", () => {
+            const result = (0, assignments_to_replicas_1.distributeAssignmentsToNodesBalanced)({ topic: [0, 1] }, { topic: { 0: [0, 1], 1: [1, 2] } });
+            (0, vitest_1.expect)(result).toMatchInlineSnapshot(`
+              {
+                "1": {
+                  "topic": [
+                    0,
+                  ],
+                },
+                "2": {
+                  "topic": [
+                    1,
+                  ],
+                },
+              }
+            `);
+        });
+    });
+    (0, vitest_1.describe)("distributeAssignmentsToNodesOptimized", () => {
+        (0, vitest_1.it)("smoke", () => {
+            const result = (0, assignments_to_replicas_1.distributeAssignmentsToNodesOptimized)({ topic: [0, 1] }, { topic: { 0: [0, 1], 1: [1, 2] } });
+            (0, vitest_1.expect)(result).toMatchInlineSnapshot(`
+              {
+                "1": {
+                  "topic": [
+                    0,
+                    1,
+                  ],
+                },
+              }
+            `);
+        });
+    });
+});

package/dist/distributors/messages-to-topic-partition-leaders.d.ts

@@ -0,0 +1,17 @@
+type TopicPartitionLeader = {
+    [topicName: string]: {
+        [partitionId: number]: number;
+    };
+};
+type MessagesByNodeTopicPartition<T> = {
+    [nodeId: number]: {
+        [topicName: string]: {
+            [partitionId: number]: T[];
+        };
+    };
+};
+export declare const distributeMessagesToTopicPartitionLeaders: <T extends {
+    topic: string;
+    partition: number;
+}>(messages: T[], topicPartitionLeader: TopicPartitionLeader) => MessagesByNodeTopicPartition<T>;
+export {};

package/dist/distributors/messages-to-topic-partition-leaders.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.distributeMessagesToTopicPartitionLeaders = void 0;
+const distributeMessagesToTopicPartitionLeaders = (messages, topicPartitionLeader) => {
+    const result = {};
+    messages.forEach((message) => {
+        const leaderId = topicPartitionLeader[message.topic][message.partition];
+        result[leaderId] ??= {};
+        result[leaderId][message.topic] ??= {};
+        result[leaderId][message.topic][message.partition] ??= [];
+        result[leaderId][message.topic][message.partition].push(message);
+    });
+    return result;
+};
+exports.distributeMessagesToTopicPartitionLeaders = distributeMessagesToTopicPartitionLeaders;

package/dist/distributors/messages-to-topic-partition-leaders.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/distributors/messages-to-topic-partition-leaders.test.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const messages_to_topic_partition_leaders_1 = require("./messages-to-topic-partition-leaders");
+(0, vitest_1.describe)("Distribute messages to partition leader ids", () => {
+    (0, vitest_1.describe)("distributeMessagesToTopicPartitionLeaders", () => {
+        (0, vitest_1.it)("snoke", () => {
+            const result = (0, messages_to_topic_partition_leaders_1.distributeMessagesToTopicPartitionLeaders)([{ topic: "topic", partition: 0, key: null, value: null, offset: 0n, timestamp: 0n, headers: {} }], { topic: { 0: 1 } });
+            (0, vitest_1.expect)(result).toMatchInlineSnapshot(`
+              {
+                "1": {
+                  "topic": {
+                    "0": [
+                      {
+                        "headers": {},
+                        "key": null,
+                        "offset": 0n,
+                        "partition": 0,
+                        "timestamp": 0n,
+                        "topic": "topic",
+                        "value": null,
+                      },
+                    ],
+                  },
+                },
+              }
+            `);
+        });
+    });
+});

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/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./client";
+export * from "./api";
+export * from "./types";

package/dist/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("./client"), exports);
+__exportStar(require("./api"), exports);
+__exportStar(require("./types"), exports);

package/dist/metadata.d.ts

@@ -0,0 +1,24 @@
+import { Cluster } from "./cluster";
+type MetadataOptions = {
+    cluster: Cluster;
+};
+export declare class Metadata {
+    private options;
+    private topicPartitions;
+    private topicNameById;
+    private topicIdByName;
+    private leaderIdByTopicPartition;
+    private isrNodesByTopicPartition;
+    constructor(options: MetadataOptions);
+    getTopicPartitionLeaderIds(): Record<string, Record<number, number>>;
+    getTopicPartitionReplicaIds(): Record<string, Record<number, number[]>>;
+    getTopicPartitions(): Record<string, number[]>;
+    getTopicIdByName(name: string): string;
+    getTopicNameById(id: string): string;
+    fetchMetadataIfNecessary({ topics, allowTopicAutoCreation, }: {
+        topics: string[];
+        allowTopicAutoCreation: boolean;
+    }): Promise<void>;
+    private fetchMetadata;
+}
+export {};

package/dist/metadata.js

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Metadata = void 0;
+const api_1 = require("./api");
+const delay_1 = require("./utils/delay");
+const error_1 = require("./utils/error");
+class Metadata {
+    options;
+    topicPartitions = {};
+    topicNameById = {};
+    topicIdByName = {};
+    leaderIdByTopicPartition = {};
+    isrNodesByTopicPartition = {};
+    constructor(options) {
+        this.options = options;
+    }
+    getTopicPartitionLeaderIds() {
+        return this.leaderIdByTopicPartition;
+    }
+    getTopicPartitionReplicaIds() {
+        return this.isrNodesByTopicPartition;
+    }
+    getTopicPartitions() {
+        return this.topicPartitions;
+    }
+    getTopicIdByName(name) {
+        return this.topicIdByName[name];
+    }
+    getTopicNameById(id) {
+        return this.topicNameById[id];
+    }
+    async fetchMetadataIfNecessary({ topics, allowTopicAutoCreation, }) {
+        const missingTopics = topics.filter((topic) => !this.topicPartitions[topic]);
+        if (!missingTopics.length) {
+            return;
+        }
+        try {
+            return await this.fetchMetadata({ topics: missingTopics, allowTopicAutoCreation });
+        }
+        catch (error) {
+            if (error instanceof error_1.KafkaTSApiError &&
+                error.errorCode === api_1.API_ERROR.UNKNOWN_TOPIC_OR_PARTITION &&
+                allowTopicAutoCreation) {
+                // TODO: investigate if we can avoid the delay
+                await (0, delay_1.delay)(1000);
+                return await this.fetchMetadata({ topics: missingTopics, allowTopicAutoCreation });
+            }
+            throw error;
+        }
+    }
+    async fetchMetadata({ topics, allowTopicAutoCreation, }) {
+        const { cluster } = this.options;
+        const response = await cluster.sendRequest(api_1.API.METADATA, {
+            allowTopicAutoCreation,
+            includeTopicAuthorizedOperations: false,
+            topics: topics?.map((name) => ({ id: null, name })) ?? null,
+        });
+        this.topicPartitions = {
+            ...this.topicPartitions,
+            ...Object.fromEntries(response.topics.map((topic) => [
+                topic.name,
+                topic.partitions.map((partition) => partition.partitionIndex),
+            ])),
+        };
+        this.topicNameById = {
+            ...this.topicNameById,
+            ...Object.fromEntries(response.topics.map((topic) => [topic.topicId, topic.name])),
+        };
+        this.topicIdByName = {
+            ...this.topicIdByName,
+            ...Object.fromEntries(response.topics.map((topic) => [topic.name, topic.topicId])),
+        };
+        this.leaderIdByTopicPartition = {
+            ...this.leaderIdByTopicPartition,
+            ...Object.fromEntries(response.topics.map((topic) => [
+                topic.name,
+                Object.fromEntries(topic.partitions.map((partition) => [partition.partitionIndex, partition.leaderId])),
+            ])),
+        };
+        this.isrNodesByTopicPartition = {
+            ...this.isrNodesByTopicPartition,
+            ...Object.fromEntries(response.topics.map((topic) => [
+                topic.name,
+                Object.fromEntries(topic.partitions.map((partition) => [partition.partitionIndex, partition.isrNodes])),
+            ])),
+        };
+    }
+}
+exports.Metadata = Metadata;

package/dist/producer/producer.d.ts

@@ -0,0 +1,19 @@
+import { Cluster } from "../cluster";
+import { Message } from "../types";
+export type ProducerOptions = {
+    allowTopicAutoCreation?: boolean;
+};
+export declare class Producer {
+    private cluster;
+    private options;
+    private metadata;
+    private producerId;
+    private producerEpoch;
+    private sequences;
+    constructor(cluster: Cluster, options: ProducerOptions);
+    send(messages: Message[]): Promise<void>;
+    close(): Promise<void>;
+    private ensureConnected;
+    private initProducerId;
+    private nextSequence;
+}

package/dist/producer/producer.js

@@ -0,0 +1,111 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Producer = void 0;
+const api_1 = require("../api");
+const messages_to_topic_partition_leaders_1 = require("../distributors/messages-to-topic-partition-leaders");
+const metadata_1 = require("../metadata");
+const delay_1 = require("../utils/delay");
+const memo_1 = require("../utils/memo");
+class Producer {
+    cluster;
+    options;
+    metadata;
+    producerId = 0n;
+    producerEpoch = 0;
+    sequences = {};
+    constructor(cluster, options) {
+        this.cluster = cluster;
+        this.options = {
+            ...options,
+            allowTopicAutoCreation: options.allowTopicAutoCreation ?? false,
+        };
+        this.metadata = new metadata_1.Metadata({ cluster });
+    }
+    async send(messages) {
+        await this.ensureConnected();
+        const { allowTopicAutoCreation } = this.options;
+        const defaultTimestamp = BigInt(Date.now());
+        const topics = Array.from(new Set(messages.map((message) => message.topic)));
+        await this.metadata.fetchMetadataIfNecessary({ topics, allowTopicAutoCreation });
+        const nodeTopicPartitionMessages = (0, messages_to_topic_partition_leaders_1.distributeMessagesToTopicPartitionLeaders)(messages, this.metadata.getTopicPartitionLeaderIds());
+        await Promise.all(Object.entries(nodeTopicPartitionMessages).map(async ([nodeId, topicPartitionMessages]) => {
+            await this.cluster.sendRequestToNode(parseInt(nodeId))(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(({ timestamp = defaultTimestamp }) => {
+                            if (!baseTimestamp || timestamp < baseTimestamp) {
+                                baseTimestamp = timestamp;
+                            }
+                            if (!maxTimestamp || timestamp > maxTimestamp) {
+                                maxTimestamp = timestamp;
+                            }
+                        });
+                        const baseSequence = this.nextSequence(topic, parseInt(partition), messages.length);
+                        return {
+                            index: parseInt(partition),
+                            baseOffset: 0n,
+                            partitionLeaderEpoch: -1,
+                            attributes: 0,
+                            lastOffsetDelta: messages.length - 1,
+                            baseTimestamp: baseTimestamp ?? 0n,
+                            maxTimestamp: maxTimestamp ?? 0n,
+                            producerId: this.producerId,
+                            producerEpoch: 0,
+                            baseSequence,
+                            records: messages.map((message, index) => ({
+                                attributes: 0,
+                                timestampDelta: (message.timestamp ?? defaultTimestamp) - (baseTimestamp ?? 0n),
+                                offsetDelta: index,
+                                key: message.key,
+                                value: message.value,
+                                headers: Object.entries(message.headers ?? {}).map(([key, value]) => ({
+                                    key,
+                                    value,
+                                })),
+                            })),
+                        };
+                    }),
+                })),
+            });
+        }));
+    }
+    async close() {
+        await this.cluster.disconnect();
+    }
+    ensureConnected = (0, memo_1.memo)(async () => {
+        await this.cluster.connect();
+        await this.initProducerId();
+    });
+    async initProducerId() {
+        try {
+            const result = await this.cluster.sendRequest(api_1.API.INIT_PRODUCER_ID, {
+                transactionalId: null,
+                transactionTimeoutMs: 0,
+                producerId: this.producerId,
+                producerEpoch: this.producerEpoch,
+            });
+            this.producerId = result.producerId;
+            this.producerEpoch = result.producerEpoch;
+            this.sequences = {};
+        }
+        catch (error) {
+            if (error.errorCode === api_1.API_ERROR.COORDINATOR_LOAD_IN_PROGRESS) {
+                await (0, delay_1.delay)(100);
+                return this.initProducerId();
+            }
+            throw error;
+        }
+    }
+    nextSequence(topic, partition, messagesCount) {
+        this.sequences[topic] ??= {};
+        this.sequences[topic][partition] ??= 0;
+        return (this.sequences[topic][partition] += messagesCount || 1);
+    }
+}
+exports.Producer = Producer;

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 {};