kafka-ts 1.1.8 → 1.2.0

package/README.md

@@ -177,7 +177,7 @@ Custom SASL mechanisms can be implemented following the `SASLProvider` interface
 | allowTopicAutoCreation | boolean     | false    | false              | Allow kafka to auto-create topic when it doesn't exist                                  |
 | partitioner            | Partitioner | false    | defaultPartitioner | Custom partitioner function. By default, it uses a default java-compatible partitioner. |
 
-### `producer.send(messages: Message[], options?: { acks?: -1 | 1 })`
+### `producer.send(messages: Message[])`
 
 <!-- export type Message = {
     topic: string;

package/dist/consumer/consumer-group.js

@@ -14,6 +14,7 @@ const api_1 = require("../api");
 const find_coordinator_1 = require("../api/find-coordinator");
 const error_1 = require("../utils/error");
 const logger_1 = require("../utils/logger");
+const retry_1 = require("../utils/retry");
 const tracer_1 = require("../utils/tracer");
 const trace = (0, tracer_1.createTracer)('ConsumerGroup');
 class ConsumerGroup {
@@ -62,7 +63,7 @@ class ConsumerGroup {
         }
     }
     async findCoordinator() {
-        try {
+        return (0, retry_1.withRetry)(this.handleError.bind(this))(async () => {
             const { coordinators } = await this.options.cluster.sendRequest(api_1.API.FIND_COORDINATOR, {
                 keyType: find_coordinator_1.KEY_TYPE.GROUP,
                 keys: [this.options.groupId],
@@ -70,15 +71,11 @@ class ConsumerGroup {
             this.coordinatorId = coordinators[0].nodeId;
             await this.options.cluster.setSeedBroker(this.coordinatorId);
             this.heartbeatError = null;
-        }
-        catch (error) {
-            await this.handleError(error);
-            return this.findCoordinator();
-        }
+        });
     }
     async joinGroup() {
-        const { cluster, groupId, groupInstanceId, sessionTimeoutMs, rebalanceTimeoutMs, topics } = this.options;
-        try {
+        return (0, retry_1.withRetry)(this.handleError.bind(this))(async () => {
+            const { cluster, groupId, groupInstanceId, sessionTimeoutMs, rebalanceTimeoutMs, topics } = this.options;
             const response = await cluster.sendRequest(api_1.API.JOIN_GROUP, {
                 groupId,
                 groupInstanceId,
@@ -93,28 +90,27 @@ class ConsumerGroup {
             this.generationId = response.generationId;
             this.leaderId = response.leader;
             this.memberIds = response.members.map((member) => member.memberId);
-        }
-        catch (error) {
-            await this.handleError(error);
-            return this.joinGroup();
-        }
+        });
     }
     async syncGroup() {
-        const { cluster, metadata, groupId, groupInstanceId } = this.options;
-        let assignments = [];
-        if (this.memberId === this.leaderId) {
-            const memberAssignments = Object.entries(metadata.getTopicPartitions())
-                .flatMap(([topic, partitions]) => partitions.map((partition) => ({ topic, partition })))
-                .reduce((acc, { topic, partition }, index) => {
-                const memberId = this.memberIds[index % this.memberIds.length];
-                acc[memberId] ??= {};
-                acc[memberId][topic] ??= [];
-                acc[memberId][topic].push(partition);
-                return acc;
-            }, {});
-            assignments = Object.entries(memberAssignments).map(([memberId, assignment]) => ({ memberId, assignment }));
-        }
-        try {
+        return (0, retry_1.withRetry)(this.handleError.bind(this))(async () => {
+            const { cluster, metadata, groupId, groupInstanceId } = this.options;
+            let assignments = [];
+            if (this.memberId === this.leaderId) {
+                const memberAssignments = Object.entries(metadata.getTopicPartitions())
+                    .flatMap(([topic, partitions]) => partitions.map((partition) => ({ topic, partition })))
+                    .reduce((acc, { topic, partition }, index) => {
+                    const memberId = this.memberIds[index % this.memberIds.length];
+                    acc[memberId] ??= {};
+                    acc[memberId][topic] ??= [];
+                    acc[memberId][topic].push(partition);
+                    return acc;
+                }, {});
+                assignments = Object.entries(memberAssignments).map(([memberId, assignment]) => ({
+                    memberId,
+                    assignment,
+                }));
+            }
             const response = await cluster.sendRequest(api_1.API.SYNC_GROUP, {
                 groupId,
                 groupInstanceId,
@@ -125,29 +121,25 @@ class ConsumerGroup {
                 assignments,
             });
             metadata.setAssignment(response.assignments);
-        }
-        catch (error) {
-            await this.handleError(error);
-            return this.syncGroup();
-        }
+        });
     }
     async offsetFetch() {
-        const { cluster, groupId, topics, metadata, offsetManager } = this.options;
-        const assignment = metadata.getAssignment();
-        const request = {
-            groups: [
-                {
-                    groupId,
-                    topics: topics
-                        .map((topic) => ({ name: topic, partitionIndexes: assignment[topic] ?? [] }))
-                        .filter(({ partitionIndexes }) => partitionIndexes.length),
-                },
-            ].filter(({ topics }) => topics.length),
-            requireStable: true,
-        };
-        if (!request.groups.length)
-            return;
-        try {
+        return (0, retry_1.withRetry)(this.handleError.bind(this))(async () => {
+            const { cluster, groupId, topics, metadata, offsetManager } = this.options;
+            const assignment = metadata.getAssignment();
+            const request = {
+                groups: [
+                    {
+                        groupId,
+                        topics: topics
+                            .map((topic) => ({ name: topic, partitionIndexes: assignment[topic] ?? [] }))
+                            .filter(({ partitionIndexes }) => partitionIndexes.length),
+                    },
+                ].filter(({ topics }) => topics.length),
+                requireStable: true,
+            };
+            if (!request.groups.length)
+                return;
             const response = await cluster.sendRequest(api_1.API.OFFSET_FETCH, request);
             const topicPartitions = {};
             response.groups.forEach((group) => {
@@ -162,44 +154,36 @@ class ConsumerGroup {
                 });
             });
             offsetManager.flush(topicPartitions);
-        }
-        catch (error) {
-            await this.handleError(error);
-            return this.offsetFetch();
-        }
+        });
     }
     async offsetCommit(topicPartitions) {
-        const { cluster, groupId, groupInstanceId, offsetManager, consumer } = this.options;
-        const request = {
-            groupId,
-            groupInstanceId,
-            memberId: this.memberId,
-            generationIdOrMemberEpoch: this.generationId,
-            topics: Object.entries(topicPartitions)
-                .filter(([topic]) => topic in offsetManager.pendingOffsets)
-                .map(([topic, partitions]) => ({
-                name: topic,
-                partitions: [...partitions]
-                    .filter((partition) => partition in offsetManager.pendingOffsets[topic])
-                    .map((partitionIndex) => ({
-                    partitionIndex,
-                    committedOffset: offsetManager.pendingOffsets[topic][partitionIndex],
-                    committedLeaderEpoch: -1,
-                    committedMetadata: null,
+        return (0, retry_1.withRetry)(this.handleError.bind(this))(async () => {
+            const { cluster, groupId, groupInstanceId, offsetManager, consumer } = this.options;
+            const request = {
+                groupId,
+                groupInstanceId,
+                memberId: this.memberId,
+                generationIdOrMemberEpoch: this.generationId,
+                topics: Object.entries(topicPartitions)
+                    .filter(([topic]) => topic in offsetManager.pendingOffsets)
+                    .map(([topic, partitions]) => ({
+                    name: topic,
+                    partitions: [...partitions]
+                        .filter((partition) => partition in offsetManager.pendingOffsets[topic])
+                        .map((partitionIndex) => ({
+                        partitionIndex,
+                        committedOffset: offsetManager.pendingOffsets[topic][partitionIndex],
+                        committedLeaderEpoch: -1,
+                        committedMetadata: null,
+                    })),
                 })),
-            })),
-        };
-        if (!request.topics.length) {
-            return;
-        }
-        try {
+            };
+            if (!request.topics.length) {
+                return;
+            }
             await cluster.sendRequest(api_1.API.OFFSET_COMMIT, request);
-        }
-        catch (error) {
-            await this.handleError(error);
-            return this.offsetCommit(topicPartitions);
-        }
-        consumer.emit('offsetCommit');
+            consumer.emit('offsetCommit');
+        });
     }
     async heartbeat() {
         const { cluster, groupId, groupInstanceId, consumer } = this.options;
@@ -212,24 +196,25 @@ class ConsumerGroup {
         consumer.emit('heartbeat');
     }
     async leaveGroup() {
-        if (this.coordinatorId === -1) {
-            return;
-        }
-        const { cluster, groupId, groupInstanceId } = this.options;
-        this.stopHeartbeater();
-        try {
-            await cluster.sendRequest(api_1.API.LEAVE_GROUP, {
-                groupId,
-                members: [{ memberId: this.memberId, groupInstanceId, reason: null }],
-            });
-        }
-        catch (error) {
-            if (error instanceof error_1.KafkaTSApiError && error.errorCode === api_1.API_ERROR.FENCED_INSTANCE_ID) {
+        return (0, retry_1.withRetry)(this.handleError.bind(this))(async () => {
+            if (this.coordinatorId === -1) {
                 return;
             }
-            await this.handleError(error);
-            return this.leaveGroup();
-        }
+            const { cluster, groupId, groupInstanceId } = this.options;
+            this.stopHeartbeater();
+            try {
+                await cluster.sendRequest(api_1.API.LEAVE_GROUP, {
+                    groupId,
+                    members: [{ memberId: this.memberId, groupInstanceId, reason: null }],
+                });
+            }
+            catch (error) {
+                if (error instanceof error_1.KafkaTSApiError && error.errorCode === api_1.API_ERROR.FENCED_INSTANCE_ID) {
+                    return;
+                }
+                throw error;
+            }
+        });
     }
     async handleError(error) {
         await (0, api_1.handleApiError)(error).catch(async (error) => {

package/dist/consumer/consumer.js

@@ -15,11 +15,13 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Consumer = void 0;
 const events_1 = __importDefault(require("events"));
 const api_1 = require("../api");
-const messages_to_topic_partition_leaders_1 = require("../distributors/messages-to-topic-partition-leaders");
+const group_by_leader_id_1 = require("../distributors/group-by-leader-id");
+const group_partitions_by_topic_1 = require("../distributors/group-partitions-by-topic");
 const delay_1 = require("../utils/delay");
 const error_1 = require("../utils/error");
 const logger_1 = require("../utils/logger");
 const retrier_1 = require("../utils/retrier");
+const retry_1 = require("../utils/retry");
 const tracer_1 = require("../utils/tracer");
 const consumer_group_1 = require("./consumer-group");
 const consumer_metadata_1 = require("./consumer-metadata");
@@ -100,7 +102,9 @@ class Consumer extends events_1.default {
                 await this.fetchManager?.stop();
             });
         }
-        await this.consumerGroup?.leaveGroup().catch((error) => logger_1.log.debug('Failed to leave group', { reason: error.message }));
+        await this.consumerGroup
+            ?.leaveGroup()
+            .catch((error) => logger_1.log.debug('Failed to leave group', { reason: error.message }));
         await this.cluster.disconnect().catch(() => { });
     }
     async startFetchManager() {
@@ -109,12 +113,11 @@ class Consumer extends events_1.default {
             try {
                 await this.consumerGroup?.join();
                 // TODO: If leader is not available, find another read replica
-                const nodeAssignments = Object.entries((0, messages_to_topic_partition_leaders_1.distributeMessagesToTopicPartitionLeaders)(Object.entries(this.metadata.getAssignment()).flatMap(([topic, partitions]) => partitions.map((partition) => ({ topic, partition }))), this.metadata.getTopicPartitionLeaderIds())).map(([nodeId, assignment]) => ({
-                    nodeId: parseInt(nodeId),
-                    assignment: Object.fromEntries(Object.entries(assignment).map(([topic, partitions]) => [
-                        topic,
-                        Object.keys(partitions).map(Number),
-                    ])),
+                const topicPartitions = Object.entries(this.metadata.getAssignment()).flatMap(([topic, partitions]) => partitions.map((partition) => ({ topic, partition })));
+                const topicPartitionsByLeaderId = (0, group_by_leader_id_1.groupByLeaderId)(topicPartitions, this.metadata.getTopicPartitionLeaderIds());
+                const nodeAssignments = Object.entries(topicPartitionsByLeaderId).map(([leaderId, topicPartitions]) => ({
+                    nodeId: parseInt(leaderId),
+                    assignment: (0, group_partitions_by_topic_1.groupPartitionsByTopic)(topicPartitions),
                 }));
                 this.fetchManager = new fetch_manager_1.FetchManager({
                     fetch: this.fetch.bind(this),
@@ -140,7 +143,7 @@ class Consumer extends events_1.default {
                 if (error instanceof error_1.KafkaTSApiError && error.errorCode === api_1.API_ERROR.NOT_COORDINATOR) {
                     logger_1.log.debug('Not coordinator. Searching for new coordinator...');
                     await this.consumerGroup?.findCoordinator();
-                    return;
+                    continue;
                 }
                 if (error instanceof error_1.ConnectionError) {
                     logger_1.log.debug(`${error.message}. Restarting consumer...`, { stack: error.stack });
@@ -210,10 +213,10 @@ class Consumer extends events_1.default {
         this.offsetManager.flush(topicPartitions);
     }
     async fetch(nodeId, assignment) {
-        const { rackId, maxWaitMs, minBytes, maxBytes, partitionMaxBytes, isolationLevel } = this.options;
-        this.consumerGroup?.handleLastHeartbeat();
-        try {
-            return await this.cluster.sendRequestToNode(nodeId)(api_1.API.FETCH, {
+        return (0, retry_1.withRetry)(this.handleError.bind(this))(async () => {
+            const { rackId, maxWaitMs, minBytes, maxBytes, partitionMaxBytes, isolationLevel } = this.options;
+            this.consumerGroup?.handleLastHeartbeat();
+            return this.cluster.sendRequestToNode(nodeId)(api_1.API.FETCH, {
                 maxWaitMs,
                 minBytes,
                 maxBytes,
@@ -234,31 +237,19 @@ class Consumer extends events_1.default {
                 forgottenTopicsData: [],
                 rackId,
             });
-        }
-        catch (error) {
-            await this.handleError(error);
-            return this.fetch(nodeId, assignment);
-        }
+        });
     }
     async fetchMetadata() {
-        const { topics, allowTopicAutoCreation } = this.options;
-        try {
+        return (0, retry_1.withRetry)(this.handleError.bind(this))(async () => {
+            const { topics, allowTopicAutoCreation } = this.options;
             await this.metadata.fetchMetadata({ topics, allowTopicAutoCreation });
-        }
-        catch (error) {
-            await this.handleError(error);
-            return this.fetchMetadata();
-        }
+        });
     }
     async fetchOffsets() {
-        const { fromTimestamp } = this.options;
-        try {
+        return (0, retry_1.withRetry)(this.handleError.bind(this))(async () => {
+            const { fromTimestamp } = this.options;
             await this.offsetManager.fetchOffsets({ fromTimestamp });
-        }
-        catch (error) {
-            await this.handleError(error);
-            return this.fetchOffsets();
-        }
+        });
     }
     async handleError(error) {
         await (0, api_1.handleApiError)(error).catch(async (error) => {

package/dist/consumer/offset-manager.js

@@ -2,7 +2,8 @@
 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");
+const group_by_leader_id_1 = require("../distributors/group-by-leader-id");
+const group_partitions_by_topic_1 = require("../distributors/group-partitions-by-topic");
 const tracer_1 = require("../utils/tracer");
 const trace = (0, tracer_1.createTracer)('OffsetManager');
 class OffsetManager {
@@ -40,11 +41,11 @@ class OffsetManager {
     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({
+        const topicPartitionsByLeaderId = (0, group_by_leader_id_1.groupByLeaderId)(topicPartitions, metadata.getTopicPartitionLeaderIds());
+        await Promise.all(Object.entries(topicPartitionsByLeaderId).map(([leaderId, topicPartitions]) => this.listOffsets({
             ...options,
-            nodeId: parseInt(nodeId),
-            nodeAssignment: Object.fromEntries(Object.entries(topicPartitions).map(([topicName, partitions]) => [topicName, Object.keys(partitions).map(Number)])),
+            nodeId: parseInt(leaderId),
+            nodeAssignment: (0, group_partitions_by_topic_1.groupPartitionsByTopic)(topicPartitions),
         })));
     }
     async listOffsets({ nodeId, nodeAssignment, fromTimestamp, }) {

package/dist/distributors/group-by-leader-id.d.ts

@@ -0,0 +1,10 @@
+export declare const groupByLeaderId: <T extends {
+    topic: string;
+    partition: number;
+}>(items: T[], leaderIdByTopicPartition: {
+    [topic: string]: {
+        [partition: number]: number;
+    };
+}) => {
+    [nodeId: number]: T[];
+};

package/dist/distributors/group-by-leader-id.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.groupByLeaderId = void 0;
+const groupByLeaderId = (items, leaderIdByTopicPartition) => {
+    const result = {};
+    items.forEach((item) => {
+        const leaderId = leaderIdByTopicPartition[item.topic][item.partition];
+        result[leaderId] ??= [];
+        result[leaderId].push(item);
+    });
+    return result;
+};
+exports.groupByLeaderId = groupByLeaderId;

package/dist/distributors/group-partitions-by-topic.d.ts

@@ -0,0 +1,6 @@
+export declare const groupPartitionsByTopic: <T extends {
+    topic: string;
+    partition: number;
+}>(items: T[]) => {
+    [topic: string]: number[];
+};

package/dist/distributors/group-partitions-by-topic.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.groupPartitionsByTopic = void 0;
+const groupPartitionsByTopic = (items) => {
+    const result = {};
+    items.forEach((item) => {
+        result[item.topic] ??= [];
+        result[item.topic].push(item.partition);
+    });
+    return result;
+};
+exports.groupPartitionsByTopic = groupPartitionsByTopic;

package/dist/metadata.d.ts

@@ -16,7 +16,7 @@ export declare class Metadata {
     getTopicIdByName(name: string): string;
     getTopicNameById(id: string): string;
     fetchMetadataIfNecessary({ topics, allowTopicAutoCreation, }: {
-        topics: string[] | Set<string>;
+        topics: string[];
         allowTopicAutoCreation: boolean;
     }): Promise<void>;
     fetchMetadata({ topics, allowTopicAutoCreation, }: {

package/dist/metadata.js

@@ -41,7 +41,7 @@ class Metadata {
         return this.topicNameById[id];
     }
     async fetchMetadataIfNecessary({ topics, allowTopicAutoCreation, }) {
-        const missingTopics = Array.from(topics).filter((topic) => !this.topicPartitions[topic]);
+        const missingTopics = topics.filter((topic) => !this.topicPartitions[topic]);
         if (!missingTopics.length) {
             return;
         }

package/dist/producer/producer-buffer.d.ts

@@ -0,0 +1,20 @@
+import { Cluster } from '../cluster';
+import { Message } from '../types';
+import { ProducerState } from './producer-state';
+type ProducerBufferOptions = {
+    nodeId: number;
+    maxBatchSize: number;
+    cluster: Cluster;
+    state: ProducerState;
+};
+export declare class ProducerBuffer {
+    private options;
+    private buffer;
+    private head;
+    private isFlushing;
+    constructor(options: ProducerBufferOptions);
+    enqueue(messages: Message[]): Promise<void>;
+    private flush;
+    private compactBuffer;
+}
+export {};

package/dist/producer/producer-buffer.js

@@ -0,0 +1,118 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProducerBuffer = void 0;
+const api_1 = require("../api");
+class ProducerBuffer {
+    options;
+    buffer = [];
+    head = 0;
+    isFlushing = false;
+    constructor(options) {
+        this.options = options;
+    }
+    enqueue(messages) {
+        return new Promise((resolve, reject) => {
+            this.buffer.push({ messages, resolve, reject });
+            this.flush();
+        });
+    }
+    async flush() {
+        if (this.isFlushing)
+            return;
+        this.isFlushing = true;
+        const { cluster, state, nodeId, maxBatchSize } = this.options;
+        while (true) {
+            const batch = [];
+            const resolvers = [];
+            const rejecters = [];
+            while (this.head < this.buffer.length) {
+                const entry = this.buffer[this.head++];
+                batch.push(...entry.messages);
+                resolvers.push(entry.resolve);
+                rejecters.push(entry.reject);
+                const nextLength = this.buffer[this.head]?.messages.length ?? 0;
+                if (batch.length + nextLength > maxBatchSize) {
+                    break;
+                }
+            }
+            if (!batch.length)
+                break;
+            this.compactBuffer();
+            const topicPartitionMessages = {};
+            batch.forEach((message) => {
+                topicPartitionMessages[message.topic] ??= {};
+                topicPartitionMessages[message.topic][message.partition] ??= [];
+                topicPartitionMessages[message.topic][message.partition].push(message);
+            });
+            const defaultTimestamp = BigInt(Date.now());
+            const topicData = Object.entries(topicPartitionMessages).map(([topic, partitionMessages]) => ({
+                name: topic,
+                partitionData: Object.entries(partitionMessages).map(([partition, messages]) => {
+                    const partitionIndex = parseInt(partition);
+                    let baseTimestamp;
+                    let maxTimestamp;
+                    messages.forEach(({ timestamp = defaultTimestamp }) => {
+                        if (!baseTimestamp || timestamp < baseTimestamp) {
+                            baseTimestamp = timestamp;
+                        }
+                        if (!maxTimestamp || timestamp > maxTimestamp) {
+                            maxTimestamp = timestamp;
+                        }
+                    });
+                    return {
+                        index: partitionIndex,
+                        baseOffset: 0n,
+                        partitionLeaderEpoch: -1,
+                        attributes: 0,
+                        lastOffsetDelta: messages.length - 1,
+                        baseTimestamp: baseTimestamp ?? 0n,
+                        maxTimestamp: maxTimestamp ?? 0n,
+                        producerId: state.producerId,
+                        producerEpoch: 0,
+                        baseSequence: state.getSequence(topic, partitionIndex),
+                        records: messages.map((message, index) => ({
+                            attributes: 0,
+                            timestampDelta: (message.timestamp ?? defaultTimestamp) - (baseTimestamp ?? 0n),
+                            offsetDelta: index,
+                            key: message.key ?? null,
+                            value: message.value,
+                            headers: Object.entries(message.headers ?? {}).map(([key, value]) => ({
+                                key,
+                                value,
+                            })),
+                        })),
+                    };
+                }),
+            }));
+            try {
+                await cluster.sendRequestToNode(nodeId)(api_1.API.PRODUCE, {
+                    transactionalId: null,
+                    acks: -1,
+                    timeoutMs: 30000,
+                    topicData,
+                });
+                topicData.forEach(({ name, partitionData }) => {
+                    partitionData.forEach(({ index, records }) => {
+                        state.updateSequence(name, index, records.length);
+                    });
+                });
+                resolvers.forEach((resolve) => resolve());
+            }
+            catch (error) {
+                rejecters.forEach((reject) => reject(error));
+            }
+        }
+        this.isFlushing = false;
+    }
+    compactBuffer() {
+        if (this.head >= this.buffer.length) {
+            this.buffer = [];
+            this.head = 0;
+        }
+        else if (this.head > 1000 && this.head > this.buffer.length / 2) {
+            this.buffer = this.buffer.slice(this.head);
+            this.head = 0;
+        }
+    }
+}
+exports.ProducerBuffer = ProducerBuffer;

package/dist/producer/producer-state.d.ts

@@ -0,0 +1,15 @@
+import { Cluster } from "../cluster";
+type ProducerStateOptions = {
+    cluster: Cluster;
+};
+export declare class ProducerState {
+    private options;
+    producerId: bigint;
+    private producerEpoch;
+    private sequences;
+    constructor(options: ProducerStateOptions);
+    initProducerId(): Promise<void>;
+    getSequence(topic: string, partition: number): number;
+    updateSequence(topic: string, partition: number, messagesCount: number): void;
+}
+export {};

package/dist/producer/producer-state.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProducerState = void 0;
+const api_1 = require("../api");
+class ProducerState {
+    options;
+    producerId = 0n;
+    producerEpoch = 0;
+    sequences = {};
+    constructor(options) {
+        this.options = options;
+    }
+    async initProducerId() {
+        const result = await this.options.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 = {};
+    }
+    getSequence(topic, partition) {
+        return this.sequences[topic]?.[partition] ?? 0;
+    }
+    updateSequence(topic, partition, messagesCount) {
+        this.sequences[topic] ??= {};
+        this.sequences[topic][partition] ??= 0;
+        this.sequences[topic][partition] += messagesCount;
+    }
+}
+exports.ProducerState = ProducerState;