@platformatic/kafka 2.11.0 → 2.12.1

package/dist/clients/consumer/messages-stream.js

@@ -5,7 +5,7 @@ import { consumerReceivesChannel, createDiagnosticContext, notifyCreation } from
 import { findErrorBy, protocolErrors, UserError } from "../../errors.js";
 import { IS_CONTROL } from "../../protocol/records.js";
 import { runAsyncSeries } from "../../registries/abstract.js";
-import { kAutocommit, kDeserializationError, kGetFetchNode, kInstance, kRefreshOffsetsAndFetch } from "../../symbols.js";
+import { kAutocommit, kDeserializationError, kGetFetchNode, kInstance, kRefreshOffsetsAndFetch, kUpdateCommittedOffset } from "../../symbols.js";
 import { kConnections, kCreateConnectionPool, kInspect, kPrometheus } from "../base/base.js";
 import { ensureMetric } from "../metrics.js";
 import { defaultConsumerOptions } from "./options.js";
@@ -49,6 +49,7 @@ export class MessagesStream extends Readable {
     #offsetsToFetch;
     #offsetsToCommit;
     #offsetsCommitted;
+    #commitWaiters;
     #partitionsEpochs;
     #inflightNodes;
     #keyDeserializer;
@@ -109,6 +110,7 @@ export class MessagesStream extends Readable {
         this.#fallbackMode = fallbackMode ?? MessagesStreamFallbackModes.LATEST;
         this.#offsetsToCommit = new Map();
         this.#offsetsCommitted = new Map();
+        this.#commitWaiters = new Map();
         this.#partitionsEpochs = new Map();
         this.#paused = false;
         this.#refreshOffsetsInflight = false;
@@ -135,6 +137,13 @@ export class MessagesStream extends Readable {
             this.#offsetsCommitted.clear();
             this.#partitionsEpochs.clear();
             this.#scheduleRefreshOffsetsAndFetch();
+            // [kAutocommit] skips flushing while mid-rejoin to avoid triggering a rejoin storm (see
+            // below), leaving any queued offset waiting for the next tick of the autocommit timer.
+            // With autocommit disabled there is no such timer, so a manual commit requested during a
+            // rebalance would otherwise never resolve. Flush now that the rejoin has completed.
+            if (this.#offsetsToCommit.size > 0) {
+                this[kAutocommit]();
+            }
         };
         this.#onBrokerDisconnect = () => {
             this.#partitionsEpochs.clear();
@@ -159,7 +168,8 @@ export class MessagesStream extends Readable {
         this.#options = structuredClone(otherOptions);
         // Start the autocommit interval
         if (typeof autocommit === 'number' && autocommit > 0) {
-            this.#autocommitInterval = setInterval(this[kAutocommit].bind(this), autocommit);
+            // Invoke without a callback so the timer path keeps the mid-rejoin skip in [kAutocommit].
+            this.#autocommitInterval = setInterval(() => this[kAutocommit](), autocommit);
         }
         else {
             this.#autocommitInterval = null;
@@ -769,31 +779,89 @@ export class MessagesStream extends Readable {
             this.push(null);
         }
     }
-    #updateCommittedOffset(topic, partition, offset) {
+    [kUpdateCommittedOffset](topic, partition, offset) {
         const key = partitionKey(topic, partition);
         const previous = this.#offsetsCommitted.get(key);
         if (typeof previous === 'undefined' || previous < offset) {
             this.#offsetsCommitted.set(key, offset);
         }
     }
-    // This could optimized to only schedule once per tick on a topic-partition and only commit the latest offset
+    // Manual commits share offsetsToCommit/autocommitInflight with kAutocommit instead of
+    // calling Consumer#commit directly. A raw one-shot call here has no way to stop two
+    // concurrent commits on the same partition from racing: whichever response the broker
+    // processes last wins regardless of offset value, so a lower offset can silently overwrite
+    // a higher one that already landed. Funnelling through the same single-flight/monotonic-merge
+    // machinery as autocommit coalesces same-partition calls into one in-flight request.
     #commit(topic, partition, offset, leaderEpoch, callback) {
         if (!callback) {
             callback = createPromisifiedCallback();
         }
-        this.#consumer.commit({ offsets: [{ topic, partition, offset, leaderEpoch }] }, error => {
-            /* c8 ignore next 4 - Hard to test */
-            if (error) {
-                callback(error);
-                return;
-            }
-            this.#updateCommittedOffset(topic, partition, offset);
-            callback(null);
-        });
+        const key = partitionKey(topic, partition);
+        const current = this.#offsetsToCommit.get(key);
+        if (!current || current.offset < offset) {
+            this.#offsetsToCommit.set(key, { topic, partition, offset, leaderEpoch });
+        }
+        let waiters = this.#commitWaiters.get(key);
+        if (!waiters) {
+            waiters = [];
+            this.#commitWaiters.set(key, waiters);
+        }
+        waiters.push({ offset, callback: callback });
+        this[kAutocommit]();
         return callback[kCallbackPromise];
     }
