@platformatic/kafka 2.7.0 → 2.9.0-alpha.1

package/dist/clients/admin/admin.js

@@ -1,5 +1,5 @@
 import { createPromisifiedCallback, kCallbackPromise, runConcurrentCallbacks } from "../../apis/callbacks.js";
-import { ConfigResourceTypes, FetchIsolationLevels, FindCoordinatorKeyTypes } from "../../apis/enumerations.js";
+import { ConfigResourceTypes, FetchIsolationLevels, FindCoordinatorKeyTypes, legacyConsumerGroupStates } from "../../apis/enumerations.js";
 import { adminAclsChannel, adminClientQuotasChannel, adminConfigsChannel, adminConsumerGroupOffsetsChannel, adminGroupsChannel, adminLogDirsChannel, adminOffsetsChannel, adminTopicsChannel, createDiagnosticContext } from "../../diagnostic.js";
 import { MultipleErrors, UserError } from "../../errors.js";
 import { Reader } from "../../protocol/reader.js";
@@ -464,9 +464,10 @@ export class Admin extends Base {
                     return;
                 }
                 const created = [];
-                for (const { name, topicId: id, numPartitions: partitions, replicationFactor: replicas, configs } of response.topics) {
+                const topics = response.topics;
+                for (const { name, topicId: id = '', numPartitions: partitions = -1, replicationFactor: replicas = -1, configs: topicConfigs } of topics) {
                     const configuration = {};
-                    for (const { name, value } of configs) {
+                    for (const { name, value } of topicConfigs ?? []) {
                         configuration[name] = value;
                     }
                     created.push({ id, name, partitions, replicas, configuration });
@@ -554,8 +555,11 @@ 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, options.states ?? [], options.types, retryCallback);
+                            api(connection, states, options.types, retryCallback);
                         });
                     }, concurrentCallback, 0);
                 });
@@ -569,8 +573,10 @@ export class Admin extends Base {
                     for (const raw of result.groups) {
                         groups.set(raw.groupId, {
                             id: raw.groupId,
-                            state: raw.groupState.toUpperCase(),
-                            groupType: raw.groupType,
+                            // 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,
                             protocolType: raw.protocolType
                         });
                     }
@@ -623,7 +629,7 @@ export class Admin extends Base {
                         for (const raw of result.groups) {
                             const group = {
                                 id: raw.groupId,
-                                state: raw.groupState.toUpperCase(),
+                                state: raw.groupState,
                                 protocolType: raw.protocolType,
                                 protocol: raw.protocolData,
                                 members: new Map(),
@@ -756,7 +762,13 @@ export class Admin extends Base {
                             groupInstanceId: null,
                             reason: typeof member === 'string' ? 'Not specified' : member.reason
                         }));
-                        api(connection, options.groupId, members, retryCallback);
+                        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));
                     });
                 });
             });
@@ -780,7 +792,28 @@ export class Admin extends Base {
                         retryCallback(error);
                         return;
                     }
-                    api(connection, options.keyType, options.keys, retryCallback);
+                    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)
+                        });
+                    });
                 });
             });
         }, (error, response) => {
@@ -816,7 +849,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) {
@@ -930,8 +963,38 @@ export class Admin extends Base {
                                     retryCallback(error);
                                     return;
                                 }
-                                /* c8 ignore next - Hard to test */
-                                api(connection, groupRequests, options.requireStable ?? false, retryCallback);
+                                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)
+                                    });
+                                });
                             });
                         });
                     }, concurrentCallback, 0);

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

