kafka-ts 1.1.6 → 1.1.8

package/dist/consumer/consumer-group.js

@@ -12,6 +12,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ConsumerGroup = void 0;
 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 tracer_1 = require("../utils/tracer");
 const trace = (0, tracer_1.createTracer)('ConsumerGroup');
 class ConsumerGroup {
@@ -28,7 +30,6 @@ class ConsumerGroup {
     }
     async init() {
         await this.findCoordinator();
-        await this.options.cluster.setSeedBroker(this.coordinatorId);
         this.memberId = '';
     }
     async join() {
@@ -61,11 +62,19 @@ class ConsumerGroup {
         }
     }
     async findCoordinator() {
-        const { coordinators } = await this.options.cluster.sendRequest(api_1.API.FIND_COORDINATOR, {
-            keyType: find_coordinator_1.KEY_TYPE.GROUP,
-            keys: [this.options.groupId],
-        });
-        this.coordinatorId = coordinators[0].nodeId;
+        try {
+            const { coordinators } = await this.options.cluster.sendRequest(api_1.API.FIND_COORDINATOR, {
+                keyType: find_coordinator_1.KEY_TYPE.GROUP,
+                keys: [this.options.groupId],
+            });
+            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;
@@ -86,11 +95,8 @@ class ConsumerGroup {
             this.memberIds = response.members.map((member) => member.memberId);
         }
         catch (error) {
-            if (error.errorCode === api_1.API_ERROR.MEMBER_ID_REQUIRED) {
-                this.memberId = error.response.memberId;
-                return this.joinGroup();
-            }
-            throw error;
+            await this.handleError(error);
+            return this.joinGroup();
         }
     }
     async syncGroup() {
@@ -108,16 +114,22 @@ class ConsumerGroup {
             }, {});
             assignments = Object.entries(memberAssignments).map(([memberId, assignment]) => ({ memberId, assignment }));
         }
-        const response = await cluster.sendRequest(api_1.API.SYNC_GROUP, {
-            groupId,
-            groupInstanceId,
-            memberId: this.memberId,
-            generationId: this.generationId,
-            protocolType: 'consumer',
-            protocolName: 'RoundRobinAssigner',
-            assignments,
-        });
-        metadata.setAssignment(response.assignments);
+        try {
+            const response = await cluster.sendRequest(api_1.API.SYNC_GROUP, {
+                groupId,
+                groupInstanceId,
+                memberId: this.memberId,
+                generationId: this.generationId,
+                protocolType: 'consumer',
+                protocolName: 'RoundRobinAssigner',
+                assignments,
+            });
+            metadata.setAssignment(response.assignments);
+        }
+        catch (error) {
+            await this.handleError(error);
+            return this.syncGroup();
+        }
     }
     async offsetFetch() {
         const { cluster, groupId, topics, metadata, offsetManager } = this.options;
@@ -135,20 +147,26 @@ class ConsumerGroup {
         };
         if (!request.groups.length)
             return;
-        const response = await cluster.sendRequest(api_1.API.OFFSET_FETCH, request);
-        const topicPartitions = {};
-        response.groups.forEach((group) => {
-            group.topics.forEach((topic) => {
-                topicPartitions[topic.name] ??= new Set();
-                topic.partitions.forEach(({ partitionIndex, committedOffset }) => {
-                    if (committedOffset >= 0) {
-                        topicPartitions[topic.name].add(partitionIndex);
-                        offsetManager.resolve(topic.name, partitionIndex, committedOffset);
-                    }
+        try {
+            const response = await cluster.sendRequest(api_1.API.OFFSET_FETCH, request);
+            const topicPartitions = {};
+            response.groups.forEach((group) => {
+                group.topics.forEach((topic) => {
+                    topicPartitions[topic.name] ??= new Set();
+                    topic.partitions.forEach(({ partitionIndex, committedOffset }) => {
+                        if (committedOffset >= 0) {
+                            topicPartitions[topic.name].add(partitionIndex);
+                            offsetManager.resolve(topic.name, partitionIndex, committedOffset);
+                        }
+                    });
                 });
             });
-        });
-        offsetManager.flush(topicPartitions);
+            offsetManager.flush(topicPartitions);
+        }
+        catch (error) {
+            await this.handleError(error);
+            return this.offsetFetch();
+        }
     }
     async offsetCommit(topicPartitions) {
         const { cluster, groupId, groupInstanceId, offsetManager, consumer } = this.options;
@@ -174,7 +192,13 @@ class ConsumerGroup {
         if (!request.topics.length) {
             return;
         }
-        await cluster.sendRequest(api_1.API.OFFSET_COMMIT, request);
+        try {
+            await cluster.sendRequest(api_1.API.OFFSET_COMMIT, request);
+        }
+        catch (error) {
+            await this.handleError(error);
+            return this.offsetCommit(topicPartitions);
+        }
         consumer.emit('offsetCommit');
     }
     async heartbeat() {
@@ -200,12 +224,27 @@ class ConsumerGroup {
             });
         }
         catch (error) {
-            if (error.errorCode === api_1.API_ERROR.FENCED_INSTANCE_ID) {
+            if (error instanceof error_1.KafkaTSApiError && error.errorCode === api_1.API_ERROR.FENCED_INSTANCE_ID) {
                 return;
             }
-            throw error;
+            await this.handleError(error);
+            return this.leaveGroup();
         }
     }
+    async handleError(error) {
+        await (0, api_1.handleApiError)(error).catch(async (error) => {
+            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.findCoordinator();
+                return;
+            }
+            if (error instanceof error_1.KafkaTSApiError && error.errorCode === api_1.API_ERROR.MEMBER_ID_REQUIRED) {
+                this.memberId = error.response.memberId;
+                return;
+            }
+            throw error;
+        });
+    }
 }
 exports.ConsumerGroup = ConsumerGroup;
 __decorate([

package/dist/consumer/consumer.d.ts

@@ -41,4 +41,7 @@ export declare class Consumer extends EventEmitter<{
     private waitForReassignment;
     private process;
     private fetch;
+    private fetchMetadata;
+    private fetchOffsets;
+    private handleError;
 }

package/dist/consumer/consumer.js

@@ -75,13 +75,12 @@ class Consumer extends events_1.default {
             : undefined;
     }
     async start() {
-        const { topics, allowTopicAutoCreation, fromTimestamp } = this.options;
         this.stopHook = undefined;
         try {
             await this.cluster.connect();
-            await this.metadata.fetchMetadata({ topics, allowTopicAutoCreation });
+            await this.fetchMetadata();
             this.metadata.setAssignment(this.metadata.getTopicPartitions());
-            await this.offsetManager.fetchOffsets({ fromTimestamp });
+            await this.fetchOffsets();
             await this.consumerGroup?.init();
         }
         catch (error) {
@@ -101,8 +100,8 @@ class Consumer extends events_1.default {
                 await this.fetchManager?.stop();
             });
         }
-        await this.consumerGroup?.leaveGroup().catch((error) => logger_1.log.debug(`Failed to leave group: ${error.message}`));
-        await this.cluster.disconnect().catch((error) => logger_1.log.debug(`Failed to disconnect: ${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() {
         const { groupId } = this.options;
@@ -129,18 +128,22 @@ class Consumer extends events_1.default {
             }
             catch (error) {
                 await this.fetchManager?.stop();
-                if (error.errorCode === api_1.API_ERROR.REBALANCE_IN_PROGRESS) {
+                if (error instanceof error_1.KafkaTSApiError && error.errorCode === api_1.API_ERROR.REBALANCE_IN_PROGRESS) {
                     logger_1.log.debug('Rebalance in progress...', { apiName: error.apiName, groupId });
                     continue;
                 }
-                if (error.errorCode === api_1.API_ERROR.FENCED_INSTANCE_ID) {
+                if (error instanceof error_1.KafkaTSApiError && error.errorCode === api_1.API_ERROR.FENCED_INSTANCE_ID) {
                     logger_1.log.debug('New consumer with the same groupInstanceId joined. Exiting the consumer...');
                     this.close();
                     break;
                 }
-                if (error instanceof error_1.ConnectionError ||
-                    (error instanceof error_1.KafkaTSApiError && error.errorCode === api_1.API_ERROR.NOT_COORDINATOR)) {
-                    logger_1.log.debug(`${error.message}. Restarting consumer...`);
+                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;
+                }
+                if (error instanceof error_1.ConnectionError) {
+                    logger_1.log.debug(`${error.message}. Restarting consumer...`, { stack: error.stack });
                     this.close().then(() => this.start());
                     break;
                 }
@@ -233,13 +236,44 @@ class Consumer extends events_1.default {
             });
         }
         catch (error) {
+            await this.handleError(error);
+            return this.fetch(nodeId, assignment);
+        }
+    }
+    async fetchMetadata() {
+        const { topics, allowTopicAutoCreation } = this.options;
+        try {
+            await this.metadata.fetchMetadata({ topics, allowTopicAutoCreation });
+        }
+        catch (error) {
+            await this.handleError(error);
+            return this.fetchMetadata();
+        }
+    }
+    async fetchOffsets() {
+        const { fromTimestamp } = this.options;
+        try {
+            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) => {
+            if (error instanceof error_1.KafkaTSApiError && error.errorCode === api_1.API_ERROR.NOT_LEADER_OR_FOLLOWER) {
+                logger_1.log.debug('Refreshing metadata', { reason: error.message });
+                await this.fetchMetadata();
+                return;
+            }
             if (error instanceof error_1.KafkaTSApiError && error.errorCode === api_1.API_ERROR.OFFSET_OUT_OF_RANGE) {
                 logger_1.log.warn('Offset out of range. Resetting offsets.');
-                await this.offsetManager.fetchOffsets({ fromTimestamp: this.options.fromTimestamp });
-                return this.fetch(nodeId, assignment);
+                await this.fetchOffsets();
+                return;
             }
             throw error;
-        }
+        });
     }
 }
 exports.Consumer = Consumer;

package/dist/consumer/metadata.d.ts

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

package/dist/consumer/metadata.js

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

package/dist/examples/src/replicator.js

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

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

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

package/dist/producer/producer.d.ts

@@ -19,8 +19,10 @@ export declare class Producer {
         acks?: -1 | 1;
     }): Promise<void>;
     close(): Promise<void>;
-    private ensureConnected;
+    private ensureProducerInitialized;
     private initProducerId;
     private getSequence;
     private updateSequence;
+    private fetchMetadata;
+    private handleError;
 }

package/dist/producer/producer.js

@@ -14,7 +14,6 @@ const api_1 = require("../api");
 const messages_to_topic_partition_leaders_1 = require("../distributors/messages-to-topic-partition-leaders");
 const partitioner_1 = require("../distributors/partitioner");
 const metadata_1 = require("../metadata");
-const delay_1 = require("../utils/delay");
 const error_1 = require("../utils/error");
 const lock_1 = require("../utils/lock");
 const logger_1 = require("../utils/logger");
@@ -41,7 +40,7 @@ class Producer {
         this.partition = this.options.partitioner({ metadata: this.metadata });
     }
     async send(messages, { acks = -1 } = {}) {
-        await this.ensureConnected();
+        await this.ensureProducerInitialized();
         const { allowTopicAutoCreation } = this.options;
         const defaultTimestamp = BigInt(Date.now());
         const topics = new Set(messages.map((message) => message.topic));
@@ -51,96 +50,74 @@ class Producer {
             return message;
         });
         const nodeTopicPartitionMessages = (0, messages_to_topic_partition_leaders_1.distributeMessagesToTopicPartitionLeaders)(partitionedMessages, this.metadata.getTopicPartitionLeaderIds());
-        try {
-            await Promise.all(Object.entries(nodeTopicPartitionMessages).map(async ([nodeId, topicPartitionMessages]) => {
-                try {
-                    await this.lock.acquire([`node:${nodeId}`], async () => {
-                        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,
+        await Promise.all(Object.entries(nodeTopicPartitionMessages).map(async ([nodeId, topicPartitionMessages]) => {
+            try {
+                await this.lock.acquire([`node:${nodeId}`], async () => {
+                    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: this.producerId,
+                                producerEpoch: 0,
+                                baseSequence: this.getSequence(topic, partitionIndex),
+                                records: messages.map((message, index) => ({
                                     attributes: 0,
-                                    lastOffsetDelta: messages.length - 1,
-                                    baseTimestamp: baseTimestamp ?? 0n,
-                                    maxTimestamp: maxTimestamp ?? 0n,
-                                    producerId: this.producerId,
-                                    producerEpoch: 0,
-                                    baseSequence: this.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,
-                                        })),
+                                    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,
                                     })),
-                                };
-                            }),
-                        }));
-                        await this.cluster.sendRequestToNode(parseInt(nodeId))(api_1.API.PRODUCE, {
-                            transactionalId: null,
-                            acks,
-                            timeoutMs: 30000,
-                            topicData,
-                        });
-                        topicData.forEach(({ name, partitionData }) => {
-                            partitionData.forEach(({ index, records }) => {
-                                this.updateSequence(name, index, records.length);
-                            });
+                                })),
+                            };
+                        }),
+                    }));
+                    await this.cluster.sendRequestToNode(parseInt(nodeId))(api_1.API.PRODUCE, {
+                        transactionalId: null,
+                        acks,
+                        timeoutMs: 30000,
+                        topicData,
+                    });
+                    topicData.forEach(({ name, partitionData }) => {
+                        partitionData.forEach(({ index, records }) => {
+                            this.updateSequence(name, index, records.length);
                         });
                     });
-                }
-                catch (error) {
-                    if (error instanceof error_1.BrokerNotAvailableError || (error instanceof error_1.KafkaTSApiError && error.errorCode === api_1.API_ERROR.NOT_LEADER_OR_FOLLOWER)) {
-                        logger_1.log.debug('Refreshing broker metadata', { reason: error.message, nodeId });
-                        await this.cluster.refreshBrokerMetadata();
-                        await this.metadata.fetchMetadata({ topics, allowTopicAutoCreation });
-                        const messages = Object.values(topicPartitionMessages).flatMap(partitionMessages => Object.values(partitionMessages).flat()).map(({ partition, ...message }) => message);
-                        return this.send(messages, { acks });
-                    }
-                    throw error;
-                }
-            }));
-        }
-        catch (error) {
-            if (error instanceof error_1.KafkaTSApiError && error.errorCode === api_1.API_ERROR.NOT_LEADER_OR_FOLLOWER) {
-                await this.metadata.fetchMetadata({ topics, allowTopicAutoCreation });
-            }
-            if (error instanceof error_1.KafkaTSApiError && error.errorCode === api_1.API_ERROR.OUT_OF_ORDER_SEQUENCE_NUMBER) {
-                await this.initProducerId();
-            }
-            logger_1.log.warn('Reconnecting producer due to an unhandled error', { error });
-            try {
-                await this.cluster.disconnect();
-                await this.cluster.connect();
+                });
             }
             catch (error) {
-                logger_1.log.warn('Failed to reconnect producer', { error });
+                await this.handleError(error);
+                const messages = Object.values(topicPartitionMessages)
+                    .flatMap((partitionMessages) => Object.values(partitionMessages).flat())
+                    .map(({ partition, ...message }) => message);
+                return this.send(messages, { acks });
             }
-            throw error;
-        }
+        }));
     }
     async close() {
         await this.cluster.disconnect();
     }
-    ensureConnected = (0, shared_1.shared)(async () => {
+    ensureProducerInitialized = (0, shared_1.shared)(async () => {
         await this.cluster.ensureConnected();
         if (!this.producerId) {
             await this.initProducerId();
@@ -159,11 +136,8 @@ class Producer {
             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;
+            await this.handleError(error);
+            return this.initProducerId();
         }
     }
     getSequence(topic, partition) {
@@ -174,6 +148,31 @@ class Producer {
         this.sequences[topic][partition] ??= 0;
         this.sequences[topic][partition] += messagesCount;
     }
+    async fetchMetadata(topics, allowTopicAutoCreation) {
+        try {
+            await this.metadata.fetchMetadata({ topics, allowTopicAutoCreation });
+        }
+        catch (error) {
+            await this.handleError(error);
+            return this.fetchMetadata(topics, allowTopicAutoCreation);
+        }
+    }
+    async handleError(error) {
+        await (0, api_1.handleApiError)(error).catch(async (error) => {
+            if (error instanceof error_1.KafkaTSApiError && error.errorCode === api_1.API_ERROR.NOT_LEADER_OR_FOLLOWER) {
+                logger_1.log.debug('Refreshing metadata', { reason: error.message });
+                const topics = Object.keys(this.metadata.getTopicPartitions());
+                await this.fetchMetadata(topics, false);
+                return;
+            }
+            if (error instanceof error_1.KafkaTSApiError && error.errorCode === api_1.API_ERROR.OUT_OF_ORDER_SEQUENCE_NUMBER) {
+                logger_1.log.debug('Out of order sequence number. Reinitializing producer ID');
+                await this.initProducerId();
+                return;
+            }
+            throw error;
+        });
+    }
 }
 exports.Producer = Producer;
 __decorate([