@platformatic/kafka 2.9.0-alpha.1 → 2.9.0

package/dist/apis/security/sasl-authenticate-v2.js

@@ -22,7 +22,6 @@ export function parseResponse(_correlationId, apiKey, apiVersion, reader) {
         authBytes: reader.readBytes(),
         sessionLifetimeMs: reader.readInt64()
     };
-    reader.readTaggedFields();
     if (response.errorCode !== 0) {
         throw new ResponseError(apiKey, apiVersion, { '/': [response.errorCode, response.errorMessage] }, response);
     }

package/dist/apis/telemetry/get-telemetry-subscriptions-v0.d.ts

@@ -1,14 +1,13 @@
 import { type NullableString } from '../../protocol/definitions.ts';
 import { type Reader } from '../../protocol/reader.ts';
 import { Writer } from '../../protocol/writer.ts';
-import { type TelemetryCompressionType } from './compression-types.ts';
 export type GetTelemetrySubscriptionsRequest = Parameters<typeof createRequest>;
 export interface GetTelemetrySubscriptionsResponse {
     throttleTimeMs: number;
     errorCode: number;
     clientInstanceId: string;
     subscriptionId: number;
-    acceptedCompressionTypes: TelemetryCompressionType[];
+    acceptedCompressionTypes: number[];
     pushIntervalMs: number;
     telemetryMaxBytes: number;
     deltaTemporality: boolean;

package/dist/apis/telemetry/get-telemetry-subscriptions-v0.js

@@ -38,7 +38,6 @@ export function parseResponse(_correlationId, apiKey, apiVersion, reader) {
         deltaTemporality: reader.readBoolean(),
         requestedMetrics: reader.readArray(r => r.readString(), true, false)
     };
-    reader.readTaggedFields();
     if (errors.length) {
         throw new ResponseError(apiKey, apiVersion, Object.fromEntries(errors), response);
     }

package/dist/apis/telemetry/index.d.ts

@@ -1,6 +1,3 @@
-export { TelemetryCompressionTypes, type TelemetryCompressionType } from './compression-types.ts';
 export * as getTelemetrySubscriptionsV0 from './get-telemetry-subscriptions-v0.ts';
 export * as listClientMetricsResourcesV0 from './list-client-metrics-resources-v0.ts';
-export * as listConfigResourcesV1 from './list-config-resources-v1.ts';
-export * as listClientMetricsResourcesV1 from './list-config-resources-v1.ts';
 export * as pushTelemetryV0 from './push-telemetry-v0.ts';

package/dist/apis/telemetry/index.js

@@ -1,6 +1,3 @@
-export { TelemetryCompressionTypes } from "./compression-types.js";
 export * as getTelemetrySubscriptionsV0 from "./get-telemetry-subscriptions-v0.js";
 export * as listClientMetricsResourcesV0 from "./list-client-metrics-resources-v0.js";
-export * as listConfigResourcesV1 from "./list-config-resources-v1.js";
-export * as listClientMetricsResourcesV1 from "./list-config-resources-v1.js";
 export * as pushTelemetryV0 from "./push-telemetry-v0.js";

package/dist/apis/telemetry/list-client-metrics-resources-v0.d.ts

@@ -1,16 +1,14 @@
 import { type Reader } from '../../protocol/reader.ts';
 import { Writer } from '../../protocol/writer.ts';
-import { type ConfigResourceTypeValue } from '../enumerations.ts';
 export type ListClientMetricsResourcesRequest = Parameters<typeof createRequest>;
 export interface ListClientMetricsResourcesResource {
-    resourceName: string;
-    resourceType: ConfigResourceTypeValue;
+    name: string;
 }
 export interface ListClientMetricsResourcesResponse {
     throttleTimeMs: number;
     errorCode: number;
-    configResources: ListClientMetricsResourcesResource[];
+    clientMetricsResources: ListClientMetricsResourcesResource[];
 }
-export declare function createRequest(_resourceTypes?: ConfigResourceTypeValue[]): Writer;
+export declare function createRequest(): Writer;
 export declare function parseResponse(_correlationId: number, apiKey: number, apiVersion: number, reader: Reader): ListClientMetricsResourcesResponse;
-export declare const api: import("../definitions.ts").API<[_resourceTypes?: ConfigResourceTypeValue[] | undefined], ListClientMetricsResourcesResponse>;
+export declare const api: import("../definitions.ts").API<[], ListClientMetricsResourcesResponse>;

package/dist/apis/telemetry/list-client-metrics-resources-v0.js

@@ -1,34 +1,29 @@
 import { ResponseError } from "../../errors.js";
 import { Writer } from "../../protocol/writer.js";
 import { createAPI } from "../definitions.js";
-import { ConfigResourceTypes } from "../enumerations.js";
 /*
   ListClientMetricsResources Request (Version: 0) => TAG_BUFFER
 */
-export function createRequest(_resourceTypes) {
+export function createRequest() {
     return Writer.create().appendTaggedFields();
 }
 /*
- ListClientMetricsResources Response (Version: 0) => throttle_time_ms error_code [config_resources] TAG_BUFFER
+ListClientMetricsResources Response (Version: 0) => throttle_time_ms error_code [client_metrics_resources] TAG_BUFFER
   throttle_time_ms => INT32
   error_code => INT16
-  config_resources => resource_name TAG_BUFFER
-    resource_name => COMPACT_STRING
+  client_metrics_resources => name TAG_BUFFER
+    name => COMPACT_STRING
 */
 export function parseResponse(_correlationId, apiKey, apiVersion, reader) {
     const response = {
         throttleTimeMs: reader.readInt32(),
         errorCode: reader.readInt16(),
-        configResources: reader.readArray(r => {
-            const resource = {
-                resourceName: r.readString(),
-                resourceType: ConfigResourceTypes.CLIENT_METRICS
+        clientMetricsResources: reader.readArray(r => {
+            return {
+                name: r.readString()
             };
-            r.readTaggedFields();
-            return resource;
-        }, true, false)
+        })
     };
-    reader.readTaggedFields();
     if (response.errorCode !== 0) {
         throw new ResponseError(apiKey, apiVersion, { '/': [response.errorCode, null] }, response);
     }

package/dist/apis/telemetry/push-telemetry-v0.d.ts

@@ -1,11 +1,10 @@
 import { type Reader } from '../../protocol/reader.ts';
 import { Writer } from '../../protocol/writer.ts';
-import { type TelemetryCompressionType } from './compression-types.ts';
 export type PushTelemetryRequest = Parameters<typeof createRequest>;
 export interface PushTelemetryResponse {
     throttleTimeMs: number;
     errorCode: number;
 }
-export declare function createRequest(clientInstanceId: string, subscriptionId: number, terminating: boolean, compressionType: TelemetryCompressionType, metrics: Buffer): Writer;
+export declare function createRequest(clientInstanceId: string, subscriptionId: number, terminating: boolean, compressionType: number, metrics: Buffer): Writer;
 export declare function parseResponse(_correlationId: number, apiKey: number, apiVersion: number, reader: Reader): PushTelemetryResponse;
-export declare const api: import("../definitions.ts").API<[clientInstanceId: string, subscriptionId: number, terminating: boolean, compressionType: TelemetryCompressionType, metrics: Buffer<ArrayBufferLike>], PushTelemetryResponse>;
+export declare const api: import("../definitions.ts").API<[clientInstanceId: string, subscriptionId: number, terminating: boolean, compressionType: number, metrics: Buffer<ArrayBufferLike>], PushTelemetryResponse>;

package/dist/apis/telemetry/push-telemetry-v0.js

@@ -28,7 +28,6 @@ export function parseResponse(_correlationId, apiKey, apiVersion, reader) {
         throttleTimeMs: reader.readInt32(),
         errorCode: reader.readInt16()
     };
-    reader.readTaggedFields();
     if (response.errorCode !== 0) {
         throw new ResponseError(apiKey, apiVersion, { '/': [response.errorCode, null] }, response);
     }

package/dist/clients/admin/admin.js

@@ -1,7 +1,7 @@
 import { createPromisifiedCallback, kCallbackPromise, runConcurrentCallbacks } from "../../apis/callbacks.js";
-import { ConfigResourceTypes, FetchIsolationLevels, FindCoordinatorKeyTypes, legacyConsumerGroupStates } from "../../apis/enumerations.js";
+import { ConfigResourceTypes, FetchIsolationLevels, FindCoordinatorKeyTypes } from "../../apis/enumerations.js";
 import { adminAclsChannel, adminClientQuotasChannel, adminConfigsChannel, adminConsumerGroupOffsetsChannel, adminGroupsChannel, adminLogDirsChannel, adminOffsetsChannel, adminTopicsChannel, createDiagnosticContext } from "../../diagnostic.js";
-import { MultipleErrors, UserError } from "../../errors.js";
+import { findErrorBy, MultipleErrors, UserError } from "../../errors.js";
 import { Reader } from "../../protocol/reader.js";
 import { Base, kAfterCreate, kCheckNotClosed, kConnections, kGetApi, kGetBootstrapConnection, kGetConnection, kMetadata, kOptions, kPerformDeduplicated, kPerformWithRetry, kValidateOptions } from "../base/base.js";
 import { adminListOffsetsOptionsValidator, alterClientQuotasOptionsValidator, alterConfigsOptionsValidator, alterConsumerGroupOffsetsOptionsValidator, createAclsOptionsValidator, createPartitionsOptionsValidator, createTopicsOptionsValidator, deleteAclsOptionsValidator, deleteConsumerGroupOffsetsOptionsValidator, deleteGroupsOptionsValidator, deleteRecordsOptionsValidator, deleteTopicsOptionsValidator, describeAclsOptionsValidator, describeClientQuotasOptionsValidator, describeConfigsOptionsValidator, describeGroupsOptionsValidator, describeLogDirsOptionsValidator, findCoordinatorOptionsValidator, incrementalAlterConfigsOptionsValidator, listConsumerGroupOffsetsOptionsValidator, listGroupsOptionsValidator, listTopicsOptionsValidator, removeMembersFromConsumerGroupOptionsValidator } from "./options.js";
@@ -373,7 +373,7 @@ export class Admin extends Base {
         }
     }
     #handleNotControllerError(error, value, callback) {
-        if (error && error?.findBy?.('apiCode', 41)) {
+        if (findErrorBy(error, 'apiCode', 41)) {
             this[kMetadata]({ topics: [], forceUpdate: true }, (metadataError, metadata) => {
                 /* c8 ignore next 4 - Hard to test */
                 if (metadataError) {
@@ -464,10 +464,9 @@ export class Admin extends Base {
                     return;
                 }
                 const created = [];
-                const topics = response.topics;
-                for (const { name, topicId: id = '', numPartitions: partitions = -1, replicationFactor: replicas = -1, configs: topicConfigs } of topics) {
+                for (const { name, topicId: id, numPartitions: partitions, replicationFactor: replicas, configs } of response.topics) {
                     const configuration = {};
-                    for (const { name, value } of topicConfigs ?? []) {
+                    for (const { name, value } of configs) {
                         configuration[name] = value;
                     }
                     created.push({ id, name, partitions, replicas, configuration });
@@ -555,11 +554,8 @@ export class Admin extends Base {
                                 retryCallback(error);
                                 return;
                             }
-                            // Brokers filter on the values they put on the wire, so the legacy Java enum
-                            // constant names have to be translated or they would silently match nothing.
-                            const states = (options.states ?? []).map(state => legacyConsumerGroupStates[state] ?? state);
                             /* c8 ignore next 5 */
-                            api(connection, states, options.types, retryCallback);
+                            api(connection, options.states ?? [], options.types, retryCallback);
                         });
                     }, concurrentCallback, 0);
                 });
@@ -573,10 +569,8 @@ export class Admin extends Base {
                     for (const raw of result.groups) {
                         groups.set(raw.groupId, {
                             id: raw.groupId,
-                            // ListGroups only carries group_state from v4, so below that the codec has nothing
-                            // to report. 'Unknown' is the value Kafka itself uses for exactly this case.
-                            state: (raw.groupState || 'Unknown'),
-                            groupType: raw.groupType || undefined,
+                            state: raw.groupState.toUpperCase(),
+                            groupType: raw.groupType,
                             protocolType: raw.protocolType
                         });
                     }
@@ -629,7 +623,7 @@ export class Admin extends Base {
                         for (const raw of result.groups) {
                             const group = {
                                 id: raw.groupId,
-                                state: raw.groupState,
+                                state: raw.groupState.toUpperCase(),
                                 protocolType: raw.protocolType,
                                 protocol: raw.protocolData,
                                 members: new Map(),
@@ -762,13 +756,7 @@ export class Admin extends Base {
                             groupInstanceId: null,
                             reason: typeof member === 'string' ? 'Not specified' : member.reason
                         }));
-                        if (api.version >= 3) {
-                            api(connection, options.groupId, members, retryCallback);
-                            return;
-                        }
-                        runConcurrentCallbacks('Removing members from consumer group failed.', members, (member, concurrentCallback) => {
-                            api(connection, options.groupId, [member], concurrentCallback);
-                        }, error => retryCallback(error));
+                        api(connection, options.groupId, members, retryCallback);
                     });
                 });
             });
@@ -792,28 +780,7 @@ export class Admin extends Base {
                         retryCallback(error);
                         return;
                     }
-                    if (api.version >= 4) {
-                        api(connection, options.keyType, options.keys, retryCallback);
-                        return;
-                    }
-                    runConcurrentCallbacks('Finding coordinator failed.', options.keys, (key, concurrentCallback) => {
-                        api(connection, options.keyType, [key], (error, response) => {
-                            if (response) {
-                                response.coordinators[0].key = key;
-                            }
-                            concurrentCallback(error, response);
-                        });
-                    }, (error, responses) => {
-                        if (error) {
-                            retryCallback(error);
-                            return;
-                        }
-                        retryCallback(null, {
-                            // The caller controls how many keys are looked up, so reduce rather than spread.
-                            throttleTimeMs: responses.reduce((max, response) => Math.max(max, response.throttleTimeMs), 0),
-                            coordinators: responses.flatMap(response => response.coordinators)
-                        });
-                    });
+                    api(connection, options.keyType, options.keys, retryCallback);
                 });
             });
         }, (error, response) => {
@@ -849,7 +816,7 @@ export class Admin extends Base {
                 callback(new MultipleErrors('Describing client quotas failed.', [error]));
                 return;
             }
-            callback(null, response.entries ?? []);
+            callback(null, response.entries);
         }, 0);
     }
     #alterClientQuotas(options, callback) {