@@ -129,7 +129,7 @@ export declare const listGroupsOptionsSchema: {
             items: {
                 type: string;
                 enumeration: {
-                    allowed: readonly ["PREPARING_REBALANCE", "COMPLETING_REBALANCE", "STABLE", "DEAD", "EMPTY"];
+                    allowed: ("Unknown" | "PreparingRebalance" | "CompletingRebalance" | "Stable" | "Dead" | "Empty" | "Assigning" | "Reconciling" | "NotReady" | "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, IncrementalAlterConfigOperationTypes } from "../../apis/enumerations.js";
+import { allowedAclOperations, allowedAclPermissionTypes, allowedClientQuotaMatchTypes, allowedFetchIsolationLevels, allowedFindCoordinatorKeyTypes, allowedIncrementalAlterConfigOperationTypes, allowedResourcePatternTypes, allowedResourceTypes, ConsumerGroupStates, KafkaConsumerGroupStates, 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,
-                    errorMessage: listErrorMessage(ConsumerGroupStates)
+                    allowed: [...ConsumerGroupStates, ...KafkaConsumerGroupStates],
+                    errorMessage: listErrorMessage([...ConsumerGroupStates, ...KafkaConsumerGroupStates])
                 }
             },
             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-v3.ts';
+import { type ApiVersionsResponseApi } from '../../apis/metadata/api-versions-v1.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,6 +1,6 @@
 import { createPromisifiedCallback, kCallbackPromise, runConcurrentCallbacks } from "../../apis/callbacks.js";
 import * as apis from "../../apis/index.js";
-import { api as apiVersionsV3 } from "../../apis/metadata/api-versions-v3.js";
+import { api as apiVersionsV1 } from "../../apis/metadata/api-versions-v1.js";
 import { baseApisChannel, baseMetadataChannel, createDiagnosticContext, notifyCreation } from "../../diagnostic.js";
 import { MultipleErrors, NetworkError, UnsupportedApiError, UserError } from "../../errors.js";
 import { TypedEventEmitter } from "../../events.js";
@@ -212,8 +212,14 @@ export class Base extends TypedEventEmitter {
                         retryCallback(error);
                         return;
                     }
-                    // We use V3 to be able to get APIS from Kafka 2.4.0+
-                    apiVersionsV3(connection, clientSoftwareName, clientSoftwareVersion, retryCallback);
+                    // 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);
                 }, attempt);
             }, (error, metadata) => {
                 if (error) {
@@ -425,7 +431,16 @@ 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, retryCallback);
+                        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);
+                        });
                     });
                 }, attempt);
             }, (error, metadata) => {

package/dist/clients/consumer/consumer.js

@@ -178,6 +178,10 @@ export class Consumer extends Base {
             callback(validationError);
             return callback[kCallbackPromise];
         }
+        if (options.onCorruptedMessage && options.onDeserializationError) {
+            callback(new UserError('Cannot specify both onCorruptedMessage and onDeserializationError.'));
+            return callback[kCallbackPromise];
+        }
         options.autocommit ??= this[kOptions].autocommit ?? true;
         options.maxBytes ??= this[kOptions].maxBytes;
         options.maxBytesPerPartition ??= this[kOptions].maxBytesPerPartition ?? options.maxBytes;
@@ -573,7 +577,36 @@ 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;
@@ -781,7 +814,17 @@ export class Consumer extends Base {
                         memberEpoch: this.#useConsumerGroupProtocol ? this.#memberEpoch : -1,
                         topics
                     }
-                ], false, groupCallback);
+                ], 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 }]
+                    });
+                });
             });
         }, (error, response) => {
             if (error) {
@@ -1130,7 +1173,12 @@ export class Consumer extends Base {
                             retryCallback(error);
                             return;
                         }
-                        api(connection, FindCoordinatorKeyTypes.GROUP, [this.groupId], retryCallback);
+                        api(connection, FindCoordinatorKeyTypes.GROUP, [this.groupId], (error, response) => {
+                            if (response && api.version < 4) {
+                                response.coordinators[0].key = this.groupId;
+                            }
+                            retryCallback(error, response);
+                        });
                     });
                 });
             }, (error, response) => {
@@ -1511,12 +1559,13 @@ export class Consumer extends Base {
                 if (!partition.records) {
                     continue;
                 }
-                if (partition.abortedTransactions.length) {
+                const abortedTransactions = partition.abortedTransactions ?? [];
+                if (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 partition.abortedTransactions) {
+                    for (const aborted of abortedTransactions) {
                         abortedRanges.set(aborted.producerId, [aborted.firstOffset, -1n]);
                     }
                     // Now find last offsets

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

@@ -9,7 +9,7 @@ import { kAutocommit, kGetFetchNode, kInstance, kRefreshOffsetsAndFetch } from "
 import { kConnections, kCreateConnectionPool, kInspect, kPrometheus } from "../base/base.js";
 import { ensureMetric } from "../metrics.js";
 import { defaultConsumerOptions } from "./options.js";
-import { MessagesStreamFallbackModes, MessagesStreamModes } from "./types.js";
+import { DeserializationErrorActions, MessagesStreamFallbackModes, MessagesStreamModes } from "./types.js";
 import { partitionKey } from "./utils.js";
 // Don't move this function as being in the same file will enable V8 to remove.
 // For futher info, ask Matteo.
@@ -61,6 +61,7 @@ export class MessagesStream extends Readable {
     #closeCallbacks;
     #metricsConsumedMessages;
     #corruptedMessageHandler;
+    #deserializationErrorHandler;
     #context;
     #onConsumerGroupJoin;
     #onBrokerDisconnect;
@@ -83,9 +84,12 @@ export class MessagesStream extends Readable {
     */
     [kConnections];
     constructor(consumer, options) {
-        const { autocommit, mode, fallbackMode, maxFetches, offsets, context, deserializers, onCorruptedMessage, registry, beforeDeserialization, 
+        const { autocommit, mode, fallbackMode, maxFetches, offsets, context, deserializers, onCorruptedMessage, onDeserializationError, registry, beforeDeserialization, 
         // The options below are only destructured to avoid being part of structuredClone below
         partitionAssigner: _partitionAssigner, protocolsMetadata: _protocolsMetadata, ...otherOptions } = options;
+        if (onCorruptedMessage && onDeserializationError) {
+            throw new UserError('Cannot specify both onCorruptedMessage and onDeserializationError.');
+        }
         if (offsets && mode !== MessagesStreamModes.MANUAL) {
             throw new UserError('Cannot specify offsets when the stream mode is not MANUAL.');
         }
@@ -124,6 +128,7 @@ export class MessagesStream extends Readable {
         this.#closed = false;
         this.#closeCallbacks = [];
         this.#corruptedMessageHandler = onCorruptedMessage ?? defaultCorruptedMessageHandler;
+        this.#deserializationErrorHandler = onDeserializationError;
         this.#context = context;
         this.#onConsumerGroupJoin = () => {
             this.#offsetsCommitted.clear();
@@ -605,18 +610,51 @@ export class MessagesStream extends Readable {
                             : this.#commit.bind(this, topic, partition, offset + 1n, leaderEpoch);
                         try {
                             const headers = new Map();
-                            for (const [headerKey, headerValue] of record.headers) {
-                                headers.set(
-                                /* c8 ignore next 2 - Hard to test */
-                                headerKeyDeserializer(headerKey ?? undefined, messageToConsume), headerValueDeserializer(headerValue ?? undefined, messageToConsume));
+                            let payloadType = 'headerKey';
+                            let deserializedKey;
+                            let deserializedValue;
+                            try {
+                                for (const [headerKey, headerValue] of record.headers) {
+                                    payloadType = 'headerKey';
+                                    /* c8 ignore next - Hard to test */
+                                    const deserializedHeaderKey = headerKeyDeserializer(headerKey ?? undefined, messageToConsume);
+                                    payloadType = 'headerValue';
+                                    /* c8 ignore next - Hard to test */
+                                    const deserializedHeaderValue = headerValueDeserializer(headerValue ?? undefined, messageToConsume);
+                                    headers.set(deserializedHeaderKey, deserializedHeaderValue);
+                                }
+                                payloadType = 'key';
+                                /* c8 ignore next - Hard to test */
+                                deserializedKey = keyDeserializer(record.key ?? undefined, headers, messageToConsume);
+                                payloadType = 'value';
+                                deserializedValue = valueDeserializer(record.value ?? undefined, headers, messageToConsume);
+                            }
+                            catch (error) {
+                                const context = {
+                                    error,
+                                    payloadType,
+                                    record,
+                                    topic,
+                                    partition,
+                                    offset,
+                                    timestamp: firstTimestamp + record.timestampDelta,
+                                    commit: commit
+                                };
+                                const shouldDestroy = this.#deserializationErrorHandler
+                                    ? this.#deserializationErrorHandler(context) !== DeserializationErrorActions.SKIP
+                                    : this.#corruptedMessageHandler(record, topic, partition, firstTimestamp, firstOffset, commit, error);
+                                if (shouldDestroy) {
+                                    diagnosticContext.error = error;
+                                    consumerReceivesChannel.error.publish(diagnosticContext);
+                                    this.destroy(new UserError('Failed to deserialize a message.', { cause: error }));
+                                    return;
+                                }
+                                continue;
                             }
-                            /* c8 ignore next 2 - Hard to test */
-                            const key = keyDeserializer(record.key ?? undefined, headers, messageToConsume);
-                            const value = valueDeserializer(record.value ?? undefined, headers, messageToConsume);
                             this.#metricsConsumedMessages?.inc();
                             const message = {
-                                key,
-                                value,
+                                key: deserializedKey,
+                                value: deserializedValue,
                                 headers,
                                 topic,
                                 partition,
@@ -632,13 +670,10 @@ export class MessagesStream extends Readable {
                             consumerReceivesChannel.asyncEnd.publish(diagnosticContext);
                         }
                         catch (error) {
-                            const shouldDestroy = this.#corruptedMessageHandler(record, topic, partition, firstTimestamp, firstOffset, commit, error);
-                            if (shouldDestroy) {
-                                diagnosticContext.error = error;
-                                consumerReceivesChannel.error.publish(diagnosticContext);
-                                this.destroy(new UserError('Failed to deserialize a message.', { cause: error }));
-                                return;
-                            }
+                            diagnosticContext.error = error;
+                            consumerReceivesChannel.error.publish(diagnosticContext);
+                            this.destroy(new UserError('Failed to process a message.', { cause: error }));
+                            return;
                         }
                         finally {
                             consumerReceivesChannel.end.publish(diagnosticContext);

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

@@ -372,6 +372,9 @@ export declare const consumeOptionsSchema: {
         onCorruptedMessage: {
             function: boolean;
         };
+        onDeserializationError: {
+            function: boolean;
+        };
     };
     required: string[];
     additionalProperties: boolean;

package/dist/clients/consumer/options.js

@@ -90,6 +90,7 @@ export const consumeOptionsSchema = {
             }
         },
         onCorruptedMessage: { function: true },
+        onDeserializationError: { function: true },
         ...groupOptionsProperties,
         ...consumeOptionsProperties
     },

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

@@ -5,7 +5,7 @@ import { type ConnectionPool } from '../../network/connection-pool.ts';
 import { type KafkaRecord, type Message } from '../../protocol/records.ts';
 import { type SchemaRegistry } from '../../registries/abstract.ts';
 import { type BaseOptions, type ClusterMetadata, type TopicWithPartitionAndOffset } from '../base/types.ts';
-import { type BeforeDeserializationHook, type Deserializers } from '../serde.ts';
+import { type BeforeDeserializationHook, type BeforeHookPayloadType, type Deserializers } from '../serde.ts';
 export interface GroupProtocolSubscription {
     name: string;
     version: number;
@@ -32,6 +32,25 @@ export interface PreferredReadReplica {
     node: number;
     expiresAt: number;
 }
+export declare const DeserializationErrorActions: {
+    readonly FAIL: "fail";
+    readonly SKIP: "skip";
+};
+export type DeserializationErrorAction = (typeof DeserializationErrorActions)[keyof typeof DeserializationErrorActions];
+export interface DeserializationErrorContext {
+    error: unknown;
+    payloadType: BeforeHookPayloadType;
+    record: KafkaRecord;
+    topic: string;
+    partition: number;
+    offset: bigint;
+    timestamp: bigint;
+    commit: Message['commit'];
+}
+export type DeserializationErrorHandler = (context: DeserializationErrorContext) => DeserializationErrorAction;
+/**
+ * @deprecated Use `DeserializationErrorHandler` instead.
+ */
 export type CorruptedMessageHandler = (record: KafkaRecord, topic: string, partition: number, firstTimestamp: bigint, firstOffset: bigint, commit: Message['commit'], error: unknown) => boolean;
 export type GroupPartitionsAssigner = (current: string, members: Map<string, ExtendedGroupProtocolSubscription>, topics: Set<string>, metadata: ClusterMetadata) => GroupPartitionsAssignments[];
 export type GroupProtocolsMetadataCallback = (protocols: GroupProtocolSubscription[], topics: string[], metadata: ClusterMetadata, callback: Callback<Buffer>) => Buffer | Promise<Buffer> | undefined;
@@ -89,6 +108,10 @@ export interface StreamOptions {
     fallbackMode?: MessagesStreamFallbackModeValue;
     maxFetches?: number;
     offsets?: TopicWithPartitionAndOffset[];
+    onDeserializationError?: DeserializationErrorHandler;
+    /**
+     * @deprecated Use `onDeserializationError` instead.
+     */
     onCorruptedMessage?: CorruptedMessageHandler;
 }
 export type ConsumeOptions<Key, Value, HeaderKey, HeaderValue> = StreamOptions & ConsumeBaseOptions<Key, Value, HeaderKey, HeaderValue> & GroupOptions;

package/dist/clients/consumer/types.js

@@ -1,3 +1,7 @@
+export const DeserializationErrorActions = {
+    FAIL: 'fail',
+    SKIP: 'skip'
+};
 export const MessagesStreamModes = {
     LATEST: 'latest',
     EARLIEST: 'earliest',

package/dist/clients/producer/producer.js

@@ -353,7 +353,12 @@ export class Producer extends Base {
                             retryCallback(error);
                             return;
                         }
-                        api(connection, FindCoordinatorKeyTypes.TRANSACTION, [transactionalId], retryCallback);
+                        api(connection, FindCoordinatorKeyTypes.TRANSACTION, [transactionalId], (error, response) => {
+                            if (response && api.version < 4) {
+                                response.coordinators[0].key = transactionalId;
+                            }
+                            retryCallback(error, response);
+                        });
                     });
                 }, attempt);
             }, (error, response) => {