-    [kAutocommit]() {
+    // Settles every waiter whose requested offset is covered by a commit that just landed for
+    // its partition (offset is the monotonic max merged from possibly several manual commits, so
+    // it covers every waiter queued before this flush's snapshot was taken). A waiter added after
+    // the snapshot keeps waiting for the next flush, triggered by the caller of this method.
+    #settleCommitWaiters(topic, partition, offset, error) {
+        const key = partitionKey(topic, partition);
+        const waiters = this.#commitWaiters.get(key);
+        if (!waiters) {
+            return;
+        }
+        const remaining = [];
+        for (const waiter of waiters) {
+            if (waiter.offset <= offset) {
+                waiter.callback(error);
+            }
+            else {
+                remaining.push(waiter);
+            }
+        }
+        if (remaining.length > 0) {
+            this.#commitWaiters.set(key, remaining);
+        }
+        else {
+            this.#commitWaiters.delete(key);
+        }
+    }
+    [kAutocommit](callback) {
+        // A commit is already running: report its outcome to the caller rather than
+        // starting a second one, so a cooperative rebalance waits for the in-flight
+        // commit instead of proceeding as if nothing was pending.
+        if (this.#autocommitInflight) {
+            if (callback) {
+                // A commit which fails with a rejoin-required error destroys the stream, and a destroyed
+                // stream never emits 'autocommit' again. Settle on whichever comes first so an awaiting
+                // rebalance cannot deadlock on a stream that is going away.
+                const onAutocommit = (error) => {
+                    this.removeListener('close', onClose);
+                    callback(error);
+                };
+                const onClose = () => {
+                    this.removeListener('autocommit', onAutocommit);
+                    callback(null);
+                };
+                this.once('autocommit', onAutocommit);
+                this.once('close', onClose);
+            }
+            // Any offset queued by a manual commit while this flush is in flight is picked up by
+            // the follow-up flush triggered right after this one settles (see below).
+            return;
+        }
         if (this.#offsetsToCommit.size === 0) {
+            callback?.(null);
             return;
         }
         // Skip this tick while the consumer is mid-(re)join: a commit attempted here would fail
@@ -803,7 +871,10 @@ export class MessagesStream extends Readable {
         // consumers in the group, this can fire fresh JoinGroups fast enough that the group never
         // completes a rebalance round. Leave the offsets queued; they are committed once the
         // consumer becomes active again (next tick, or the final flush on close/destroy).
-        if (!this.#consumer.isActive()) {
+        // A caller-supplied callback means an explicitly requested flush (the cooperative rebalance
+        // commits before revoking partitions) rather than a timer tick: it awaits this commit
+        // instead of rejoining on failure, so it must not be skipped or the revoked offsets are lost.
+        if (!callback && !this.#consumer.isActive()) {
             return;
         }
         this.#autocommitInflight = true;
@@ -817,14 +888,53 @@ export class MessagesStream extends Readable {
                 // (ILLEGAL_GENERATION, UNKNOWN_MEMBER_ID, REBALANCE_IN_PROGRESS).
                 // Transient coordinator errors must not tear down the consumption loop.
                 if (findErrorBy(error, 'needsRejoin', true)) {
+                    // The stream is going away: every pending manual commit, for every partition, must be
+                    // rejected now, since a destroyed stream never gets another chance to flush them.
+                    for (const waiters of this.#commitWaiters.values()) {
+                        for (const waiter of waiters) {
+                            waiter.callback(error);
+                        }
+                    }
+                    this.#commitWaiters.clear();
                     this.destroy(error);
                 }
+                else {
+                    // Keep offsets produced while the commit was in flight, and retry the failed snapshot
+                    // without replacing a newer offset for the same partition.
+                    for (const offset of offsets) {
+                        const key = partitionKey(offset.topic, offset.partition);
+                        const current = this.#offsetsToCommit.get(key);
+                        if (!current || current.offset < offset.offset) {
+                            this.#offsetsToCommit.set(key, offset);
+                        }
+                    }
+                    // Report the failure to whichever manual commits were part of this snapshot. The
+                    // offset stays queued above and is retried by the next flush regardless.
+                    for (const offset of offsets) {
+                        this.#settleCommitWaiters(offset.topic, offset.partition, offset.offset, error);
+                    }
+                    // A manual commit queued for a different, newer offset while this flush was in
+                    // flight was not part of the failed snapshot and must not wait on this stream's
+                    // autocommit timer (or never, if autocommit is disabled) to get its own attempt.
+                    if (this.#commitWaiters.size > 0) {
+                        this[kAutocommit]();
+                    }
+                }
+                callback?.(error);
                 return;
             }
             for (const { topic, partition, offset } of offsets) {
-                this.#updateCommittedOffset(topic, partition, offset);
+                this[kUpdateCommittedOffset](topic, partition, offset);
+                this.#settleCommitWaiters(topic, partition, offset, null);
             }
             this.emit('autocommit', null, offsets);
+            callback?.(null);
+            // A manual commit queued while this flush was in flight is still waiting: its offset
+            // was not part of the snapshot above, so drive another flush now instead of leaving it
+            // stranded until the next autocommit tick.
+            if (this.#commitWaiters.size > 0) {
+                this[kAutocommit]();
+            }
         });
     }
     #refreshOffsets(callback) {