@@ -963,38 +930,8 @@ export class Admin extends Base {
                                     retryCallback(error);
                                     return;
                                 }
-                                if (api.version >= 8) {
-                                    api(connection, groupRequests, options.requireStable ?? false, retryCallback);
-                                    return;
-                                }
-                                runConcurrentCallbacks('Listing consumer group offsets failed.', groupRequests, (groupRequest, groupCallback) => {
-                                    api(connection, [groupRequest], options.requireStable ?? false, (error, response) => {
-                                        if (error) {
-                                            groupCallback(error);
-                                            return;
-                                        }
-                                        const legacyResponse = response;
-                                        groupCallback(null, {
-                                            throttleTimeMs: legacyResponse.throttleTimeMs,
-                                            groups: [
-                                                {
-                                                    groupId: groupRequest.groupId,
-                                                    topics: legacyResponse.topics,
-                                                    errorCode: legacyResponse.errorCode
-                                                }
-                                            ]
-                                        });
-                                    });
-                                }, (error, responses) => {
-                                    if (error) {
-                                        retryCallback(error);
-                                        return;
-                                    }
-                                    retryCallback(null, {
-                                        throttleTimeMs: responses.reduce((max, response) => Math.max(max, response.throttleTimeMs), 0),
-                                        groups: responses.flatMap(response => response.groups)
-                                    });
-                                });
+                                /* c8 ignore next - Hard to test */
+                                api(connection, groupRequests, options.requireStable ?? false, retryCallback);
                             });
                         });
                     }, concurrentCallback, 0);

