@platformatic/kafka 0.1.0

package/dist/clients/consumer/consumer.js

@@ -0,0 +1,767 @@
+import { api as fetchV17 } from "../../apis/consumer/fetch.js";
+import { api as heartbeatV4 } from "../../apis/consumer/heartbeat.js";
+import { api as joinGroupV9 } from "../../apis/consumer/join-group.js";
+import { api as leaveGroupV5 } from "../../apis/consumer/leave-group.js";
+import { api as listOffsetsV9 } from "../../apis/consumer/list-offsets.js";
+import { api as offsetCommitV9 } from "../../apis/consumer/offset-commit.js";
+import { api as offsetFetchV9 } from "../../apis/consumer/offset-fetch.js";
+import { api as syncGroupV5 } from "../../apis/consumer/sync-group.js";
+import { FetchIsolationLevels, FindCoordinatorKeyTypes } from "../../apis/enumerations.js";
+import { api as findCoordinatorV6 } from "../../apis/metadata/find-coordinator.js";
+import { UserError } from "../../errors.js";
+import { Reader } from "../../protocol/reader.js";
+import { Writer } from "../../protocol/writer.js";
+import { Base, kBootstrapBrokers, kCheckNotClosed, kClosed, kConnections, kCreateConnectionPool, kMetadata, kOptions, kPerformDeduplicated, kPerformWithRetry, kValidateOptions } from "../base/base.js";
+import { defaultBaseOptions } from "../base/options.js";
+import { createPromisifiedCallback, kCallbackPromise, runConcurrentCallbacks } from "../callbacks.js";
+import { MessagesStream } from "./messages-stream.js";
+import { commitOptionsValidator, consumeOptionsValidator, consumerOptionsValidator, defaultConsumerOptions, fetchOptionsValidator, groupOptionsValidator, listCommitsOptionsValidator, listOffsetsOptionsValidator } from "./options.js";
+import { TopicsMap } from "./topics-map.js";
+export class Consumer extends Base {
+    groupId;
+    generationId;
+    memberId;
+    topics;
+    assignments;
+    #members;
+    #membershipActive;
+    #isLeader;
+    #protocol;
+    #coordinatorId;
+    #heartbeatInterval;
+    #streams;
+    /*
+      The following requests are blocking in Kafka:
+  
+      FetchRequest (soprattutto con maxWaitMs)
+      JoinGroupRequest
+      SyncGroupRequest
+      OffsetCommitRequest
+      ProduceRequest
+      ListOffsetsRequest
+      ListGroupsRequest
+      DescribeGroupsRequest
+  
+      In order to avoid consumer group problems, we separate FetchRequest only on a separate connection.
+    */
+    #fetchConnectionPool;
+    constructor(options) {
+        super(options);
+        this[kOptions] = Object.assign({}, defaultBaseOptions, defaultConsumerOptions, options);
+        this[kValidateOptions](options, consumerOptionsValidator, '/options');
+        this.groupId = options.groupId;
+        this.generationId = 0;
+        this.memberId = null;
+        this.topics = new TopicsMap();
+        this.assignments = null;
+        this.#members = new Map();
+        this.#membershipActive = false;
+        this.#isLeader = false;
+        this.#protocol = null;
+        this.#coordinatorId = null;
+        this.#heartbeatInterval = null;
+        this.#streams = new Set();
+        this.#validateGroupOptions(this[kOptions]);
+        // Initialize connection pool
+        this.#fetchConnectionPool = this[kCreateConnectionPool]();
+    }
+    close(force, callback) {
+        if (typeof force === 'function') {
+            callback = force;
+            force = false;
+        }
+        if (!callback) {
+            callback = createPromisifiedCallback();
+        }
+        if (this[kClosed]) {
+            callback(null);
+            return callback[kCallbackPromise];
+        }
+        this[kClosed] = true;
+        const closer = this.#membershipActive
+            ? this.#leaveGroup.bind(this)
+            : function (_, callback) {
+                callback(null);
+            };
+        closer(force, error => {
+            if (error) {
+                callback(error);
+                return;
+            }
+            this.#fetchConnectionPool.close(error => {
+                if (error) {
+                    callback(error);
+                    return;
+                }
+                super.close(callback);
+            });
+        });
+        return callback[kCallbackPromise];
+    }
+    consume(options, callback) {
+        if (!callback) {
+            callback = createPromisifiedCallback();
+        }
+        if (this[kCheckNotClosed](callback)) {
+            return callback[kCallbackPromise];
+        }
+        const validationError = this[kValidateOptions](options, consumeOptionsValidator, '/options', false);
+        if (validationError) {
+            callback(validationError, undefined);
+            return callback[kCallbackPromise];
+        }
+        options.autocommit ??= this[kOptions].autocommit ?? true;
+        options.maxBytes ??= this[kOptions].maxBytes;
+        options.deserializers = Object.assign({}, options.deserializers, this[kOptions].deserializers);
+        options.highWaterMark ??= this[kOptions].highWaterMark;
+        this.#consume(options, callback);
+        return callback[kCallbackPromise];
+    }
+    fetch(options, callback) {
+        if (!callback) {
+            callback = createPromisifiedCallback();
+        }
+        if (this[kCheckNotClosed](callback)) {
+            return callback[kCallbackPromise];
+        }
+        const validationError = this[kValidateOptions](options, fetchOptionsValidator, '/options', false);
+        if (validationError) {
+            callback(validationError, undefined);
+            return callback[kCallbackPromise];
+        }
+        this.#fetch(options, callback);
+        return callback[kCallbackPromise];
+    }
+    commit(options, callback) {
+        if (!callback) {
+            callback = createPromisifiedCallback();
+        }
+        if (this[kCheckNotClosed](callback)) {
+            return callback[kCallbackPromise];
+        }
+        const validationError = this[kValidateOptions](options, commitOptionsValidator, '/options', false);
+        if (validationError) {
+            callback(validationError);
+            return callback[kCallbackPromise];
+        }
+        this.#commit(options, callback);
+        return callback[kCallbackPromise];
+    }
+    listOffsets(options, callback) {
+        if (!callback) {
+            callback = createPromisifiedCallback();
+        }
+        if (this[kCheckNotClosed](callback)) {
+            return callback[kCallbackPromise];
+        }
+        const validationError = this[kValidateOptions](options, listOffsetsOptionsValidator, '/options', false);
+        if (validationError) {
+            callback(validationError, undefined);
+            return callback[kCallbackPromise];
+        }
+        this.#listOffsets(options, callback);
+        return callback[kCallbackPromise];
+    }
+    listCommittedOffsets(options, callback) {
+        if (!callback) {
+            callback = createPromisifiedCallback();
+        }
+        if (this[kCheckNotClosed](callback)) {
+            return callback[kCallbackPromise];
+        }
+        const validationError = this[kValidateOptions](options, listCommitsOptionsValidator, '/options', false);
+        if (validationError) {
+            callback(validationError, undefined);
+            return callback[kCallbackPromise];
+        }
+        this.#listCommittedOffsets(options, callback);
+        return callback[kCallbackPromise];
+    }
+    findGroupCoordinator(callback) {
+        if (!callback) {
+            callback = createPromisifiedCallback();
+        }
+        if (this[kCheckNotClosed](callback)) {
+            return callback[kCallbackPromise];
+        }
+        if (this.#coordinatorId) {
+            callback(null, this.#coordinatorId);
+            return callback[kCallbackPromise];
+        }
+        this.#findGroupCoordinator(callback);
+        return callback[kCallbackPromise];
+    }
+    joinGroup(options, callback) {
+        if (!callback) {
+            callback = createPromisifiedCallback();
+        }
+        if (this[kCheckNotClosed](callback)) {
+            return callback[kCallbackPromise];
+        }
+        const validationError = this[kValidateOptions](options, groupOptionsValidator, '/options', false);
+        if (validationError) {
+            callback(validationError, undefined);
+            return callback[kCallbackPromise];
+        }
+        options.sessionTimeout ??= this[kOptions].sessionTimeout;
+        options.rebalanceTimeout ??= this[kOptions].rebalanceTimeout;
+        options.heartbeatInterval ??= this[kOptions].heartbeatInterval;
+        options.protocols ??= this[kOptions].protocols;
+        this.#validateGroupOptions(options);
+        this.#membershipActive = true;
+        this.#joinGroup(options, callback);
+        return callback[kCallbackPromise];
+    }
+    leaveGroup(force, callback) {
+        if (typeof force === 'function') {
+            callback = force;
+            force = false;
+        }
+        if (!callback) {
+            callback = createPromisifiedCallback();
+        }
+        if (this[kCheckNotClosed](callback)) {
+            return callback[kCallbackPromise];
+        }
+        this.#membershipActive = false;
+        this.#leaveGroup(force, callback);
+        return callback[kCallbackPromise];
+    }
+    #consume(options, callback) {
+        // Subscribe all topics
+        let joinNeeded = this.memberId === null;
+        for (const topic of options.topics) {
+            if (this.topics.track(topic)) {
+                joinNeeded = true;
+            }
+        }
+        // If we need to (re)join the group, do that first and then try again
+        if (joinNeeded) {
+            this.joinGroup(options, error => {
+                if (error) {
+                    callback(error, undefined);
+                    return;
+                }
+                this.#consume(options, callback);
+            });
+            return callback[kCallbackPromise];
+        }
+        // Create the stream and start consuming
+        const stream = new MessagesStream(this, options);
+        this.#streams.add(stream);
+        stream.once('close', () => {
+            this.#streams.delete(stream);
+        });
+        callback(null, stream);
+        return callback[kCallbackPromise];
+    }
+    #fetch(options, callback) {
+        this[kPerformWithRetry]('fetch', retryCallback => {
+            this[kMetadata]({ topics: this.topics.current }, (error, metadata) => {
+                if (error) {
+                    retryCallback(error, undefined);
+                    return;
+                }
+                const broker = metadata.brokers.get(options.node);
+                if (!broker) {
+                    retryCallback(new UserError(`Cannot find broker with node id ${options.node}`), undefined);
+                    return;
+                }
+                this.#fetchConnectionPool.get(broker, (error, connection) => {
+                    if (error) {
+                        retryCallback(error, undefined);
+                        return;
+                    }
+                    fetchV17(connection, options.maxWaitTime ?? this[kOptions].maxWaitTime, options.minBytes ?? this[kOptions].minBytes, options.maxBytes ?? this[kOptions].maxBytes, FetchIsolationLevels[options.isolationLevel ?? this[kOptions].isolationLevel], 0, 0, options.topics, [], '', retryCallback);
+                });
+            });
+        }, callback, 0);
+    }
+    #commit(options, callback) {
+        this.#performGroupOperation('commit', (connection, groupCallback) => {
+            const topics = new Map();
+            for (const { topic, partition, offset, leaderEpoch } of options.offsets) {
+                let topicOffsets = topics.get(topic);
+                if (!topicOffsets) {
+                    topicOffsets = { name: topic, partitions: [] };
+                    topics.set(topic, topicOffsets);
+                }
+                topicOffsets.partitions.push({
+                    partitionIndex: partition,
+                    committedOffset: offset,
+                    committedLeaderEpoch: leaderEpoch,
+                    committedMetadata: null
+                });
+            }
+            offsetCommitV9(connection, this.groupId, this.generationId, this.memberId, null, Array.from(topics.values()), groupCallback);
+        }, error => {
+            callback(error);
+        });
+    }
+    #listOffsets(options, callback) {
+        this[kMetadata]({ topics: options.topics }, (error, metadata) => {
+            if (error) {
+                callback(error, undefined);
+                return;
+            }
+            const requests = new Map();
+            for (const name of options.topics) {
+                const topic = metadata.topics.get(name);
+                for (let i = 0; i < topic.partitionsCount; i++) {
+                    const partition = topic.partitions[i];
+                    const { leader, leaderEpoch } = partition;
+                    let leaderRequests = requests.get(leader);
+                    if (!leaderRequests) {
+                        leaderRequests = new Map();
+                        requests.set(leader, leaderRequests);
+                    }
+                    let topicRequests = leaderRequests.get(name);
+                    if (!topicRequests) {
+                        topicRequests = { name, partitions: [] };
+                        leaderRequests.set(name, topicRequests);
+                    }
+                    topicRequests.partitions.push({
+                        partitionIndex: i,
+                        currentLeaderEpoch: leaderEpoch,
+                        timestamp: options.timestamp ?? -1n
+                    });
+                }
+            }
+            runConcurrentCallbacks('Listing offsets failed.', requests, ([leader, requests], concurrentCallback) => {
+                this[kPerformWithRetry]('listOffsets', retryCallback => {
+                    this[kConnections].get(metadata.brokers.get(leader), (error, connection) => {
+                        if (error) {
+                            retryCallback(error, undefined);
+                            return;
+                        }
+                        listOffsetsV9(connection, -1, FetchIsolationLevels[options.isolationLevel ?? this[kOptions].isolationLevel], Array.from(requests.values()), retryCallback);
+                    });
+                }, concurrentCallback, 0);
+            }, (error, responses) => {
+                if (error) {
+                    callback(error, undefined);
+                    return;
+                }
+                const offsets = new Map();
+                for (const response of responses) {
+                    for (const { name: topic, partitions } of response.topics) {
+                        let topicOffsets = offsets.get(topic);
+                        if (!topicOffsets) {
+                            topicOffsets = Array(metadata.topics.get(topic).partitionsCount);
+                            offsets.set(topic, topicOffsets);
+                        }
+                        for (const { partitionIndex: index, offset } of partitions) {
+                            topicOffsets[index] = offset;
+                        }
+                    }
+                }
+                callback(null, offsets);
+            });
+        });
+    }
+    #listCommittedOffsets(options, callback) {
+        const topics = [];
+        for (const { topic: name, partitions } of options.topics) {
+            topics.push({ name, partitionIndexes: partitions });
+        }
+        this.#performGroupOperation('listCommits', (connection, groupCallback) => {
+            offsetFetchV9(connection, 
+            // Note: once we start implementing KIP-848, the memberEpoch must be obtained
+            [{ groupId: this.groupId, memberId: this.memberId, memberEpoch: -1, topics }], false, groupCallback);
+        }, (error, response) => {
+            if (error) {
+                callback(error, undefined);
+                return;
+            }
+            const committed = new Map();
+            for (const responseGroup of response.groups) {
+                for (const responseTopic of responseGroup.topics) {
+                    const topic = responseTopic.name;
+                    const partitions = Array(responseTopic.partitions.length);
+                    for (const { partitionIndex: index, committedOffset } of responseTopic.partitions) {
+                        partitions[index] = committedOffset;
+                    }
+                    committed.set(topic, partitions);
+                }
+            }
+            callback(null, committed);
+        });
+    }
+    #findGroupCoordinator(callback) {
+        if (this.#coordinatorId) {
+            callback(null, this.#coordinatorId);
+            return;
+        }
+        this[kPerformDeduplicated]('findGroupCoordinator', deduplicateCallback => {
+            this[kPerformWithRetry]('findGroupCoordinator', retryCallback => {
+                this[kConnections].getFirstAvailable(this[kBootstrapBrokers], (error, connection) => {
+                    if (error) {
+                        retryCallback(error, undefined);
+                        return;
+                    }
+                    findCoordinatorV6(connection, FindCoordinatorKeyTypes.GROUP, [this.groupId], retryCallback);
+                });
+            }, (error, response) => {
+                if (error) {
+                    deduplicateCallback(error, undefined);
+                    return;
+                }
+                const groupInfo = response.coordinators.find(coordinator => coordinator.key === this.groupId);
+                this.#coordinatorId = groupInfo.nodeId;
+                deduplicateCallback(null, this.#coordinatorId);
+            }, 0);
+        }, callback);
+    }
+    #joinGroup(options, callback) {
+        if (!this.#membershipActive) {
+            callback(null, undefined);
+            return;
+        }
+        this.#cancelHeartbeat();
+        const protocols = [];
+        for (const protocol of options.protocols) {
+            protocols.push({
+                name: protocol.name,
+                metadata: this.#encodeProtocolSubscriptionMetadata(protocol, this.topics.current)
+            });
+        }
+        this.#performDeduplicateGroupOperaton('joinGroup', (connection, groupCallback) => {
+            joinGroupV9(connection, this.groupId, options.sessionTimeout, options.rebalanceTimeout, this.memberId ?? '', null, 'consumer', protocols, '', groupCallback);
+        }, (error, response) => {
+            if (!this.#membershipActive) {
+                callback(null, undefined);
+                return;
+            }
+            if (error) {
+                if (this.#getRejoinError(error)) {
+                    this.#joinGroup(options, callback);
+                    return;
+                }
+                callback(error, undefined);
+                return;
+            }
+            this.generationId = response.generationId;
+            this.#isLeader = response.leader === this.memberId;
+            this.#protocol = response.protocolName;
+            this.#members = new Map();
+            for (const member of response.members) {
+                this.#members.set(member.memberId, this.#decodeProtocolSubscriptionMetadata(member.memberId, member.metadata));
+            }
+            // Send a syncGroup request
+            this.#syncGroup(null, (error, response) => {
+                if (!this.#membershipActive) {
+                    callback(null, undefined);
+                    return;
+                }
+                if (error) {
+                    if (this.#getRejoinError(error)) {
+                        this.#joinGroup(options, callback);
+                        return;
+                    }
+                    callback(error, undefined);
+                    return;
+                }
+                this.assignments = response;
+                this.#cancelHeartbeat();
+                this.#heartbeatInterval = setTimeout(() => {
+                    this.#heartbeat(options);
+                }, options.heartbeatInterval);
+                this.emitWithDebug('consumer', 'group:join', {
+                    groupId: this.groupId,
+                    memberId: this.memberId,
+                    generationId: this.generationId,
+                    isLeader: this.#isLeader,
+                    assignments: this.assignments
+                });
+                callback(null, this.memberId);
+            });
+        });
+    }
+    #leaveGroup(force, callback) {
+        if (!this.memberId) {
+            callback(null);
+            return;
+        }
+        // Remove streams that might have been exited in the meanwhile
+        for (const stream of this.#streams) {
+            if (stream.closed || stream.destroyed) {
+                this.#streams.delete(stream);
+            }
+        }
+        if (this.#streams.size) {
+            if (!force) {
+                callback(new UserError('Cannot leave group while consuming messages.'));
+                return;
+            }
+            runConcurrentCallbacks('Closing streams failed.', this.#streams, (stream, concurrentCallback) => {
+                stream.close(concurrentCallback);
+            }, error => {
+                if (error) {
+                    callback(error);
+                    return;
+                }
+                // All streams are closed, try the operation again without force
+                this.#leaveGroup(false, callback);
+            });
+            return;
+        }
+        this.#cancelHeartbeat();
+        this.#performDeduplicateGroupOperaton('leaveGroup', (connection, groupCallback) => {
+            leaveGroupV5(connection, this.groupId, [{ memberId: this.memberId }], groupCallback);
+        }, error => {
+            if (error) {
+                const unknownMemberError = error.findBy?.('unknownMemberId', true);
+                // This is to avoid throwing an error if a group join was cancelled.
+                if (!unknownMemberError) {
+                    callback(error);
+                    return;
+                }
+            }
+            this.emitWithDebug('consumer', 'group:leave', {
+                groupId: this.groupId,
+                memberId: this.memberId,
+                generationId: this.generationId
+            });
+            callback(null);
+        });
+    }
+    #syncGroup(assignments, callback) {
+        if (!this.#membershipActive) {
+            callback(null, undefined);
+            return;
+        }
+        if (!Array.isArray(assignments)) {
+            if (this.#isLeader) {
+                // Get all the metadata for  the topics the consumer are listening to, then compute the assignments
+                const topicsSubscriptions = new Map();
+                for (const subscription of this.#members.values()) {
+                    for (const topic of subscription.topics) {
+                        let topicSubscriptions = topicsSubscriptions.get(topic);
+                        if (!topicSubscriptions) {
+                            topicSubscriptions = [];
+                            topicsSubscriptions.set(topic, topicSubscriptions);
+                        }
+                        topicSubscriptions.push(subscription);
+                    }
+                }
+                this[kMetadata]({ topics: Array.from(topicsSubscriptions.keys()) }, (error, metadata) => {
+                    if (error) {
+                        callback(error, undefined);
+                        return;
+                    }
+                    if (!this.#membershipActive) {
+                        callback(null, undefined);
+                        return;
+                    }
+                    this.#syncGroup(this.#roundRobinAssignments(metadata), callback);
+                });
+                return;
+            }
+            else {
+                // Non leader simply do not send any assignments and wait
+                assignments = [];
+            }
+        }
+        this.#performDeduplicateGroupOperaton('syncGroup', (connection, groupCallback) => {
+            syncGroupV5(connection, this.groupId, this.generationId, this.memberId, null, 'consumer', this.#protocol, assignments, groupCallback);
+        }, (error, response) => {
+            if (!this.#membershipActive) {
+                callback(null, undefined);
+                return;
+            }
+            if (error) {
+                callback(error, undefined);
+                return;
+            }
+            else if (response.assignment.length === 0) {
+                callback(null, []);
+                return;
+            }
+            // Read the assignment back
+            const reader = Reader.from(response.assignment);
+            const assignments = reader.readArray(r => {
+                return {
+                    topic: r.readString(),
+                    partitions: r.readArray(r => r.readInt32(), true, false)
+                };
+            }, true, false);
+            callback(error, assignments);
+        });
+    }
+    #heartbeat(options) {
+        const eventPayload = { groupId: this.groupId, memberId: this.memberId, generationId: this.generationId };
+        this.#performDeduplicateGroupOperaton('heartbeat', (connection, groupCallback) => {
+            // We have left the group in the meanwhile, abort
+            if (!this.#membershipActive) {
+                return;
+            }
+            this.emitWithDebug('consumer:heartbeat', 'start');
+            heartbeatV4(connection, this.groupId, this.generationId, this.memberId, null, groupCallback);
+        }, error => {
+            // The heartbeat has been aborted elsewhere, ignore the response
+            if (this.#heartbeatInterval === null || !this.#membershipActive) {
+                return;
+            }
+            if (error) {
+                this.#cancelHeartbeat();
+                if (this.#getRejoinError(error)) {
+                    this[kPerformWithRetry]('rejoinGroup', retryCallback => {
+                        this.#joinGroup(options, retryCallback);
+                    }, error => {
+                        if (error) {
+                            this.emitWithDebug(null, 'error', error);
+                        }
+                        this.emitWithDebug('consumer', 'rejoin');
+                    }, 0);
+                    return;
+                }
+                this.emitWithDebug('consumer:heartbeat', 'error', { ...eventPayload, error });
+                // Note that here we purposely do not return, since it was not a group related problem we schedule another heartbeat
+            }
+            else {
+                this.emitWithDebug('consumer:heartbeat', 'end', eventPayload);
+            }
+            this.#heartbeatInterval?.refresh();
+        });
+    }
+    #cancelHeartbeat() {
+        clearTimeout(this.#heartbeatInterval);
+        this.#heartbeatInterval = null;
+    }
+    #performDeduplicateGroupOperaton(operationId, operation, callback) {
+        return this[kPerformDeduplicated](operationId, deduplicateCallback => {
+            this.#performGroupOperation(operationId, operation, deduplicateCallback);
+        }, callback);
+    }
+    #performGroupOperation(operationId, operation, callback) {
+        this.#findGroupCoordinator((error, coordinatorId) => {
+            if (error) {
+                callback(error, undefined);
+                return;
+            }
+            this[kMetadata]({ topics: this.topics.current }, (error, metadata) => {
+                if (error) {
+                    callback(error, undefined);
+                    return;
+                }
+                this[kPerformWithRetry](operationId, retryCallback => {
+                    this[kConnections].get(metadata.brokers.get(coordinatorId), (error, connection) => {
+                        if (error) {
+                            retryCallback(error, undefined);
+                            return;
+                        }
+                        operation(connection, retryCallback);
+                    });
+                }, callback);
+            });
+        });
+    }
+    #validateGroupOptions(options) {
+        if (options.rebalanceTimeout < options.sessionTimeout) {
+            throw new UserError('/options/rebalanceTimeout must be greater than or equal to /options/sessionTimeout.');
+        }
+        if (options.heartbeatInterval > options.sessionTimeout) {
+            throw new UserError('/options/heartbeatInterval must be less than or equal to /options/sessionTimeout.');
+        }
+        if (options.heartbeatInterval > options.rebalanceTimeout) {
+            throw new UserError('/options/heartbeatInterval must be less than or equal to /options/rebalanceTimeout.');
+        }
+    }
+    /*
+      The following two methods follow:
+      https://github.com/apache/kafka/blob/trunk/clients/src/main/resources/common/message/ConsumerProtocolSubscription.json
+    */
+    #encodeProtocolSubscriptionMetadata(metadata, topics) {
+        return Writer.create()
+            .appendInt16(metadata.version)
+            .appendArray(topics, (w, t) => w.appendString(t, false), false, false)
+            .appendBytes(typeof metadata.metadata === 'string' ? Buffer.from(metadata.metadata) : metadata.metadata, false)
+            .buffer;
+    }
+    #decodeProtocolSubscriptionMetadata(memberId, buffer) {
+        const reader = Reader.from(buffer);
+        return {
+            memberId,
+            version: reader.readInt16(),
+            topics: reader.readArray(r => r.readString(false), false, false),
+            metadata: reader.readBytes(false)
+        };
+    }
+    /*
+      This follows:
+      https://github.com/apache/kafka/blob/trunk/clients/src/main/resources/common/message/ConsumerProtocolAssignment.json
+    */
+    #encodeProtocolAssignment(assignments) {
+        return Writer.create().appendArray(assignments, (w, { topic, partitions }) => {
+            w.appendString(topic).appendArray(partitions, (w, a) => w.appendInt32(a), true, false);
+        }, true, false).buffer;
+    }
+    #roundRobinAssignments(metadata) {
+        const partitionTracker = new Map();
+        // First of all, layout topics-partitions in a list
+        for (const [topic, partitions] of metadata.topics) {
+            partitionTracker.set(topic, { next: 0, max: partitions.partitionsCount });
+        }
+        // We are the only member of the group, assign all partitions to us
+        const membersSize = this.#members.size;
+        if (membersSize === 1) {
+            const assignments = [];
+            for (const topic of this.topics.current) {
+                const partitionsCount = metadata.topics.get(topic).partitionsCount;
+                const partitions = [];
+                for (let i = 0; i < partitionsCount; i++) {
+                    partitions.push(i);
+                }
+                assignments.push({ topic, partitions });
+            }
+            return [{ memberId: this.memberId, assignment: this.#encodeProtocolAssignment(assignments) }];
+        }
+        // Flat the list of members and subscribed topics
+        const members = [];
+        const subscribedTopics = new Set();
+        for (const [memberId, subscription] of this.#members) {
+            members.push({ memberId, assignments: new Map() });
+            for (const topic of subscription.topics) {
+                subscribedTopics.add(topic);
+            }
+        }
+        // Assign topic-partitions in round robin
+        let currentMember = 0;
+        for (const topic of subscribedTopics) {
+            const partitionsCount = metadata.topics.get(topic).partitionsCount;
+            for (let i = 0; i < partitionsCount; i++) {
+                const member = members[currentMember++ % membersSize];
+                let topicAssignments = member.assignments.get(topic);
+                if (!topicAssignments) {
+                    topicAssignments = { topic, partitions: [] };
+                    member.assignments.set(topic, topicAssignments);
+                }
+                topicAssignments?.partitions.push(i);
+            }
+        }
+        const assignments = [];
+        for (const member of members) {
+            assignments.push({
+                memberId: member.memberId,
+                assignment: this.#encodeProtocolAssignment(Array.from(member.assignments.values()))
+            });
+        }
+        return assignments;
+    }
+    #getRejoinError(error) {
+        const protocolError = error.findBy?.('needsRejoin', true);
+        if (!protocolError) {
+            return null;
+        }
+        if (protocolError.rebalanceInProgress) {
+            this.emitWithDebug('consumer', 'group:rebalance', { groupId: this.groupId });
+        }
+        if (protocolError.unknownMemberId) {
+            this.memberId = null;
+        }
+        else if (protocolError.memberId && !this.memberId) {
+            this.memberId = protocolError.memberId;
+        }
+        return protocolError;
+    }
+}