package/dist/clients/consumer/partitions-assigners.d.ts

@@ -1,3 +1,6 @@
 import { type ClusterMetadata } from '../base/types.ts';
 import { type ExtendedGroupProtocolSubscription, type GroupPartitionsAssignments } from './types.ts';
+export declare const ROUNDROBIN_ASSIGNOR = "roundrobin";
+export declare const COOPERATIVE_STICKY_ASSIGNOR = "cooperative-sticky";
 export declare function roundRobinAssigner(_current: string, members: Map<string, ExtendedGroupProtocolSubscription>, topics: Set<string>, metadata: ClusterMetadata): GroupPartitionsAssignments[];
+export declare function cooperativeStickyAssigner(_current: string, members: Map<string, ExtendedGroupProtocolSubscription>, topics: Set<string>, metadata: ClusterMetadata): GroupPartitionsAssignments[];

package/dist/clients/consumer/partitions-assigners.js

@@ -1,3 +1,5 @@
+export const ROUNDROBIN_ASSIGNOR = 'roundrobin';
+export const COOPERATIVE_STICKY_ASSIGNOR = 'cooperative-sticky';
 export function roundRobinAssigner(_current, members, topics, metadata) {
     const membersSize = members.size;
     const assignments = [];
@@ -21,3 +23,260 @@ export function roundRobinAssigner(_current, members, topics, metadata) {
     }
     return assignments;
 }
