@platformatic/kafka 1.0.0 → 1.2.0

package/dist/errors.js

@@ -12,6 +12,7 @@ export const errorCodes = [
     'PLT_KFK_TIMEOUT',
     'PLT_KFK_UNEXPECTED_CORRELATION_ID',
     'PLT_KFK_UNFINISHED_WRITE_BUFFER',
+    'PLT_KFK_UNSUPPORTED_API',
     'PLT_KFK_UNSUPPORTED_COMPRESSION',
     'PLT_KFK_UNSUPPORTED',
     'PLT_KFK_USER'
@@ -75,7 +76,6 @@ export class MultipleErrors extends AggregateError {
             return this;
         }
         for (const error of this.errors) {
-            /* c8 ignore next */
             if (error[kGenericError] ? error.findBy(property, value) : error[property] === value) {
                 return error;
             }
@@ -131,30 +131,36 @@ export class TimeoutError extends GenericError {
 export class UnexpectedCorrelationIdError extends GenericError {
     static code = 'PLT_KFK_UNEXPECTED_CORRELATION_ID';
     constructor(message, properties = {}) {
-        super(UnexpectedCorrelationIdError.code, message, properties);
+        super(UnexpectedCorrelationIdError.code, message, { canRetry: false, ...properties });
     }
 }
 export class UnfinishedWriteBufferError extends GenericError {
     static code = 'PLT_KFK_UNFINISHED_WRITE_BUFFER';
     constructor(message, properties = {}) {
-        super(UnfinishedWriteBufferError.code, message, properties);
+        super(UnfinishedWriteBufferError.code, message, { canRetry: false, ...properties });
+    }
+}
+export class UnsupportedApiError extends GenericError {
+    static code = 'PLT_KFK_UNSUPPORTED_API';
+    constructor(message, properties = {}) {
+        super(UnsupportedApiError.code, message, { canRetry: false, ...properties });
     }
 }
 export class UnsupportedCompressionError extends GenericError {
     static code = 'PLT_KFK_UNSUPPORTED_COMPRESSION';
     constructor(message, properties = {}) {
-        super(UnsupportedCompressionError.code, message, properties);
+        super(UnsupportedCompressionError.code, message, { canRetry: false, ...properties });
     }
 }
 export class UnsupportedError extends GenericError {
     static code = 'PLT_KFK_UNSUPPORTED';
     constructor(message, properties = {}) {
-        super(UnsupportedError.code, message, properties);
+        super(UnsupportedError.code, message, { canRetry: false, ...properties });
     }
 }
 export class UserError extends GenericError {
     static code = 'PLT_KFK_USER';
     constructor(message, properties = {}) {
-        super(UserError.code, message, properties);
+        super(UserError.code, message, { canRetry: false, ...properties });
     }
 }

package/dist/index.d.ts

@@ -1,3 +1,4 @@
+export * from './diagnostic.ts';
 export * from './errors.ts';
 export * from './utils.ts';
 export * from './network/index.ts';

package/dist/index.js

@@ -1,4 +1,5 @@
 // General
+export * from "./diagnostic.js";
 export * from "./errors.js";
 export * from "./utils.js";
 // Networking

package/dist/network/connection-pool.d.ts

@@ -4,8 +4,9 @@ import { Connection, type Broker, type ConnectionOptions } from './connection.ts
 export declare class ConnectionPool extends EventEmitter {
     #private;
     constructor(clientId: string, connectionOptions?: ConnectionOptions);
+    get instanceId(): number;
     get(broker: Broker, callback: CallbackWithPromise<Connection>): void;
     get(broker: Broker): Promise<Connection>;
-    getFirstAvailable(brokers: Broker[], callback?: CallbackWithPromise<Connection>, current?: number, errors?: Error[]): void | Promise<Connection>;
+    getFirstAvailable(brokers: Broker[], callback?: CallbackWithPromise<Connection>): void | Promise<Connection>;
     close(callback?: CallbackWithPromise<void>): void | Promise<void>;
 }

package/dist/network/connection-pool.js

@@ -1,8 +1,11 @@
 import EventEmitter from 'node:events';
 import { createPromisifiedCallback, kCallbackPromise, runConcurrentCallbacks } from "../clients/callbacks.js";
+import { connectionsPoolGetsChannel, createDiagnosticContext, notifyCreation } from "../diagnostic.js";
 import { MultipleErrors } from "../errors.js";
 import { Connection, ConnectionStatuses } from "./connection.js";
+let currentInstance = 0;
 export class ConnectionPool extends EventEmitter {
+    #instanceId;
     #clientId;
     // @ts-ignore This is used just for debugging
     #ownerId;
@@ -10,17 +13,47 @@ export class ConnectionPool extends EventEmitter {
     #connectionOptions;
     constructor(clientId, connectionOptions = {}) {
         super();
+        this.#instanceId = currentInstance++;
         this.#clientId = clientId;
         this.#ownerId = connectionOptions.ownerId;
         this.#connections = new Map();
         this.#connectionOptions = connectionOptions;
+        notifyCreation('connection-pool', this);
+    }
+    get instanceId() {
+        return this.#instanceId;
     }
     get(broker, callback) {
-        const key = `${broker.host}:${broker.port}`;
-        const existing = this.#connections.get(key);
         if (!callback) {
             callback = createPromisifiedCallback();
         }
+        connectionsPoolGetsChannel.traceCallback(this.#get, 1, createDiagnosticContext({ connectionPool: this, broker, operation: 'get' }), this, broker, callback);
+        return callback[kCallbackPromise];
+    }
+    getFirstAvailable(brokers, callback) {
+        if (!callback) {
+            callback = createPromisifiedCallback();
+        }
+        connectionsPoolGetsChannel.traceCallback(this.#getFirstAvailable, 3, createDiagnosticContext({ connectionPool: this, brokers, operation: 'getFirstAvailable' }), this, brokers, 0, [], callback);
+        return callback[kCallbackPromise];
+    }
+    close(callback) {
+        if (!callback) {
+            callback = createPromisifiedCallback();
+        }
+        if (this.#connections.size === 0) {
+            callback(null);
+            return callback[kCallbackPromise];
+        }
+        runConcurrentCallbacks('Closing connections failed.', this.#connections, ([key, connection], cb) => {
+            connection.close(cb);
+            this.#connections.delete(key);
+        }, error => callback(error));
+        return callback[kCallbackPromise];
+    }
+    #get(broker, callback) {
+        const key = `${broker.host}:${broker.port}`;
+        const existing = this.#connections.get(key);
         if (existing) {
             if (existing.status !== ConnectionStatuses.CONNECTED) {
                 existing.ready(error => {
@@ -34,7 +67,7 @@ export class ConnectionPool extends EventEmitter {
             else {
                 callback(null, existing);
             }
-            return callback[kCallbackPromise];
+            return;
         }
         const connection = new Connection(this.#clientId, this.#connectionOptions);
         this.#connections.set(key, connection);
@@ -61,28 +94,6 @@ export class ConnectionPool extends EventEmitter {
         connection.on('drain', () => {
             this.emit('drain', eventPayload);
         });
-        return callback[kCallbackPromise];
-    }
-    getFirstAvailable(brokers, callback, current = 0, errors = []) {
-        if (!callback) {
-            callback = createPromisifiedCallback();
-        }
-        this.#getFirstAvailable(brokers, current, errors, callback);
-        return callback[kCallbackPromise];
-    }
-    close(callback) {
-        if (!callback) {
-            callback = createPromisifiedCallback();
-        }
-        if (this.#connections.size === 0) {
-            callback(null);
-            return callback[kCallbackPromise];
-        }
-        runConcurrentCallbacks('Closing connections failed.', this.#connections, ([key, connection], cb) => {
-            connection.close(cb);
-            this.#connections.delete(key);
-        }, error => callback(error));
-        return callback[kCallbackPromise];
     }
     #getFirstAvailable(brokers, current = 0, errors = [], callback) {
         this.get(brokers[current], (error, connection) => {

package/dist/network/connection.d.ts

@@ -23,6 +23,7 @@ export interface Request {
     payload: () => Writer;
     parser: ResponseParser<unknown>;
     callback: Callback<any>;
+    diagnostic: Record<string, unknown>;
 }
 export declare const ConnectionStatuses: {
     readonly NONE: "none";
@@ -35,11 +36,10 @@ export declare const ConnectionStatuses: {
 export type ConnectionStatus = keyof typeof ConnectionStatuses;
 export type ConnectionStatusValue = (typeof ConnectionStatuses)[keyof typeof ConnectionStatuses];
 export declare const defaultOptions: ConnectionOptions;
-export declare function noResponseCallback(..._: any[]): void;
-export declare namespace noResponseCallback { }
 export declare class Connection extends EventEmitter {
     #private;
     constructor(clientId?: string, options?: ConnectionOptions);
+    get instanceId(): number;
     get status(): ConnectionStatusValue;
     get socket(): Socket;
     connect(host: string, port: number, callback?: CallbackWithPromise<void>): void | Promise<void>;

package/dist/network/connection.js

@@ -3,6 +3,7 @@ import EventEmitter from 'node:events';
 import { createConnection } from 'node:net';
 import { connect as createTLSConnection } from 'node:tls';
 import { createPromisifiedCallback, kCallbackPromise } from "../clients/callbacks.js";
+import { connectionsApiChannel, connectionsConnectsChannel, createDiagnosticContext, notifyCreation } from "../diagnostic.js";
 import { NetworkError, TimeoutError, UnexpectedCorrelationIdError } from "../errors.js";
 import { protocolAPIsById } from "../protocol/apis.js";
 import { EMPTY_OR_SINGLE_COMPACT_LENGTH_SIZE, INT32_SIZE } from "../protocol/definitions.js";
@@ -22,13 +23,11 @@ export const defaultOptions = {
     connectTimeout: 5000,
     maxInflights: 5
 };
-const kNoResponse = Symbol('plt.kafka.noResponse');
-/* c8 ignore next */
-export function noResponseCallback(..._) { }
-noResponseCallback[kNoResponse] = true;
+let currentInstance = 0;
 export class Connection extends EventEmitter {
     #options;
     #status;
+    #instanceId;
     #clientId;
     // @ts-ignore This is used just for debugging
     #ownerId;
@@ -44,6 +43,7 @@ export class Connection extends EventEmitter {
     constructor(clientId, options = {}) {
         super();
         this.setMaxListeners(0);
+        this.#instanceId = currentInstance++;
         this.#options = Object.assign({}, defaultOptions, options);
         this.#status = ConnectionStatuses.NONE;
         this.#clientId = clientId;
@@ -56,6 +56,10 @@ export class Connection extends EventEmitter {
         this.#responseBuffer = new DynamicBuffer();
         this.#responseReader = new Reader(this.#responseBuffer);
         this.#socketMustBeDrained = false;
+        notifyCreation('connection', this);
+    }
+    get instanceId() {
+        return this.#instanceId;
     }
     get status() {
         return this.#status;
@@ -67,49 +71,72 @@ export class Connection extends EventEmitter {
         if (!callback) {
             callback = createPromisifiedCallback();
         }
-        if (this.#status === ConnectionStatuses.CONNECTED) {
-            callback(null);
-            return callback[kCallbackPromise];
-        }
-        this.ready(callback);
-        if (this.#status === ConnectionStatuses.CONNECTING) {
-            return callback[kCallbackPromise];
+        const diagnosticContext = createDiagnosticContext({ connection: this, operation: 'connect', host, port });
+        connectionsConnectsChannel.start.publish(diagnosticContext);
+        try {
+            if (this.#status === ConnectionStatuses.CONNECTED) {
+                callback(null);
+                return callback[kCallbackPromise];
+            }
+            this.ready(callback);
+            if (this.#status === ConnectionStatuses.CONNECTING) {
+                return callback[kCallbackPromise];
+            }
+            this.#status = ConnectionStatuses.CONNECTING;
+            const connectionOptions = {
+                timeout: this.#options.connectTimeout
+            };
+            const connectionTimeoutHandler = () => {
+                const error = new TimeoutError(`Connection to ${host}:${port} timed out.`);
+                diagnosticContext.error = error;
+                this.#socket.destroy();
+                this.#status = ConnectionStatuses.ERROR;
+                connectionsConnectsChannel.error.publish(diagnosticContext);
+                connectionsConnectsChannel.asyncStart.publish(diagnosticContext);
+                this.emit('timeout', error);
+                this.emit('error', error);
+                connectionsConnectsChannel.asyncEnd.publish(diagnosticContext);
+            };
+            const connectionErrorHandler = (e) => {
+                const error = new NetworkError(`Connection to ${host}:${port} failed.`, { cause: e });
+                diagnosticContext.error = error;
+                this.#status = ConnectionStatuses.ERROR;
+                connectionsConnectsChannel.error.publish(diagnosticContext);
+                connectionsConnectsChannel.asyncStart.publish(diagnosticContext);
+                this.emit('error', error);
+                connectionsConnectsChannel.asyncEnd.publish(diagnosticContext);
+            };
+            this.emit('connecting');
+            /* c8 ignore next 3 - TLS connection is not tested but we rely on Node.js tests */
+            this.#socket = this.#options.tls
+                ? createTLSConnection(port, host, { ...this.#options.tls, ...connectionOptions })
+                : createConnection({ ...connectionOptions, port, host });
+            this.#socket.setNoDelay(true);
+            this.#socket.once('connect', () => {
+                this.#socket.removeListener('timeout', connectionTimeoutHandler);
+                this.#socket.removeListener('error', connectionErrorHandler);
+                this.#socket.on('error', this.#onError.bind(this));
+                this.#socket.on('data', this.#onData.bind(this));
+                this.#socket.on('drain', this.#onDrain.bind(this));
+                this.#socket.on('close', this.#onClose.bind(this));
+                this.#socket.setTimeout(0);
+                this.#status = ConnectionStatuses.CONNECTED;
+                connectionsConnectsChannel.asyncStart.publish(diagnosticContext);
+                this.emit('connect');
+                connectionsConnectsChannel.asyncEnd.publish(diagnosticContext);
+            });
+            this.#socket.once('timeout', connectionTimeoutHandler);
+            this.#socket.once('error', connectionErrorHandler);
         }
-        this.#status = ConnectionStatuses.CONNECTING;
-        const connectionOptions = {
-            timeout: this.#options.connectTimeout
-        };
-        const connectionTimeoutHandler = () => {
-            const error = new TimeoutError(`Connection to ${host}:${port} timed out.`);
-            this.#socket.destroy();
-            this.#status = ConnectionStatuses.ERROR;
-            this.emit('timeout', error);
-            this.emit('error', error);
-        };
-        const connectionErrorHandler = (e) => {
-            const error = new NetworkError(`Connection to ${host}:${port} failed.`, { cause: e });
+        catch (error) {
             this.#status = ConnectionStatuses.ERROR;
-            this.emit('error', error);
-        };
-        this.emit('connecting');
-        /* c8 ignore next 3 */
-        this.#socket = this.#options.tls
-            ? createTLSConnection(port, host, { ...this.#options.tls, ...connectionOptions })
-            : createConnection({ ...connectionOptions, port, host });
-        this.#socket.setNoDelay(true);
-        this.#socket.once('connect', () => {
-            this.#socket.removeListener('timeout', connectionTimeoutHandler);
-            this.#socket.removeListener('error', connectionErrorHandler);
-            this.#socket.on('error', this.#onError.bind(this));
-            this.#socket.on('data', this.#onData.bind(this));
-            this.#socket.on('drain', this.#onDrain.bind(this));
-            this.#socket.on('close', this.#onClose.bind(this));
-            this.#socket.setTimeout(0);
-            this.#status = ConnectionStatuses.CONNECTED;
-            this.emit('connect');
-        });
-        this.#socket.once('timeout', connectionTimeoutHandler);
-        this.#socket.once('error', connectionErrorHandler);
+            diagnosticContext.error = error;
+            connectionsConnectsChannel.error.publish(diagnosticContext);
+            throw error;
+        }
+        finally {
+            connectionsConnectsChannel.end.publish(diagnosticContext);
+        }
         return callback[kCallbackPromise];
     }
     ready(callback) {
@@ -169,7 +196,14 @@ export class Connection extends EventEmitter {
                 hasResponseHeaderTaggedFields,
                 parser: responseParser,
                 payload,
-                callback: fastQueueCallback
+                callback: fastQueueCallback,
+                diagnostic: createDiagnosticContext({
+                    connection: this,
+                    operation: 'send',
+                    apiKey,
+                    apiVersion,
+                    correlationId
+                })
             };
             if (this.#socketMustBeDrained) {
                 this.#afterDrainRequests.push(request);
@@ -187,44 +221,56 @@ export class Connection extends EventEmitter {
         client_id => NULLABLE_STRING
     */
     #sendRequest(request) {
-        if (this.#status !== ConnectionStatuses.CONNECTED) {
-            request.callback(new NetworkError('Connection closed'), undefined);
-            return false;
-        }
-        let canWrite = true;
-        const { correlationId, apiKey, apiVersion, payload: payloadFn, hasRequestHeaderTaggedFields } = request;
-        const writer = Writer.create()
-            .appendInt16(apiKey)
-            .appendInt16(apiVersion)
-            .appendInt32(correlationId)
-            .appendString(this.#clientId, false);
-        if (hasRequestHeaderTaggedFields) {
-            writer.appendTaggedFields();
-        }
-        const payload = payloadFn();
-        writer.appendFrom(payload);
-        writer.prependLength();
-        // Write the header
-        this.#socket.cork();
-        if (!payload.context.noResponse) {
-            this.#inflightRequests.set(correlationId, request);
-        }
-        /* c8 ignore next */
-        loggers.protocol({ apiKey: protocolAPIsById[apiKey], correlationId, request }, 'Sending request.');
-        for (const buf of writer.buffers) {
-            if (!this.#socket.write(buf)) {
-                canWrite = false;
+        connectionsApiChannel.start.publish(request.diagnostic);
+        try {
+            if (this.#status !== ConnectionStatuses.CONNECTED) {
+                request.callback(new NetworkError('Connection closed'), undefined);
+                return false;
+            }
+            let canWrite = true;
+            const { correlationId, apiKey, apiVersion, payload: payloadFn, hasRequestHeaderTaggedFields } = request;
+            const writer = Writer.create()
+                .appendInt16(apiKey)
+                .appendInt16(apiVersion)
+                .appendInt32(correlationId)
+                .appendString(this.#clientId, false);
+            if (hasRequestHeaderTaggedFields) {
+                writer.appendTaggedFields();
             }
+            const payload = payloadFn();
+            writer.appendFrom(payload);
+            writer.prependLength();
+            // Write the header
+            this.#socket.cork();
+            if (!payload.context.noResponse) {
+                this.#inflightRequests.set(correlationId, request);
+            }
+            loggers.protocol({ apiKey: protocolAPIsById[apiKey], correlationId, request }, 'Sending request.');
+            for (const buf of writer.buffers) {
+                if (!this.#socket.write(buf)) {
+                    canWrite = false;
+                }
+            }
+            if (!canWrite) {
+                this.#socketMustBeDrained = true;
+            }
+            this.#socket.uncork();
+            if (payload.context.noResponse) {
+                request.callback(null, canWrite);
+            }
+            // debugDump(Date.now() % 100000, 'send', { owner: this.#ownerId, apiKey: protocolAPIsById[apiKey], correlationId })
+            return canWrite;
         }
-        if (!canWrite) {
-            this.#socketMustBeDrained = true;
+        catch (error) {
+            request.diagnostic.error = error;
+            connectionsApiChannel.error.publish(request.diagnostic);
+            connectionsApiChannel.end.publish(request.diagnostic);
+            throw error;
+            /* c8 ignore next 3 - C8 does not detect these as covered */
         }
-        this.#socket.uncork();
-        if (payload.context.noResponse) {
-            request.callback(null, canWrite);
+        finally {
+            connectionsApiChannel.end.publish(request.diagnostic);
         }
-        // debugDump(Date.now() % 100000, 'send', { owner: this.#ownerId, apiKey: protocolAPIsById[apiKey], correlationId })
-        return canWrite;
     }
     /*
       Response Header v1 => correlation_id TAG_BUFFER
@@ -281,9 +327,17 @@ export class Connection extends EventEmitter {
             //   apiKey: protocolAPIsById[apiKey],
             //   correlationId
             // })
-            /* c8 ignore next */
             loggers.protocol({ apiKey: protocolAPIsById[apiKey], correlationId, request }, 'Received response.');
+            if (responseError) {
+                request.diagnostic.error = responseError;
+                connectionsApiChannel.error.publish(request.diagnostic);
+            }
+            else {
+                request.diagnostic.result = deserialized;
+            }
+            connectionsApiChannel.asyncStart.publish(request.diagnostic);
             callback(responseError, deserialized);
+            connectionsApiChannel.asyncStart.publish(request.diagnostic);
         }
     }
     #onDrain() {

package/dist/protocol/compression.js

@@ -17,7 +17,7 @@ function loadSnappy() {
         const snappy = require('snappy');
         snappyCompressSync = snappy.compressSync;
         snappyDecompressSync = snappy.uncompressSync;
-        /* c8 ignore next 5 */
+        /* c8 ignore next 5 - In tests snappy is always available */
     }
     catch (e) {
         throw new UnsupportedCompressionError('Cannot load snappy module, which is an optionalDependency. Please check your local installation.');
@@ -28,7 +28,7 @@ function loadLZ4() {
         const lz4 = require('lz4-napi');
         lz4CompressSync = lz4.compressSync;
         lz4DecompressSync = lz4.uncompressSync;
-        /* c8 ignore next 5 */
+        /* c8 ignore next 5 - In tests lz4-napi is always available */
     }
     catch (e) {
         throw new UnsupportedCompressionError('Cannot load lz4-napi module, which is an optionalDependency. Please check your local installation.');
@@ -58,14 +58,14 @@ export const compressionsAlgorithms = {
     },
     snappy: {
         compressSync(data) {
-            /* c8 ignore next 4 */
+            /* c8 ignore next 4 - In tests snappy is always available */
             if (!snappyCompressSync) {
                 loadSnappy();
             }
             return snappyCompressSync(ensureBuffer(data));
         },
         decompressSync(data) {
-            /* c8 ignore next 4 */
+            /* c8 ignore next 4 - In tests snappy is always available */
             if (!snappyDecompressSync) {
                 loadSnappy();
             }
@@ -76,14 +76,14 @@ export const compressionsAlgorithms = {
     },
     lz4: {
         compressSync(data) {
-            /* c8 ignore next 4 */
+            /* c8 ignore next 4 - In tests lz4-napi is always available */
             if (!lz4CompressSync) {
                 loadLZ4();
             }
             return lz4CompressSync(ensureBuffer(data));
         },
         decompressSync(data) {
-            /* c8 ignore next 4 */
+            /* c8 ignore next 4 - In tests lz4-napi is always available */
             if (!lz4DecompressSync) {
                 loadLZ4();
             }
@@ -93,14 +93,14 @@ export const compressionsAlgorithms = {
         available: true
     },
     zstd: {
-        /* c8 ignore next 7 */
+        /* c8 ignore next 7 - Tests are only run on Node.js versions that support zstd */
         compressSync(data) {
             if (!zstdCompressSync) {
                 throw new UnsupportedCompressionError('zstd is not supported in the current Node.js version');
             }
             return zstdCompressSync(ensureBuffer(data));
         },
-        /* c8 ignore next 7 */
+        /* c8 ignore next 7 - Tests are only run on Node.js versions that support zstd */
         decompressSync(data) {
             if (!zstdCompressSync) {
                 throw new UnsupportedCompressionError('zstd is not supported in the current Node.js version');

package/dist/protocol/reader.js

@@ -205,7 +205,6 @@ export class Reader {
         return value;
     }
     readBytes(compact = true) {
-        /* c8 ignore next */
         return this.readNullableBytes(compact) || EMPTY_BUFFER;
     }
     readVarIntBytes() {

package/dist/protocol/records.js

@@ -83,7 +83,6 @@ export function createRecordsBatch(messages, options = {}) {
         attributes |= IS_TRANSACTIONAL;
     }
     // Set the compression, if any
-    /* c8 ignore next */
     if ((options.compression ?? 'none') !== 'none') {
         const algorithm = compressionsAlgorithms[options.compression];
         if (!algorithm) {
@@ -100,9 +99,7 @@ export function createRecordsBatch(messages, options = {}) {
         .appendInt32(messages.length - 1)
         .appendInt64(BigInt(firstTimestamp))
         .appendInt64(BigInt(maxTimestamp))
-        /* c8 ignore next */
         .appendInt64(options.producerId ?? -1n)
-        /* c8 ignore next */
         .appendInt16(options.producerEpoch ?? 0)
         .appendInt32(firstSequence)
         .appendInt32(messages.length) // Number of records

package/dist/protocol/sasl/plain.d.ts

@@ -1,3 +1,3 @@
-import { type SASLAuthenticationAPI, type SaslAuthenticateResponse } from '../../apis/security/sasl-authenticate.ts';
+import { type SASLAuthenticationAPI, type SaslAuthenticateResponse } from '../../apis/security/sasl-authenticate-v2.ts';
 import { type Connection } from '../../network/connection.ts';
 export declare function authenticate(authenticateAPI: SASLAuthenticationAPI, connection: Connection, username: string, password: string): Promise<SaslAuthenticateResponse>;

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

@@ -1,10 +1,16 @@
-import { type SASLAuthenticationAPI, type SaslAuthenticateResponse } from '../../apis/security/sasl-authenticate.ts';
+import { type SASLAuthenticationAPI, type SaslAuthenticateResponse } from '../../apis/security/sasl-authenticate-v2.ts';
 import { type Connection } from '../../network/connection.ts';
 export interface ScramAlgorithmDefinition {
     keyLength: number;
     algorithm: string;
     minIterations: number;
 }
+export interface ScramCryptoModule {
+    h: (definition: ScramAlgorithmDefinition, data: string | Buffer) => Buffer;
+    hi: (definition: ScramAlgorithmDefinition, password: string, salt: Buffer, iterations: number) => Buffer;
+    hmac: (definition: ScramAlgorithmDefinition, key: Buffer, data: string | Buffer) => Buffer;
+    xor: (a: Buffer, b: Buffer) => Buffer;
+}
 export declare const ScramAlgorithms: {
     readonly 'SHA-256': {
         readonly keyLength: 32;
@@ -21,8 +27,9 @@ export type ScramAlgorithm = keyof typeof ScramAlgorithms;
 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<ArrayBufferLike>;
-export declare function hi(definition: ScramAlgorithmDefinition, password: string, salt: Buffer, iterations: number): Buffer<ArrayBufferLike>;
+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 hmac(definition: ScramAlgorithmDefinition, key: Buffer, data: string | Buffer): Buffer;
 export declare function xor(a: Buffer, b: Buffer): Buffer;
-export declare function authenticate(authenticateAPI: SASLAuthenticationAPI, connection: Connection, algorithm: ScramAlgorithm, username: string, password: string): Promise<SaslAuthenticateResponse>;
+export declare const defaultCrypto: ScramCryptoModule;
+export declare function authenticate(authenticateAPI: SASLAuthenticationAPI, connection: Connection, algorithm: ScramAlgorithm, username: string, password: string, crypto?: ScramCryptoModule): Promise<SaslAuthenticateResponse>;

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

@@ -50,8 +50,15 @@ export function xor(a, b) {
     }
     return result;
 }
+export const defaultCrypto = {
+    h,
+    hi,
+    hmac,
+    xor
+};
 // Implements https://datatracker.ietf.org/doc/html/rfc5802#section-9
-export async function authenticate(authenticateAPI, connection, algorithm, username, password) {
+export async function authenticate(authenticateAPI, connection, algorithm, username, password, crypto = defaultCrypto) {
+    const { h, hi, hmac, xor } = crypto;
     const definition = ScramAlgorithms[algorithm];
     if (!definition) {
         throw new AuthenticationError(`Unsupported SCRAM algorithm ${algorithm}`);
@@ -99,6 +106,5 @@ export async function authenticate(authenticateAPI, connection, algorithm, usern
     else if (lastData.v !== serverSignature.toString('base64')) {
         throw new AuthenticationError('Invalid server signature.');
     }
-    /* c8 ignore next 2 */
     return lastResponse;
 }

package/dist/symbols.d.ts

@@ -0,0 +1 @@
+export declare const kInstance: unique symbol;

package/dist/symbols.js

@@ -0,0 +1,2 @@
+// IMPORTANT: Never export this file in index.ts - The symbols are meant to be private
+export const kInstance = Symbol('plt.kafka.base.instance');