@platformatic/kafka 1.27.0 → 1.29.0

package/dist/clients/producer/options.js

@@ -3,6 +3,7 @@ import { allowedCompressionsAlgorithms, compressionsAlgorithms } from "../../pro
 import { messageSchema } from "../../protocol/records.js";
 import { ajv, enumErrorMessage } from "../../utils.js";
 import { serdeProperties } from "../serde.js";
+import { allowedProducerStreamReportModes, ProducerStreamReportModes } from "./types.js";
 export const produceOptionsProperties = {
     producerId: { bigint: true },
     producerEpoch: { type: 'number' },
@@ -52,3 +53,20 @@ export const sendOptionsSchema = {
     additionalProperties: false
 };
 export const sendOptionsValidator = ajv.compile(sendOptionsSchema);
+export const defaultProducerStreamOptions = {
+    batchSize: 100,
+    batchTime: 10,
+    reportMode: ProducerStreamReportModes.NONE
+};
+export const producerStreamOptionsSchema = {
+    type: 'object',
+    properties: {
+        highWaterMark: { type: 'integer', minimum: 1 },
+        batchSize: { type: 'integer', minimum: 1 },
+        batchTime: { type: 'integer', minimum: 0 },
+        reportMode: { type: 'string', enum: allowedProducerStreamReportModes },
+        ...produceOptionsProperties
+    },
+    additionalProperties: false
+};
+export const producerStreamOptionsValidator = ajv.compile(producerStreamOptionsSchema);

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

@@ -0,0 +1,19 @@
+import { Writable } from 'node:stream';
+import { type CallbackWithPromise } from '../../apis/callbacks.ts';
+import type { MessageToProduce } from '../../protocol/records.ts';
+import type { Producer } from './producer.ts';
+import { type ProducerStreamOptions } from './types.ts';
+export declare class ProducerStream<Key = Buffer, Value = Buffer, HeaderKey = Buffer, HeaderValue = Buffer> extends Writable {
+    #private;
+    instance: number;
+    constructor(producer: Producer<Key, Value, HeaderKey, HeaderValue>, options: ProducerStreamOptions<Key, Value, HeaderKey, HeaderValue>);
+    get producer(): Producer<Key, Value, HeaderKey, HeaderValue>;
+    close(callback: CallbackWithPromise<void>): void;
+    close(): Promise<void>;
+    _write(message: MessageToProduce<Key, Value, HeaderKey, HeaderValue>, _: BufferEncoding, callback: (error?: Error | null) => void): void;
+    _writev(chunks: Array<{
+        chunk: MessageToProduce<Key, Value, HeaderKey, HeaderValue>;
+    }>, callback: (error?: Error | null) => void): void;
+    _final(callback: (error?: Error | null) => void): void;
+    _destroy(error: Error | null, callback: (error?: Error | null) => void): void;
+}

package/dist/clients/producer/producer-stream.js

@@ -0,0 +1,187 @@
+import { Writable } from 'node:stream';
+import { createPromisifiedCallback, kCallbackPromise } from "../../apis/callbacks.js";
+import { notifyCreation } from "../../diagnostic.js";
+import { defaultProducerStreamOptions } from "./options.js";
+import { ProducerStreamReportModes } from "./types.js";
+let currentInstance = 0;
+export class ProducerStream extends Writable {
+    #producer;
+    #batchSize;
+    #batchTime;
+    #reportMode;
+    #produceOptions;
+    #buffer;
+    #timer;
+    #flushing;
+    #batchId;
+    #pendingWriteCallback;
+    instance;
+    constructor(producer, options) {
+        super({
+            objectMode: true,
+            highWaterMark: options.highWaterMark
+        });
+        const { batchSize, batchTime, reportMode, highWaterMark: _highWaterMark, ...sendOptions } = options;
+        this.#producer = producer;
+        this.#batchSize = batchSize ?? defaultProducerStreamOptions.batchSize;
+        this.#batchTime = batchTime ?? defaultProducerStreamOptions.batchTime;
+        this.#reportMode = reportMode ?? defaultProducerStreamOptions.reportMode;
+        this.#produceOptions = sendOptions;
+        this.#buffer = [];
+        this.#timer = null;
+        this.#flushing = false;
+        this.#batchId = 0;
+        this.#pendingWriteCallback = null;
+        this.instance = currentInstance++;
+        notifyCreation('producer-stream', this);
+    }
+    get producer() {
+        return this.#producer;
+    }
+    close(callback) {
+        if (!callback) {
+            callback = createPromisifiedCallback();
+        }
+        this.end((error) => callback(error ?? null));
+        return callback[kCallbackPromise];
+    }
+    _write(message, _, callback) {
+        this.#buffer.push(message);
+        const finalizeAfterFlush = this.#buffer.length >= this.writableHighWaterMark;
+        if (this.#buffer.length >= this.#batchSize) {
+            this.#clearTimer();
+            this.#flush();
+        }
+        else {
+            this.#scheduleFlush();
+        }
+        if (finalizeAfterFlush) {
+            this.#pendingWriteCallback = callback;
+            return;
+        }
+        callback(null);
+    }
+    _writev(chunks, callback) {
+        for (const { chunk } of chunks) {
+            this.#buffer.push(chunk);
+        }
+        const finalizeAfterFlush = this.#buffer.length >= this.writableHighWaterMark;
+        if (this.#buffer.length >= this.#batchSize) {
+            this.#clearTimer();
+            this.#flush();
+        }
+        else {
+            this.#scheduleFlush();
+        }
+        if (finalizeAfterFlush) {
+            this.#pendingWriteCallback = callback;
+            return;
+        }
+        callback(null);
+    }
+    _final(callback) {
+        this.#clearTimer();
+        if (!this.#buffer.length && !this.#flushing) {
+            callback(null);
+            return;
+        }
+        const self = this;
+        function onError(error) {
+            self.removeListener('error', onError);
+            self.removeListener('flush', onFlush);
+            callback(error);
+        }
+        function onFlush() {
+            if (self.#buffer.length || self.#flushing) {
+                return;
+            }
+            self.removeListener('error', onError);
+            self.removeListener('flush', onFlush);
+            callback(null);
+        }
+        this.on('error', onError);
+        this.on('flush', onFlush);
+        this.#flush();
+    }
+    _destroy(error, callback) {
+        this.#clearTimer();
+        this.#buffer = [];
+        this.#flushWriteCallbacks(error);
+        callback(error);
+    }
+    #scheduleFlush() {
+        if (this.#timer || this.#batchTime < 0) {
+            return;
+        }
+        this.#timer = setTimeout(() => {
+            this.#timer = null;
+            this.#flush();
+        }, this.#batchTime);
+    }
+    #clearTimer() {
+        if (this.#timer) {
+            clearTimeout(this.#timer);
+            this.#timer = null;
+        }
+    }
+    #flush() {
+        if (this.#flushing || this.destroyed) {
+            return;
+        }
+        /* c8 ignore next 3 - Hard to test */
+        if (this.#buffer.length === 0) {
+            return;
+        }
+        this.#flushing = true;
+        const pending = this.#buffer.splice(0, this.#batchSize);
+        const batchId = this.#batchId++;
+        const startedAt = Date.now();
+        this.#producer.send({ messages: pending, ...this.#produceOptions }, (error, result) => {
+            this.#flushing = false;
+            if (error) {
+                this.#flushWriteCallbacks(error);
+                this.destroy(error);
+                return;
+            }
+            this.#emitReports(this.#reportMode, batchId, pending, result);
+            this.emit('flush', { batchId, count: pending.length, duration: Date.now() - startedAt, result: result });
+            if (this.#buffer.length >= this.#batchSize) {
+                this.#flush();
+            }
+            else if (this.#buffer.length > 0) {
+                this.#scheduleFlush();
+            }
+            this.#flushWriteCallbacks();
+        });
+    }
+    #flushWriteCallbacks(error) {
+        if (!this.#pendingWriteCallback || this.#buffer.length >= this.writableHighWaterMark) {
+            return;
+        }
+        const callback = this.#pendingWriteCallback;
+        this.#pendingWriteCallback = null;
+        callback(error ?? null);
+    }
+    #emitReports(mode, batchId, pending, result) {
+        if (mode === ProducerStreamReportModes.NONE) {
+            return;
+        }
+        if (mode === ProducerStreamReportModes.BATCH) {
+            const report = {
+                batchId,
+                count: pending.length,
+                result
+            };
+            this.emit('delivery-report', report);
+            return;
+        }
+        for (let i = 0; i < pending.length; i++) {
+            const report = {
+                batchId,
+                index: i,
+                message: pending[i]
+            };
+            this.emit('delivery-report', report);
+        }
+    }
+}

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