+function topicPartitionKey({ topic, partition }) {
+    return `${topic}:${partition}`;
+}
+function parseTopicPartitionKey(key) {
+    const index = key.lastIndexOf(':');
+    return {
+        topic: key.slice(0, index),
+        partition: Number(key.slice(index + 1))
+    };
+}
+function compareTopicPartitions(left, right) {
+    const topicComparison = left.topic.localeCompare(right.topic);
+    return topicComparison === 0 ? left.partition - right.partition : topicComparison;
+}
+function flattenAssignments(assignments) {
+    const partitions = [];
+    for (const assignment of assignments) {
+        for (const partition of assignment.partitions) {
+            partitions.push({ topic: assignment.topic, partition });
+        }
+    }
+    return partitions;
+}
+function assignmentSize(assignments) {
+    let size = 0;
+    for (const assignment of assignments.values()) {
+        size += assignment.partitions.length;
+    }
+    return size;
+}
+function sortedMemberIds(assignments) {
+    return [...assignments.keys()].sort();
+}
+function assignedPartitionKeys(assignments) {
+    const assigned = new Set();
+    for (const memberAssignments of assignments.values()) {
+        for (const partition of flattenAssignments(Array.from(memberAssignments.values()))) {
+            assigned.add(topicPartitionKey(partition));
+        }
+    }
+    return assigned;
+}
+function addAssignment(assignments, memberId, partition) {
+    const memberAssignments = assignments.get(memberId);
+    let topicAssignment = memberAssignments.get(partition.topic);
+    if (!topicAssignment) {
+        topicAssignment = { topic: partition.topic, partitions: [] };
+        memberAssignments.set(partition.topic, topicAssignment);
+    }
+    if (!topicAssignment.partitions.includes(partition.partition)) {
+        topicAssignment.partitions.push(partition.partition);
+        topicAssignment.partitions.sort((a, b) => a - b);
+    }
+}
+function removeAssignment(assignments, memberId, partition) {
+    const memberAssignments = assignments.get(memberId);
+    const topicAssignment = memberAssignments?.get(partition.topic);
+    if (!topicAssignment) {
+        return;
+    }
+    topicAssignment.partitions = topicAssignment.partitions.filter(current => current !== partition.partition);
+    if (topicAssignment.partitions.length === 0) {
+        memberAssignments.delete(partition.topic);
+    }
+}
+function createEmptyAssignments(members) {
+    const assignments = new Map();
+    for (const memberId of members.keys()) {
+        assignments.set(memberId, new Map());
+    }
+    return assignments;
+}
+function hasEligibleMember(members, topic) {
+    for (const member of members.values()) {
+        if (member.topics?.includes(topic)) {
+            return true;
+        }
+    }
+    return false;
+}
+function listAssignablePartitions(members, topics, metadata) {
+    const result = [];
+    for (const topic of [...topics].sort()) {
+        const topicMetadata = metadata.topics.get(topic);
+        if (!topicMetadata || !hasEligibleMember(members, topic)) {
+            continue;
+        }
+        for (let partition = 0; partition < topicMetadata.partitionsCount; partition++) {
+            result.push({ topic, partition });
+        }
+    }
+    return result;
+}
+function previousOwnership(members, allPartitions) {
+    const validPartitions = new Set(allPartitions.map(topicPartitionKey));
+    const maxGeneration = Math.max(-1, ...Array.from(members.values(), member => member.generationId ?? -1));
+    const claims = new Map();
+    for (const [memberId, member] of members) {
+        const generationId = member.generationId ?? -1;
+        if (maxGeneration >= 0 && generationId < maxGeneration) {
+            continue;
+        }
+        for (const owned of member.ownedPartitions ?? []) {
+            if (!member.topics?.includes(owned.topic)) {
+                continue;
+            }
+            for (const partition of owned.partitions) {
+                const topicPartition = { topic: owned.topic, partition };
+                const key = topicPartitionKey(topicPartition);
+                if (!validPartitions.has(key)) {
+                    continue;
+                }
+                let partitionClaims = claims.get(key);
+                if (!partitionClaims) {
+                    partitionClaims = [];
+                    claims.set(key, partitionClaims);
+                }
+                partitionClaims.push({ memberId, generationId });
+            }
+        }
+    }
+    const owners = new Map();
+    const contested = new Set();
+    for (const [key, partitionClaims] of claims) {
+        const highestGeneration = Math.max(...partitionClaims.map(claim => claim.generationId));
+        const highestGenerationClaims = partitionClaims.filter(claim => claim.generationId === highestGeneration);
+        // If two members claim the same partition in the same generation, neither
+        // claim can be trusted. This mirrors the Kafka assignor's safety check.
+        if (highestGenerationClaims.length === 1) {
+            owners.set(key, highestGenerationClaims[0].memberId);
+        }
+        else {
+            contested.add(key);
+        }
+    }
+    return { owners, contested };
+}
+function leastLoadedEligibleMember(assignments, members, partition) {
+    let selected = null;
+    let selectedSize = Number.POSITIVE_INFINITY;
+    for (const memberId of sortedMemberIds(assignments)) {
+        const member = members.get(memberId);
+        if (!member.topics?.includes(partition.topic)) {
+            continue;
+        }
+        const size = assignmentSize(assignments.get(memberId));
+        if (size < selectedSize) {
+            selected = memberId;
+            selectedSize = size;
+        }
+    }
+    return selected;
+}
+function removablePartition(assignments, targetMember) {
+    const partitions = flattenAssignments(Array.from(assignments.values())).sort(compareTopicPartitions);
+    for (const partition of partitions) {
+        if (targetMember.topics?.includes(partition.topic)) {
+            return partition;
+        }
+    }
+    return null;
+}
+function assignUnassignedPartitions(assignments, members, allPartitions) {
+    const assigned = assignedPartitionKeys(assignments);
+    for (const partition of allPartitions) {
+        if (assigned.has(topicPartitionKey(partition))) {
+            continue;
+        }
+        const memberId = leastLoadedEligibleMember(assignments, members, partition);
+        if (memberId) {
+            addAssignment(assignments, memberId, partition);
+            assigned.add(topicPartitionKey(partition));
+        }
+    }
+}
+function balanceAssignments(assignments, members) {
+    const totalPartitions = assignedPartitionKeys(assignments).size;
+    if (totalPartitions === 0 || members.size === 0) {
+        return;
+    }
+    const minQuota = Math.floor(totalPartitions / members.size);
+    const maxQuota = Math.ceil(totalPartitions / members.size);
+    while (true) {
+        const underloadedMembers = sortedMemberIds(assignments).filter(memberId => assignmentSize(assignments.get(memberId)) < minQuota);
+        const overloadedMembers = sortedMemberIds(assignments)
+            .filter(memberId => assignmentSize(assignments.get(memberId)) > maxQuota)
+            .sort((left, right) => assignmentSize(assignments.get(right)) - assignmentSize(assignments.get(left)));
+        if (underloadedMembers.length === 0 || overloadedMembers.length === 0) {
+            return;
+        }
+        let moved = false;
+        for (const underloaded of underloadedMembers) {
+            for (const overloaded of overloadedMembers) {
+                const partition = removablePartition(assignments.get(overloaded), members.get(underloaded));
+                if (!partition) {
+                    continue;
+                }
+                removeAssignment(assignments, overloaded, partition);
+                addAssignment(assignments, underloaded, partition);
+                moved = true;
+                break;
+            }
+            if (moved) {
+                break;
+            }
+        }
+        if (!moved) {
+            return;
+        }
+    }
+}
+function adjustCooperativeTransfers(assignments, members, previousOwners, contestedPreviousOwners) {
+    const added = new Map();
+    const revoked = new Set();
+    for (const [memberId, memberAssignments] of assignments) {
+        const trustedOwned = new Set(flattenAssignments(members.get(memberId)?.ownedPartitions ?? [])
+            .map(topicPartitionKey)
+            .filter(key => previousOwners.get(key) === memberId));
+        const claimedOwned = new Set(flattenAssignments(members.get(memberId)?.ownedPartitions ?? [])
+            .map(topicPartitionKey)
+            .filter(key => previousOwners.get(key) === memberId || contestedPreviousOwners.has(key)));
+        const assigned = new Set(flattenAssignments(Array.from(memberAssignments.values())).map(topicPartitionKey));
+        for (const key of assigned) {
+            if (!trustedOwned.has(key)) {
+                added.set(key, memberId);
+            }
+        }
+        for (const key of claimedOwned) {
+            if (!assigned.has(key)) {
+                revoked.add(key);
+            }
+        }
+    }
+    for (const [key, memberId] of added) {
+        if (revoked.has(key)) {
+            removeAssignment(assignments, memberId, parseTopicPartitionKey(key));
+        }
+    }
+}
+export function cooperativeStickyAssigner(_current, members, topics, metadata) {
+    const assignments = createEmptyAssignments(members);
+    const allPartitions = listAssignablePartitions(members, topics, metadata);
+    const { owners: previousOwners, contested: contestedPreviousOwners } = previousOwnership(members, allPartitions);
+    for (const partition of allPartitions) {
+        const owner = previousOwners.get(topicPartitionKey(partition));
+        if (owner) {
+            addAssignment(assignments, owner, partition);
+        }
+    }
+    assignUnassignedPartitions(assignments, members, allPartitions);
+    balanceAssignments(assignments, members);
+    adjustCooperativeTransfers(assignments, members, previousOwners, contestedPreviousOwners);
+    return Array.from(assignments, ([memberId, memberAssignments]) => ({
+        memberId,
+        assignments: memberAssignments
+    }));
+}