package/dist/clients/admin/options.d.ts

@@ -129,7 +129,7 @@ export declare const listGroupsOptionsSchema: {
             items: {
                 type: string;
                 enumeration: {
-                    allowed: ("Unknown" | "PreparingRebalance" | "CompletingRebalance" | "Stable" | "Dead" | "Empty" | "Assigning" | "Reconciling" | "NotReady" | "PREPARING_REBALANCE" | "COMPLETING_REBALANCE" | "STABLE" | "DEAD" | "EMPTY")[];
+                    allowed: readonly ["PREPARING_REBALANCE", "COMPLETING_REBALANCE", "STABLE", "DEAD", "EMPTY"];
                     errorMessage: string;
                 };
             };

package/dist/clients/admin/options.js

@@ -1,4 +1,4 @@
-import { allowedAclOperations, allowedAclPermissionTypes, allowedClientQuotaMatchTypes, allowedFetchIsolationLevels, allowedFindCoordinatorKeyTypes, allowedIncrementalAlterConfigOperationTypes, allowedResourcePatternTypes, allowedResourceTypes, ConsumerGroupStates, KafkaConsumerGroupStates, IncrementalAlterConfigOperationTypes } from "../../apis/enumerations.js";
+import { allowedAclOperations, allowedAclPermissionTypes, allowedClientQuotaMatchTypes, allowedFetchIsolationLevels, allowedFindCoordinatorKeyTypes, allowedIncrementalAlterConfigOperationTypes, allowedResourcePatternTypes, allowedResourceTypes, ConsumerGroupStates, IncrementalAlterConfigOperationTypes } from "../../apis/enumerations.js";
 import { ajv, listErrorMessage } from "../../utils.js";
 import { idProperty } from "../base/options.js";
 export const groupsProperties = {
@@ -86,8 +86,8 @@ export const listGroupsOptionsSchema = {
             items: {
                 type: 'string',
                 enumeration: {
-                    allowed: [...ConsumerGroupStates, ...KafkaConsumerGroupStates],
-                    errorMessage: listErrorMessage([...ConsumerGroupStates, ...KafkaConsumerGroupStates])
+                    allowed: ConsumerGroupStates,
+                    errorMessage: listErrorMessage(ConsumerGroupStates)
                 }
             },
             minItems: 0

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

@@ -33,7 +33,7 @@ export interface GroupMember {
 export interface GroupBase {
     id: string;
     state: ConsumerGroupStateValue;
-    groupType?: string;
+    groupType: string;
     protocolType: string;
 }
 export interface Group extends Omit<GroupBase, 'groupType'> {

package/dist/clients/base/base.d.ts

@@ -1,7 +1,7 @@
 import { type ValidateFunction } from 'ajv';
 import { type CallbackWithPromise } from '../../apis/callbacks.ts';
 import { type API, type Callback } from '../../apis/definitions.ts';
-import { type ApiVersionsResponseApi } from '../../apis/metadata/api-versions-v1.ts';
+import { type ApiVersionsResponseApi } from '../../apis/metadata/api-versions-v3.ts';
 import { type ClientType } from '../../diagnostic.ts';
 import { TypedEventEmitter, type TypedEvents } from '../../events.ts';
 import { ConnectionPool, type ConnectionPoolEventPayload } from '../../network/connection-pool.ts';

package/dist/clients/base/base.js

@@ -1,8 +1,8 @@
 import { createPromisifiedCallback, kCallbackPromise, runConcurrentCallbacks } from "../../apis/callbacks.js";
 import * as apis from "../../apis/index.js";
-import { api as apiVersionsV1 } from "../../apis/metadata/api-versions-v1.js";
+import { api as apiVersionsV3 } from "../../apis/metadata/api-versions-v3.js";
 import { baseApisChannel, baseMetadataChannel, createDiagnosticContext, notifyCreation } from "../../diagnostic.js";
-import { MultipleErrors, NetworkError, UnsupportedApiError, UserError } from "../../errors.js";
+import { findErrorBy, MultipleErrors, NetworkError, UnsupportedApiError, UserError } from "../../errors.js";
 import { TypedEventEmitter } from "../../events.js";
 import { ConnectionPool } from "../../network/connection-pool.js";
 import { parseBroker } from "../../network/utils.js";
@@ -212,14 +212,8 @@ export class Base extends TypedEventEmitter {
                         retryCallback(error);
                         return;
                     }
-                    // We use V1 because it is supported by Kafka 1.1.0+.
-                    //
-                    // The tradeoff is that clientSoftwareName and clientSoftwareVersion only exist from
-                    // V3, so brokers cannot attribute client metrics to this package (KIP-511) and the
-                    // two arguments below are accepted and discarded by the V1 codec. Removing the
-                    // tradeoff requires negotiating down from V3 on UNSUPPORTED_VERSION rather than
-                    // pinning a version: see https://github.com/platformatic/kafka/issues/343.
-                    apiVersionsV1(connection, clientSoftwareName, clientSoftwareVersion, retryCallback);
+                    // We use V3 to be able to get APIS from Kafka 2.4.0+
+                    apiVersionsV3(connection, clientSoftwareName, clientSoftwareVersion, retryCallback);
                 }, attempt);
             }, (error, metadata) => {
                 if (error) {
@@ -235,7 +229,12 @@ export class Base extends TypedEventEmitter {
     }
     [kCheckNotClosed](callback) {
         if (this[kClosed]) {
-            const error = new NetworkError('Client is closed.', { closed: true, instance: this[kInstance] });
+            // A closed client never reopens, so this must not be retried.
+            const error = new NetworkError('Client is closed.', {
+                canRetry: false,
+                closed: true,
+                instance: this[kInstance]
+            });
             callback(error, undefined);
             return true;
         }
@@ -249,9 +248,8 @@ export class Base extends TypedEventEmitter {
         this.emitWithDebug('client', 'performWithRetry', operationId, attempt, retries);
         operation((error, result) => {
             if (error) {
-                const genericError = error;
                 // Only retry if all the errors in the chain are retriable
-                const retriable = !genericError.findBy?.('canRetry', false);
+                const retriable = !findErrorBy(error, 'canRetry', false);
                 errors.push(error);
                 if (attempt < retries && retriable && !shouldSkipRetry?.(error)) {
                     function onClose() {
@@ -431,21 +429,12 @@ export class Base extends TypedEventEmitter {
                         // (e.g. MSK) authorize every topic operation and emit a CloudTrail
                         // AccessDenied per denied op (CreateTopic/DeleteTopic/...) — pure
                         // audit-log noise for permissions the client never exercises.
-                        api(connection, topicsToFetch, autocreateTopics, false, (error, response) => {
-                            // Metadata v0-v8 do not carry topic UUIDs. Topic names are stable
-                            // surrogates for the consumer paths that use internal topic IDs.
-                            if (!error && api.version <= 8) {
-                                for (const topic of response.topics) {
-                                    topic.topicId = topic.name;
-                                }
-                            }
-                            retryCallback(error, response);
-                        });
+                        api(connection, topicsToFetch, autocreateTopics, false, retryCallback);
                     });
                 }, attempt);
             }, (error, metadata) => {
                 if (error) {
-                    const unknownTopicError = error.findBy('apiCode', 3);
+                    const unknownTopicError = findErrorBy(error, 'apiCode', 3);
                     if (unknownTopicError) {
                         const topicIndexMatch = unknownTopicError.path?.match(/\/topics\/(\d+)/);
                         /* c8 ignore next 3 - Hard to test  */
@@ -454,7 +443,7 @@ export class Base extends TypedEventEmitter {
                         deduplicateCallback(new UserError(`Unknown topic ${topicName}.`));
                         return;
                     }
-                    const hasStaleMetadata = error.findBy('hasStaleMetadata', true);
+                    const hasStaleMetadata = findErrorBy(error, 'hasStaleMetadata', true);
                     // Stale metadata, we need to fetch everything again
                     /* c8 ignore next 4 - Hard to test */
                     if (hasStaleMetadata) {

package/dist/clients/consumer/consumer.js

@@ -2,7 +2,7 @@ import { randomUUID } from 'node:crypto';
 import { createPromisifiedCallback, kCallbackPromise, runConcurrentCallbacks } from "../../apis/callbacks.js";
 import { FetchIsolationLevels, FindCoordinatorKeyTypes } from "../../apis/enumerations.js";
 import { consumerCommitsChannel, consumerConsumesChannel, consumerFetchesChannel, consumerGroupChannel, consumerHeartbeatChannel, consumerLagChannel, consumerOffsetsChannel, createDiagnosticContext } from "../../diagnostic.js";
-import { NetworkError, protocolErrors, UserError } from "../../errors.js";
+import { findErrorBy, NetworkError, protocolErrors, UserError } from "../../errors.js";
 import { INT32_SIZE } from "../../protocol/definitions.js";
 import { Reader } from "../../protocol/reader.js";
 import { IS_CONTROL } from "../../protocol/records.js";
@@ -577,45 +577,15 @@ export class Consumer extends Base {
                                 }
                             }
                         }
-                        // Fetch v12 identifies topics by name, while later versions use UUIDs.
-                        const useTopicNames = api.version <= 12;
-                        let topicIdsByName;
-                        if (useTopicNames) {
-                            // Built here rather than in the response callback so that the fetch loop allocates
-                            // it once per request instead of once per request and once per response.
-                            topicIdsByName = new Map();
-                            for (const [id, name] of topicIds) {
-                                topicIdsByName.set(name, id);
-                            }
-                            requestTopics = requestTopics.map(topic => ({
-                                ...topic,
-                                topicId: topicIds.get(topic.topicId) ?? topic.topicId
-                            }));
-                            for (const forgotten of forgottenTopicsData) {
-                                const topicId = forgotten.topicId ?? forgotten.topic;
-                                forgotten.topicId = topicIds.get(topicId) ?? topicId;
-                                delete forgotten.topic;
-                            }
-                        }
                         api(connection, options.maxWaitTime ?? this[kOptions].maxWaitTime, options.minBytes ?? this[kOptions].minBytes, options.maxBytes ?? this[kOptions].maxBytes, isolationLevel, sessionId, sessionEpoch, requestTopics, forgottenTopicsData, this.#clientRack, (error, result) => {
-                            const response = result ?? error?.response;
-                            if (response && !response.nodeEndpoints) {
-                                response.nodeEndpoints = [];
-                            }
-                            if (useTopicNames && response) {
-                                for (const topic of response.responses) {
-                                    topic.topicId = topicIdsByName.get(topic.topicId) ?? topic.topicId;
-                                }
-                            }
                             if (error) {
                                 this.#clearPreferredReadReplicas(options.topics, topicIds);
-                                const genericError = error;
-                                if (genericError.findBy?.('apiId', 'FETCH_SESSION_ID_NOT_FOUND') ||
-                                    genericError.findBy?.('apiId', 'INVALID_FETCH_SESSION_EPOCH') ||
-                                    genericError.findBy?.('apiId', 'FETCH_SESSION_TOPIC_ID_ERROR')) {
+                                if (findErrorBy(error, 'apiId', 'FETCH_SESSION_ID_NOT_FOUND') ||
+                                    findErrorBy(error, 'apiId', 'INVALID_FETCH_SESSION_EPOCH') ||
+                                    findErrorBy(error, 'apiId', 'FETCH_SESSION_TOPIC_ID_ERROR')) {
                                     this.#fetchSessions.delete(node);
                                 }
-                                if (genericError.findBy?.('apiId', 'FENCED_LEADER_EPOCH')) {
+                                if (findErrorBy(error, 'apiId', 'FENCED_LEADER_EPOCH')) {
                                     this.#fetchSessions.delete(node);
                                     this.clearMetadata();
                                     for (const topic of options.topics) {
@@ -814,23 +784,13 @@ export class Consumer extends Base {
                         memberEpoch: this.#useConsumerGroupProtocol ? this.#memberEpoch : -1,
                         topics
                     }
-                ], false, (error, response) => {
-                    if (error || api.version >= 8) {
-                        groupCallback(error, response);
-                        return;
-                    }
-                    const legacyResponse = response;
-                    groupCallback(null, {
-                        throttleTimeMs: legacyResponse.throttleTimeMs,
-                        groups: [{ groupId: this.groupId, topics: legacyResponse.topics, errorCode: legacyResponse.errorCode }]
-                    });
-                });
+                ], false, groupCallback);
             });
         }, (error, response) => {
             if (error) {
                 if (this.#useConsumerGroupProtocol &&
                     staleMemberEpochRetries < this[kOptions].retries &&
-                    error.findBy?.('apiId', 'STALE_MEMBER_EPOCH')) {
+                    findErrorBy(error, 'apiId', 'STALE_MEMBER_EPOCH')) {
                     this.#consumerGroupHeartbeat(this[kOptions], heartbeatError => {
                         if (heartbeatError) {
                             callback(this.#handleError(heartbeatError));
@@ -1080,7 +1040,35 @@ export class Consumer extends Base {
             callback(err);
         });
     }
-    #leaveGroupConsumerProtocol(_, callback) {
+    #leaveGroupConsumerProtocol(force, callback) {
+        // 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);
+            }
+        }
+        // Active streams must be closed before leaving the group, exactly like in the classic protocol.
+        // Their fetch loop keeps running until they are closed and, since Consumer.close marks the client
+        // as closed before leaving, any fetch scheduled in the meanwhile would fail with "Client is closed."
+        // and destroy the stream with an error the user never asked for.
+        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 => {
+                /* c8 ignore next 4 - Hard to test */
+                if (error) {
+                    callback(error);
+                    return;
+                }
+                // All streams are closed, try the operation again without force
+                this.#leaveGroupConsumerProtocol(false, callback);
+            });
+            return;
+        }
         // Leave by sending a heartbeat with memberEpoch = -1
         this.#cancelHeartbeat();
         this.#performDeduplicateGroupOperaton('leaveGroupConsumerProtocol', (connection, groupCallback) => {
@@ -1173,12 +1161,7 @@ export class Consumer extends Base {
                             retryCallback(error);
                             return;
                         }
-                        api(connection, FindCoordinatorKeyTypes.GROUP, [this.groupId], (error, response) => {
-                            if (response && api.version < 4) {
-                                response.coordinators[0].key = this.groupId;
-                            }
-                            retryCallback(error, response);
-                        });
+                        api(connection, FindCoordinatorKeyTypes.GROUP, [this.groupId], retryCallback);
                     });
                 });
             }, (error, response) => {
@@ -1304,7 +1287,7 @@ export class Consumer extends Base {
             });
         }, error => {
             if (error) {
-                const unknownMemberError = error.findBy?.('unknownMemberId', true);
+                const unknownMemberError = findErrorBy(error, 'unknownMemberId', true);
                 // This is to avoid throwing an error if a group join was cancelled.
                 if (!unknownMemberError) {
                     callback(error);
@@ -1559,13 +1542,12 @@ export class Consumer extends Base {
                 if (!partition.records) {
                     continue;
                 }
-                const abortedTransactions = partition.abortedTransactions ?? [];
-                if (abortedTransactions.length) {
+                if (partition.abortedTransactions.length) {
                     const abortedRanges = new Map();
                     // Find first offsets
                     // For last offsets we set -1n as special value. It allows us to detect open ranges, whichs means
                     // that Kafka has not sent the control marker. In that case we ignore the range for safety.
-                    for (const aborted of abortedTransactions) {
+                    for (const aborted of partition.abortedTransactions) {
                         abortedRanges.set(aborted.producerId, [aborted.firstOffset, -1n]);
                     }
                     // Now find last offsets
@@ -1586,7 +1568,7 @@ export class Consumer extends Base {
         }
     }
     #getRejoinError(error) {
-        const protocolError = error.findBy?.('needsRejoin', true);
+        const protocolError = findErrorBy(error, 'needsRejoin', true);
         if (!protocolError) {
             return null;
         }
@@ -1672,17 +1654,14 @@ export class Consumer extends Base {
         }
     }
     #handleError(error) {
-        const kafkaError = error;
-        if (kafkaError) {
-            if (kafkaError.findBy('hasStaleMetadata', true)) {
-                this.clearMetadata();
-            }
-            else if (kafkaError.findBy('code', 'PLT_KFK_NETWORK') ||
-                kafkaError.findBy('apiId', 'COORDINATOR_LOAD_IN_PROGRESS') ||
-                kafkaError.findBy('apiId', 'COORDINATOR_NOT_AVAILABLE') ||
-                kafkaError.findBy('apiId', 'NOT_COORDINATOR')) {
-                this.#coordinatorId = null;
-            }
+        if (findErrorBy(error, 'hasStaleMetadata', true)) {
+            this.clearMetadata();
+        }
+        else if (findErrorBy(error, 'code', 'PLT_KFK_NETWORK') ||
+            findErrorBy(error, 'apiId', 'COORDINATOR_LOAD_IN_PROGRESS') ||
+            findErrorBy(error, 'apiId', 'COORDINATOR_NOT_AVAILABLE') ||
+            findErrorBy(error, 'apiId', 'NOT_COORDINATOR')) {
+            this.#coordinatorId = null;
         }
         return error;
     }