@@ -2,8 +2,9 @@ import { type CallbackWithPromise } from '../../apis/callbacks.ts';
 import { type Message } from '../../protocol/records.ts';
 import { kTransaction, kTransactionAddOffsets, kTransactionAddPartitions, kTransactionCancel, kTransactionCommitOffset, kTransactionEnd, kTransactionFindCoordinator } from '../../symbols.ts';
 import { Base } from '../base/base.ts';
+import { ProducerStream } from './producer-stream.ts';
 import { Transaction } from './transaction.ts';
-import { type ProduceOptions, type ProduceResult, type ProducerInfo, type ProducerOptions, type SendOptions } from './types.ts';
+import { type ProduceOptions, type ProduceResult, type ProducerInfo, type ProducerOptions, type ProducerStreamOptions, type SendOptions } from './types.ts';
 export declare function noopSerializer(data?: Buffer): Buffer | undefined;
 export declare class Producer<Key = Buffer, Value = Buffer, HeaderKey = Buffer, HeaderValue = Buffer> extends Base<ProducerOptions<Key, Value, HeaderKey, HeaderValue>> {
     #private;
@@ -12,8 +13,9 @@ export declare class Producer<Key = Buffer, Value = Buffer, HeaderKey = Buffer,
     get producerEpoch(): number | undefined;
     get transaction(): Transaction<Key, Value, HeaderKey, HeaderValue> | undefined;
     get coordinatorId(): number;
-    close(callback: CallbackWithPromise<void>): void;
-    close(): Promise<void>;
+    get streamsCount(): number;
+    close(force: boolean | CallbackWithPromise<void>, callback?: CallbackWithPromise<void>): void;
+    close(force?: boolean): Promise<void>;
     initIdempotentProducer(options: ProduceOptions<Key, Value, HeaderKey, HeaderValue>, callback: CallbackWithPromise<ProducerInfo>): void;
     initIdempotentProducer(options: ProduceOptions<Key, Value, HeaderKey, HeaderValue>): Promise<ProducerInfo>;
     send(options: SendOptions<Key, Value, HeaderKey, HeaderValue> & {
@@ -22,6 +24,7 @@ export declare class Producer<Key = Buffer, Value = Buffer, HeaderKey = Buffer,
     send(options: SendOptions<Key, Value, HeaderKey, HeaderValue> & {
         [kTransaction]?: number;
     }): Promise<ProduceResult>;
+    asStream(options?: ProducerStreamOptions<Key, Value, HeaderKey, HeaderValue>): ProducerStream<Key, Value, HeaderKey, HeaderValue>;
     beginTransaction(options: ProduceOptions<Key, Value, HeaderKey, HeaderValue>, callback: CallbackWithPromise<Transaction<Key, Value, HeaderKey, HeaderValue>>): void;
     beginTransaction(options?: ProduceOptions<Key, Value, HeaderKey, HeaderValue>): Promise<Transaction<Key, Value, HeaderKey, HeaderValue>>;
     [kTransactionFindCoordinator](callback: CallbackWithPromise<void>): void;

package/dist/clients/producer/producer.js

@@ -9,7 +9,8 @@ import { kInstance, kTransaction, kTransactionAddOffsets, kTransactionAddPartiti
 import { emitExperimentalApiWarning, NumericMap } from "../../utils.js";
 import { Base, kAfterCreate, kCheckNotClosed, kClosed, kGetApi, kGetBootstrapConnection, kGetConnection, kMetadata, kOptions, kPerformDeduplicated, kPerformWithRetry, kPrometheus, kValidateOptions } from "../base/base.js";
 import { ensureMetric } from "../metrics.js";
-import { produceOptionsValidator, producerOptionsValidator, sendOptionsValidator } from "./options.js";
+import { produceOptionsValidator, producerOptionsValidator, producerStreamOptionsValidator, sendOptionsValidator } from "./options.js";
+import { ProducerStream } from "./producer-stream.js";
 import { Transaction } from "./transaction.js";
 // Don't move this function as being in the same file will enable V8 to remove.
 // For futher info, ask Matteo.
@@ -29,6 +30,7 @@ export class Producer extends Base {
     #metricsProducedMessages;
     #coordinatorId;
     #transaction;
+    #streams;
     #sendOperation;
     constructor(options) {
         if (options.idempotent) {
@@ -64,6 +66,7 @@ export class Producer extends Base {
         this.#valueSerializer = serializers?.value ?? noopSerializer;
         this.#headerKeySerializer = serializers?.headerKey ?? noopSerializer;
         this.#headerValueSerializer = serializers?.headerValue ?? noopSerializer;
+        this.#streams = new Set();
         this[kOptions].transactionalId ??= randomUUID();
         if (this[kPrometheus]) {
             ensureMetric(this[kPrometheus], 'Gauge', 'kafka_producers', 'Number of active Kafka producers').inc();
@@ -92,7 +95,14 @@ export class Producer extends Base {
     get coordinatorId() {
         return this.#coordinatorId;
     }
-    close(callback) {
+    get streamsCount() {
+        return this.#streams.size;
+    }
+    close(force, callback) {
+        if (typeof force === 'function') {
+            callback = force;
+            force = false;
+        }
         if (!callback) {
             callback = createPromisifiedCallback();
         }
@@ -101,6 +111,36 @@ export class Producer extends Base {
             return callback[kCallbackPromise];
         }
         this[kClosed] = true;
+        this.#performClose(force, callback);
+        return callback[kCallbackPromise];
+    }
+    #performClose(force, callback) {
+        for (const stream of this.#streams) {
+            /* c8 ignore next 3 - Hard to test */
+            if (stream.closed || stream.destroyed) {
+                this.#streams.delete(stream);
+            }
+        }
+        if (this.#streams.size) {
+            if (!force) {
+                this[kClosed] = false;
+                callback(new UserError('Cannot close producer while producing messages.'));
+                return;
+            }
+            runConcurrentCallbacks('Closing streams failed.', this.#streams, (stream, concurrentCallback) => {
+                stream.close(concurrentCallback);
+            }, error => {
+                /* c8 ignore next 5 - Hard to test */
+                if (error) {
+                    this[kClosed] = false;
+                    callback(error);
+                    return;
+                }
+                this.#streams.clear();
+                this.#performClose(false, callback);
+            });
+            return;
+        }
         super.close(error => {
             if (error) {
                 this[kClosed] = false;
@@ -112,7 +152,6 @@ export class Producer extends Base {
             }
             callback(null);
         });
-        return callback[kCallbackPromise];
     }
     initIdempotentProducer(options, callback) {
         if (!callback) {
@@ -162,6 +201,19 @@ export class Producer extends Base {
         producerSendsChannel.traceCallback(this.#sendOperation, 1, createDiagnosticContext({ client: this, operation: 'send', options }), this, options, callback);
         return callback[kCallbackPromise];
     }
+    asStream(options) {
+        options ??= {};
+        const validationError = this[kValidateOptions](options, producerStreamOptionsValidator, '/options', false);
+        if (validationError) {
+            throw validationError;
+        }
+        const stream = new ProducerStream(this, options);
+        this.#streams.add(stream);
+        stream.once('close', () => {
+            this.#streams.delete(stream);
+        });
+        return stream;
+    }
     beginTransaction(options, callback) {
         if (!callback) {
             callback = createPromisifiedCallback();

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

@@ -13,6 +13,16 @@ export interface ProduceResult {
     unwritableNodes?: number[];
 }
 export type Partitioner<Key, Value, HeaderKey, HeaderValue> = (message: MessageToProduce<Key, Value, HeaderKey, HeaderValue>) => number;
+export interface ProducerStreamReport {
+    batchId: number;
+    count: number;
+    result: ProduceResult;
+}
+export interface ProducerStreamMessageReport<Key, Value, HeaderKey, HeaderValue> {
+    batchId: number;
+    index: number;
+    message: MessageToProduce<Key, Value, HeaderKey, HeaderValue>;
+}
 export interface ProduceOptions<Key, Value, HeaderKey, HeaderValue> {
     producerId?: bigint;
     producerEpoch?: number;
@@ -32,3 +42,17 @@ export type ProducerOptions<Key, Value, HeaderKey, HeaderValue> = BaseOptions &
 export type SendOptions<Key, Value, HeaderKey, HeaderValue> = {
     messages: MessageToProduce<Key, Value, HeaderKey, HeaderValue>[];
 } & ProduceOptions<Key, Value, HeaderKey, HeaderValue>;
+export declare const ProducerStreamReportModes: {
+    readonly NONE: "none";
+    readonly BATCH: "batch";
+    readonly MESSAGE: "message";
+};
+export declare const allowedProducerStreamReportModes: ProducerStreamReportModeValue[];
+export type ProducerStreamReportMode = keyof typeof ProducerStreamReportModes;
+export type ProducerStreamReportModeValue = (typeof ProducerStreamReportModes)[keyof typeof ProducerStreamReportModes];
+export type ProducerStreamOptions<Key, Value, HeaderKey, HeaderValue> = Omit<SendOptions<Key, Value, HeaderKey, HeaderValue>, 'messages'> & {
+    highWaterMark?: number;
+    batchSize?: number;
+    batchTime?: number;
+    reportMode?: ProducerStreamReportModeValue;
+};

package/dist/clients/producer/types.js

@@ -1 +1,6 @@
-export {};
+export const ProducerStreamReportModes = {
+    NONE: 'none',
+    BATCH: 'batch',
+    MESSAGE: 'message'
+};
+export const allowedProducerStreamReportModes = Object.values(ProducerStreamReportModes);

package/dist/diagnostic.d.ts

@@ -4,7 +4,7 @@ import { type ConnectionPool } from './network/connection-pool.ts';
 import { type Connection } from './network/connection.ts';
 export type ClientType = 'base' | 'producer' | 'consumer' | 'admin';
 export interface CreationEvent<InstanceType> {
-    type: ClientType | 'connection' | 'connectionPool';
+    type: ClientType | 'connection' | 'connection-pool' | 'messages-stream' | 'producer-stream';
     instance: InstanceType;
 }
 export type ConnectionDiagnosticEvent<Attributes = Record<string, unknown>> = {
@@ -29,7 +29,7 @@ export type DiagnosticContext<BaseContext = {}> = BaseContext & {
 };
 export declare const channelsNamespace: "plt:kafka";
 export declare function createDiagnosticContext<BaseContext = {}>(context: BaseContext): DiagnosticContext<BaseContext>;
-export declare function notifyCreation<InstanceType>(type: ClientType | 'connection' | 'connection-pool' | 'messages-stream', instance: InstanceType): void;
+export declare function notifyCreation<InstanceType>(type: ClientType | 'connection' | 'connection-pool' | 'messages-stream' | 'producer-stream', instance: InstanceType): void;
 export declare function createChannel<DiagnosticEvent extends object>(name: string): ChannelWithName<DiagnosticEvent>;
 export declare function createTracingChannel<DiagnosticEvent extends object>(name: string): TracingChannelWithName<DiagnosticEvent>;
 export declare const instancesChannel: ChannelWithName<object>;

package/dist/network/connection.js

@@ -126,7 +126,14 @@ export class Connection extends TypedEventEmitter {
                 connectionsConnectsChannel.asyncEnd.publish(diagnosticContext);
             };
             const connectingSocketErrorHandler = (error) => {
-                this.#onConnectionError(host, port, diagnosticContext, error);
+                let cause = error;
+                const tlsConnectionError = error;
+                if (this.#options.tls &&
+                    tlsConnectionError.code === 'ECONNRESET' &&
+                    tlsConnectionError.message.includes('secure TLS connection was established')) {
+                    cause = new UserError('TLS handshake failed. Please verify the broker supports TLS.', { cause: error });
+                }
+                this.#onConnectionError(host, port, diagnosticContext, cause);
             };
             this.emit('connecting');
             this.#host = host;
@@ -404,9 +411,13 @@ export class Connection extends TypedEventEmitter {
         if (sessionLifetimeMs > 0) {
             this.#reauthenticationTimeout = setTimeout(this.reauthenticate.bind(this), Number(sessionLifetimeMs) * 0.8);
         }
-        if (this.#status === ConnectionStatuses.CONNECTED || this.#status === ConnectionStatuses.REAUTHENTICATING) {
+        const isReauthenticating = this.#status === ConnectionStatuses.REAUTHENTICATING;
+        if (this.#status === ConnectionStatuses.CONNECTED || isReauthenticating) {
             this.#status = ConnectionStatuses.CONNECTED;
             this.emit('sasl:authentication:extended', authBytes);
+            if (isReauthenticating) {
+                this.emit('connect');
+            }
         }
         else {
             this.emit('sasl:authentication', authBytes);

package/dist/protocol/sasl/scram-sha.d.ts

@@ -8,7 +8,7 @@ export interface ScramAlgorithmDefinition {
 }
 export interface ScramCryptoModule {
     h: (definition: ScramAlgorithmDefinition, data: string | Buffer) => Buffer;
-    hi: (definition: ScramAlgorithmDefinition, password: string, salt: Buffer, iterations: number) => Buffer;
+    hi: (definition: ScramAlgorithmDefinition, password: string, salt: Buffer, iterations: number) => Promise<Buffer>;
     hmac: (definition: ScramAlgorithmDefinition, key: Buffer, data: string | Buffer) => Buffer;
     xor: (a: Buffer, b: Buffer) => Buffer;
 }
@@ -31,7 +31,7 @@ export declare function createNonce(): string;
 export declare function sanitizeString(str: string): string;
 export declare function parseParameters(data: Buffer): Record<string, string>;
 export declare function h(definition: ScramAlgorithmDefinition, data: string | Buffer): Buffer;
-export declare function hi(definition: ScramAlgorithmDefinition, password: string, salt: Buffer, iterations: number): Buffer;
+export declare function hi(definition: ScramAlgorithmDefinition, password: string, salt: Buffer, iterations: number): Promise<Buffer>;
 export declare function hmac(definition: ScramAlgorithmDefinition, key: Buffer, data: string | Buffer): Buffer;
 export declare function xor(a: Buffer, b: Buffer): Buffer;
 export declare const defaultCrypto: ScramCryptoModule;

package/dist/protocol/sasl/scram-sha.js

@@ -1,4 +1,5 @@
-import { createHash, createHmac, pbkdf2Sync, randomBytes } from 'node:crypto';
+import { createHash, createHmac, pbkdf2, randomBytes } from 'node:crypto';
+import { promisify } from 'node:util';
 import { createPromisifiedCallback, kCallbackPromise } from "../../apis/callbacks.js";
 import { AuthenticationError } from "../../errors.js";
 import { getCredential } from "./utils.js";
@@ -38,8 +39,9 @@ export function parseParameters(data) {
 export function h(definition, data) {
     return createHash(definition.algorithm).update(data).digest();
 }
+const pbkdf2Async = promisify(pbkdf2);
 export function hi(definition, password, salt, iterations) {
-    return pbkdf2Sync(password, salt, iterations, definition.keyLength, definition.algorithm);
+    return pbkdf2Async(password, salt, iterations, definition.keyLength, definition.algorithm);
 }
 export function hmac(definition, key, data) {
     return createHmac(definition.algorithm, key).update(data).digest();
@@ -93,31 +95,37 @@ function performAuthentication(connection, algorithm, definition, authenticateAP
         // ClientProof     := ClientKey XOR ClientSignature
         // ServerKey       := HMAC(SaltedPassword, "Server Key")
         // ServerSignature := HMAC(ServerKey, AuthMessage)
-        const saltedPassword = hi(definition, password, salt, iterations);
-        const clientKey = hmac(definition, saltedPassword, HMAC_CLIENT_KEY);
-        const storedKey = h(definition, clientKey);
-        const clientFinalMessageWithoutProof = `c=${GS2_HEADER_BASE64},r=${serverNonce}`;
-        const authMessage = `${clientFirstMessageBare},${serverFirstMessage},${clientFinalMessageWithoutProof}`;
-        const clientSignature = hmac(definition, storedKey, authMessage);
-        const clientProof = xor(clientKey, clientSignature);
-        const serverKey = hmac(definition, saltedPassword, HMAC_SERVER_KEY);
-        const serverSignature = hmac(definition, serverKey, authMessage);
-        authenticateAPI(connection, Buffer.from(`${clientFinalMessageWithoutProof},p=${clientProof.toString('base64')}`), (error, lastResponse) => {
-            if (error) {
-                callback(new AuthenticationError('SASL authentication failed.', { cause: error }));
-                return;
-            }
-            // Send the last message to the server
-            const lastData = parseParameters(lastResponse.authBytes);
-            if (lastData.e) {
-                callback(new AuthenticationError(lastData.e));
-                return;
-            }
-            else if (lastData.v !== serverSignature.toString('base64')) {
-                callback(new AuthenticationError('Invalid server signature.'));
-                return;
-            }
-            callback(null, lastResponse);
+        hi(definition, password, salt, iterations)
+            .then(saltedPassword => {
+            const clientKey = hmac(definition, saltedPassword, HMAC_CLIENT_KEY);
+            const storedKey = h(definition, clientKey);
+            const clientFinalMessageWithoutProof = `c=${GS2_HEADER_BASE64},r=${serverNonce}`;
+            const authMessage = `${clientFirstMessageBare},${serverFirstMessage},${clientFinalMessageWithoutProof}`;
+            const clientSignature = hmac(definition, storedKey, authMessage);
+            const clientProof = xor(clientKey, clientSignature);
+            const serverKey = hmac(definition, saltedPassword, HMAC_SERVER_KEY);
+            const serverSignature = hmac(definition, serverKey, authMessage);
+            authenticateAPI(connection, Buffer.from(`${clientFinalMessageWithoutProof},p=${clientProof.toString('base64')}`), (error, lastResponse) => {
+                if (error) {
+                    callback(new AuthenticationError('SASL authentication failed.', { cause: error }));
+                    return;
+                }
+                // Send the last message to the server
+                const lastData = parseParameters(lastResponse.authBytes);
+                if (lastData.e) {
+                    callback(new AuthenticationError(lastData.e));
+                    return;
+                }
+                else if (lastData.v !== serverSignature.toString('base64')) {
+                    callback(new AuthenticationError('Invalid server signature.'));
+                    return;
+                }
+                callback(null, lastResponse);
+            });
+        })
+            /* c8 ignore next 3 - Hard to test */
+            .catch(error => {
+            callback(new AuthenticationError('SASL authentication failed.', { cause: error }));
         });
     });
 }

package/dist/typescript-4/dist/apis/admin/describe-cluster-v0.d.ts

@@ -18,6 +18,6 @@ export interface DescribeClusterResponse {
   brokers: DescribeClusterResponseBroker[];
   clusterAuthorizedOperations: number;
 }
-export declare function createRequest(includeClusterAuthorizedOperations: boolean): Writer;
+export declare function createRequest(includeClusterAuthorizedOperations: boolean, _endpointType: number): Writer;
 export declare function parseResponse(_correlationId: number, apiKey: number, apiVersion: number, reader: Reader): DescribeClusterResponse;
-export declare const api: import("../definitions").API<[includeClusterAuthorizedOperations: boolean], DescribeClusterResponse>;
+export declare const api: import("../definitions").API<[includeClusterAuthorizedOperations: boolean, _endpointType: number], DescribeClusterResponse>;

package/dist/typescript-4/dist/apis/admin/list-groups-v4.d.ts

@@ -12,6 +12,6 @@ export interface ListGroupsResponse {
   errorCode: number;
   groups: ListGroupsResponseGroup[];
 }
-export declare function createRequest(statesFilter: ConsumerGroupStateValue[]): Writer;
+export declare function createRequest(statesFilter: ConsumerGroupStateValue[], _typesFilter: string[]): Writer;
 export declare function parseResponse(_correlationId: number, apiKey: number, apiVersion: number, reader: Reader): ListGroupsResponse;
-export declare const api: import("../definitions").API<[statesFilter: ("PREPARING_REBALANCE" | "COMPLETING_REBALANCE" | "STABLE" | "DEAD" | "EMPTY")[]], ListGroupsResponse>;
+export declare const api: import("../definitions").API<[statesFilter: ("PREPARING_REBALANCE" | "COMPLETING_REBALANCE" | "STABLE" | "DEAD" | "EMPTY")[], _typesFilter: string[]], ListGroupsResponse>;

package/dist/typescript-4/dist/apis/admin/list-transactions-v0.d.ts

@@ -13,6 +13,6 @@ export interface ListTransactionsResponse {
   unknownStateFilters: string[];
   transactionStates: ListTransactionsResponseTransactionState[];
 }
-export declare function createRequest(stateFilters: TransactionState[], producerIdFilters: bigint[]): Writer;
+export declare function createRequest(stateFilters: TransactionState[], producerIdFilters: bigint[], _durationFilter: bigint): Writer;
 export declare function parseResponse(_correlationId: number, apiKey: number, apiVersion: number, reader: Reader): ListTransactionsResponse;
-export declare const api: import("../definitions").API<[stateFilters: ("EMPTY" | "ONGOING" | "PREPARE_ABORT" | "COMMITTING" | "ABORTING" | "COMPLETE_COMMIT" | "COMPLETE_ABORT")[], producerIdFilters: bigint[]], ListTransactionsResponse>;
+export declare const api: import("../definitions").API<[stateFilters: ("EMPTY" | "ONGOING" | "PREPARE_ABORT" | "COMMITTING" | "ABORTING" | "COMPLETE_COMMIT" | "COMPLETE_ABORT")[], producerIdFilters: bigint[], _durationFilter: bigint], ListTransactionsResponse>;

package/dist/typescript-4/dist/apis/consumer/join-group-v6.d.ts

@@ -22,6 +22,6 @@ export interface JoinGroupResponse {
   memberId: NullableString;
   members: JoinGroupResponseMember[];
 }
-export declare function createRequest(groupId: string, sessionTimeoutMs: number, rebalanceTimeoutMs: number, memberId: string, groupInstanceId: NullableString, protocolType: string, protocols: JoinGroupRequestProtocol[]): Writer;
+export declare function createRequest(groupId: string, sessionTimeoutMs: number, rebalanceTimeoutMs: number, memberId: string, groupInstanceId: NullableString, protocolType: string, protocols: JoinGroupRequestProtocol[], _reason?: NullableString): Writer;
 export declare function parseResponse(_correlationId: number, apiKey: number, apiVersion: number, reader: Reader): JoinGroupResponse;
-export declare const api: import("../definitions").API<[groupId: string, sessionTimeoutMs: number, rebalanceTimeoutMs: number, memberId: string, groupInstanceId: NullableString, protocolType: string, protocols: JoinGroupRequestProtocol[]], JoinGroupResponse>;
+export declare const api: import("../definitions").API<[groupId: string, sessionTimeoutMs: number, rebalanceTimeoutMs: number, memberId: string, groupInstanceId: NullableString, protocolType: string, protocols: JoinGroupRequestProtocol[], _reason?: NullableString], JoinGroupResponse>;

package/dist/typescript-4/dist/apis/consumer/join-group-v7.d.ts

@@ -22,6 +22,6 @@ export interface JoinGroupResponse {
   memberId: NullableString;
   members: JoinGroupResponseMember[];
 }
-export declare function createRequest(groupId: string, sessionTimeoutMs: number, rebalanceTimeoutMs: number, memberId: string, groupInstanceId: NullableString, protocolType: string, protocols: JoinGroupRequestProtocol[]): Writer;
+export declare function createRequest(groupId: string, sessionTimeoutMs: number, rebalanceTimeoutMs: number, memberId: string, groupInstanceId: NullableString, protocolType: string, protocols: JoinGroupRequestProtocol[], _reason?: NullableString): Writer;
 export declare function parseResponse(_correlationId: number, apiKey: number, apiVersion: number, reader: Reader): JoinGroupResponse;
-export declare const api: import("../definitions").API<[groupId: string, sessionTimeoutMs: number, rebalanceTimeoutMs: number, memberId: string, groupInstanceId: NullableString, protocolType: string, protocols: JoinGroupRequestProtocol[]], JoinGroupResponse>;
+export declare const api: import("../definitions").API<[groupId: string, sessionTimeoutMs: number, rebalanceTimeoutMs: number, memberId: string, groupInstanceId: NullableString, protocolType: string, protocols: JoinGroupRequestProtocol[], _reason?: NullableString], JoinGroupResponse>;

package/dist/typescript-4/dist/apis/consumer/offset-commit-v8.d.ts

@@ -24,6 +24,6 @@ export interface OffsetCommitResponse {
   throttleTimeMs: number;
   topics: OffsetCommitResponseTopic[];
 }
-export declare function createRequest(groupId: string, generationIdOrMemberEpoch: number, memberId: string, groupInstanceId: NullableString, topics: OffsetCommitRequestTopic[]): Writer;
+export declare function createRequest(groupId: string, generationIdOrMemberEpoch: number, memberId: NullableString, groupInstanceId: NullableString, topics: OffsetCommitRequestTopic[]): Writer;
 export declare function parseResponse(_correlationId: number, apiKey: number, apiVersion: number, reader: Reader): OffsetCommitResponse;
-export declare const api: import("../definitions").API<[groupId: string, generationIdOrMemberEpoch: number, memberId: string, groupInstanceId: NullableString, topics: OffsetCommitRequestTopic[]], OffsetCommitResponse>;
+export declare const api: import("../definitions").API<[groupId: string, generationIdOrMemberEpoch: number, memberId: NullableString, groupInstanceId: NullableString, topics: OffsetCommitRequestTopic[]], OffsetCommitResponse>;

package/dist/typescript-4/dist/apis/consumer/sync-group-v4.d.ts

@@ -13,6 +13,6 @@ export interface SyncGroupResponse {
   protocolName: NullableString;
   assignment: Buffer;
 }
-export declare function createRequest(groupId: string, generationId: number, memberId: string, groupInstanceId: NullableString, assignments: SyncGroupRequestAssignment[]): Writer;
+export declare function createRequest(groupId: string, generationId: number, memberId: string, groupInstanceId: NullableString, _protocolType: NullableString, _protocolName: NullableString, assignments: SyncGroupRequestAssignment[]): Writer;
 export declare function parseResponse(_correlationId: number, apiKey: number, apiVersion: number, reader: Reader): SyncGroupResponse;
-export declare const api: import("../definitions").API<[groupId: string, generationId: number, memberId: string, groupInstanceId: NullableString, assignments: SyncGroupRequestAssignment[]], SyncGroupResponse>;
+export declare const api: import("../definitions").API<[groupId: string, generationId: number, memberId: string, groupInstanceId: NullableString, _protocolType: NullableString, _protocolName: NullableString, assignments: SyncGroupRequestAssignment[]], SyncGroupResponse>;