package/dist/clients/consumer/types.d.ts

@@ -11,6 +11,10 @@ export interface GroupProtocolSubscription {
     version: number;
     metadata?: Buffer | string;
 }
+export interface TopicPartitionAssignment {
+    topic: string;
+    partition: number;
+}
 export interface GroupAssignment {
     topic: string;
     partitions: number[];
@@ -21,6 +25,9 @@ export interface GroupPartitionsAssignments {
 }
 export interface ExtendedGroupProtocolSubscription extends Omit<GroupProtocolSubscription, 'name'> {
     topics?: string[];
+    ownedPartitions?: GroupAssignment[];
+    generationId?: number;
+    rackId?: string | null;
     memberId: string;
 }
 export type Offsets = Map<string, bigint[]>;
@@ -163,6 +170,10 @@ export interface ConsumerGroupLeavePayload {
 export interface ConsumerGroupRebalancePayload {
     groupId: string;
 }
+export interface ConsumerGroupAutocommitErrorPayload {
+    groupId: string;
+    error: Error;
+}
 export interface ConsumerHeartbeatPayload {
     groupId?: string;
     memberId?: string | null;

package/dist/clients/producer/producer.d.ts

@@ -15,8 +15,8 @@ export declare class Producer<Key = Buffer, Value = Buffer, HeaderKey = Buffer,
     get transaction(): Transaction<Key, Value, HeaderKey, HeaderValue> | undefined;
     get coordinatorId(): number | undefined;
     get streamsCount(): number;
-    close(force: boolean | CallbackWithPromise<void>, callback?: CallbackWithPromise<void>): void;
     close(force?: boolean): Promise<void>;
+    close(force: boolean | CallbackWithPromise<void>, callback?: CallbackWithPromise<void>): void;
     initIdempotentProducer(options: ProduceOptions<Key, Value, HeaderKey, HeaderValue>, callback: CallbackWithPromise<ProducerInfo>): void;
     initIdempotentProducer(options: ProduceOptions<Key, Value, HeaderKey, HeaderValue>): Promise<ProducerInfo>;
     send(options: SendOptions<Key, Value, HeaderKey, HeaderValue> & {

package/dist/clients/producer/producer.js

@@ -752,7 +752,7 @@ export class Producer extends Base {
         const { topic, partition } = messages[0];
         let refreshMetadata = false;
         this[kPerformWithRetry]('produce', retryCallback => {
-            this[kMetadata]({ topics, autocreateTopics, forceUpdate: refreshMetadata }, (error, metadata) => {
+            this[kMetadata]({ topics, autocreateTopics, forceUpdate: refreshMetadata, retries: 0 }, (error, metadata) => {
                 if (error) {
                     refreshMetadata = NetworkError.isRetryable(error);
                     retryCallback(error);

package/dist/errors.js

@@ -142,10 +142,21 @@ export class ProtocolError extends GenericError {
                 'NOT_LEADER_OR_FOLLOWER',
                 'FENCED_LEADER_EPOCH'
             ].includes(id),
-            needsRejoin: ['MEMBER_ID_REQUIRED', 'UNKNOWN_MEMBER_ID', 'REBALANCE_IN_PROGRESS', 'ILLEGAL_GENERATION'].includes(id),
+            needsRejoin: [
+                'MEMBER_ID_REQUIRED',
+                'UNKNOWN_MEMBER_ID',
+                'REBALANCE_IN_PROGRESS',
+                'ILLEGAL_GENERATION',
+                'FENCED_INSTANCE_ID'
+            ].includes(id),
             producerFenced: id === 'INVALID_PRODUCER_EPOCH',
             rebalanceInProgress: id === 'REBALANCE_IN_PROGRESS',
             unknownMemberId: id === 'UNKNOWN_MEMBER_ID',
+            // A fenced static member's id is permanently dead — another process already claimed
+            // this group.instance.id — so, like UNKNOWN_MEMBER_ID, the cached memberId must be
+            // dropped before rejoining. Without this, the client keeps resending the same invalid
+            // id and the broker rejects it forever (see #getRejoinError in consumer.ts).
+            fencedInstanceId: id === 'FENCED_INSTANCE_ID',
             memberId: response?.memberId,
             ...properties
         });

package/dist/network/connection.d.ts

@@ -94,6 +94,6 @@ export declare class Connection extends TypedEventEmitter<ConnectionEvents> {
     ready(): Promise<void>;
     close(callback: CallbackWithPromise<void>): void;
     close(): Promise<void>;
-    send<ReturnType>(apiKey: number, apiVersion: number, createPayload: () => Writer, responseParser: ResponseParser<ReturnType>, hasRequestHeaderTaggedFields: boolean, hasResponseHeaderTaggedFields: boolean, callback: Callback<ReturnType>): void;
+    send<ReturnType>(apiKey: number, apiVersion: number, createPayload: () => Writer | Promise<Writer>, responseParser: ResponseParser<ReturnType>, hasRequestHeaderTaggedFields: boolean, hasResponseHeaderTaggedFields: boolean, callback: Callback<ReturnType>): void;
     reauthenticate(): void;
 }