@platformatic/kafka 2.10.0 → 2.12.0

package/dist/network/connection.js

@@ -4,7 +4,8 @@ import { createConnection } from 'node:net';
 import { connect as createTLSConnection } from 'node:tls';
 import { createPromisifiedCallback, kCallbackPromise } from "../apis/callbacks.js";
 import { allowedSASLMechanisms, SASLMechanisms } from "../apis/enumerations.js";
-import { saslAuthenticateV2, saslHandshakeV1 } from "../apis/index.js";
+import { clientSoftwareName, clientSoftwareVersion } from "../clients/base/options.js";
+import { apiVersionsV1, saslAuthenticateV0, saslAuthenticateV1, saslAuthenticateV2, saslHandshakeV1 } from "../apis/index.js";
 import { connectionsApiChannel, connectionsConnectsChannel, createDiagnosticContext, notifyCreation } from "../diagnostic.js";
 import { AuthenticationError, NetworkError, TimeoutError, UnexpectedCorrelationIdError, UserError } from "../errors.js";
 import { TypedEventEmitter } from "../events.js";
@@ -44,6 +45,7 @@ export class Connection extends TypedEventEmitter {
     #correlationId;
     #nextMessage;
     #afterDrainRequests;
+    #payloadQueue;
     #requestsQueue;
     #inflightRequests;
     #responseBuffer;
@@ -52,6 +54,8 @@ export class Connection extends TypedEventEmitter {
     #socketMustBeDrained;
     #detectMissingTLS;
     #reauthenticationTimeout;
+    // Negotiated once per connection: reauthentication runs the same path again.
+    #saslAuthenticateApi;
     constructor(clientId, options = {}) {
         super();
         this.setMaxListeners(0);
@@ -71,6 +75,7 @@ export class Connection extends TypedEventEmitter {
         this.#correlationId = 0;
         this.#nextMessage = 0;
         this.#afterDrainRequests = [];
+        this.#payloadQueue = fastq((op, cb) => op(cb), 1);
         this.#requestsQueue = fastq((op, cb) => op(cb), this.#options.maxInflights ?? defaultOptions.maxInflights);
         this.#inflightRequests = new Map();
         this.#responseBuffer = new DynamicBuffer();
@@ -271,45 +276,80 @@ export class Connection extends TypedEventEmitter {
             apiVersion,
             correlationId
         });
-        const writer = Writer.create();
-        writer.appendInt16(apiKey).appendInt16(apiVersion).appendInt32(correlationId).appendString(this.#clientId, false);
-        if (hasRequestHeaderTaggedFields) {
-            writer.appendTaggedFields();
-        }
-        let payload;
-        try {
-            payload = createPayload();
-        }
-        catch (err) {
-            diagnostic.error = err;
-            connectionsApiChannel.error.publish(diagnostic);
-            return callback(err);
-        }
-        writer.appendFrom(payload).prependLength();
-        const request = {
-            correlationId,
-            apiKey,
-            apiVersion,
-            parser: responseParser,
-            payload: writer.buffer,
-            callback: null, // Will be set later
-            hasResponseHeaderTaggedFields,
-            noResponse: payload.context.noResponse ?? false,
-            diagnostic,
-            timeoutHandle: null,
-            timedOut: false
-        };
-        this.#requestsQueue.push(fastQueueCallback => {
-            request.callback = fastQueueCallback;
-            if (!request.noResponse) {
-                request.timeoutHandle = setTimeout(this.#onRequestTimeout.bind(this, request), this.#options.requestTimeout);
+        this.#payloadQueue.push(payloadQueueCallback => {
+            let payloadQueueCompleted = false;
+            const completePayloadQueue = () => {
+                if (!payloadQueueCompleted) {
+                    payloadQueueCompleted = true;
+                    payloadQueueCallback(null);
+                }
+            };
+            const onPayloadError = (error) => {
+                diagnostic.error = error;
+                connectionsApiChannel.error.publish(diagnostic);
+                try {
+                    callback(error);
+                }
+                finally {
+                    completePayloadQueue();
+                }
+            };
+            const onPayload = (payload) => {
+                try {
+                    const writer = Writer.create();
+                    writer
+                        .appendInt16(apiKey)
+                        .appendInt16(apiVersion)
+                        .appendInt32(correlationId)
+                        .appendString(this.#clientId, false);
+                    if (hasRequestHeaderTaggedFields) {
+                        writer.appendTaggedFields();
+                    }
+                    writer.appendFrom(payload).prependLength();
+                    const request = {
+                        correlationId,
+                        apiKey,
+                        apiVersion,
+                        parser: responseParser,
+                        payload: writer.buffer,
+                        callback: null, // Will be set later
+                        hasResponseHeaderTaggedFields,
+                        noResponse: payload.context.noResponse ?? false,
+                        diagnostic,
+                        timeoutHandle: null,
+                        timedOut: false
+                    };
+                    this.#requestsQueue.push(fastQueueCallback => {
+                        request.callback = fastQueueCallback;
+                        if (!request.noResponse) {
+                            request.timeoutHandle = setTimeout(this.#onRequestTimeout.bind(this, request), this.#options.requestTimeout);
+                        }
+                        if (this.#socketMustBeDrained) {
+                            this.#afterDrainRequests.push(request);
+                            return false;
+                        }
+                        return this.#sendRequest(request);
+                    }, this.#onResponse.bind(this, request, callback));
+                }
+                catch (error) {
+                    onPayloadError(error);
+                    return;
+                }
+                completePayloadQueue();
+            };
+            try {
+                const payload = createPayload();
+                if (typeof payload.then === 'function') {
+                    Promise.resolve(payload).then(onPayload, onPayloadError);
+                }
+                else {
+                    onPayload(payload);
+                }
             }
-            if (this.#socketMustBeDrained) {
-                this.#afterDrainRequests.push(request);
-                return false;
+            catch (error) {
+                onPayloadError(error);
             }
-            return this.#sendRequest(request);
-        }, this.#onResponse.bind(this, request, callback));
+        }, () => { });
     }
     reauthenticate() {
         if (!this.#options.sasl) {
@@ -329,7 +369,11 @@ export class Connection extends TypedEventEmitter {
     }
     #onRequestTimeout(request) {
         request.timedOut = true;
-        request.callback(new TimeoutError('Request timed out'), null);
+        this.#inflightRequests.delete(request.correlationId);
+        this.#afterDrainRequests = this.#afterDrainRequests.filter(r => r !== request);
+        this.#status = ConnectionStatuses.CLOSING;
+        request.callback(new TimeoutError('Request timed out', { canRetry: true }), null);
+        this.#socket?.destroy();
     }
     #authenticate(host, port, diagnosticContext) {
         if (this.#status === ConnectionStatuses.CONNECTING) {
@@ -340,28 +384,71 @@ export class Connection extends TypedEventEmitter {
             this.#onConnectionError(host, port, diagnosticContext, new UserError(`SASL mechanism ${mechanism} not supported.`));
             return;
         }
-        saslHandshakeV1.api(this, mechanism, (error, response) => {
+        this.#negotiateSaslAuthenticate(saslAuthenticate => {
+            saslHandshakeV1.api(this, mechanism, (error, response) => {
+                if (error) {
+                    this.#onConnectionError(host, port, diagnosticContext, new AuthenticationError('Cannot find a suitable SASL mechanism.', { cause: error }));
+                    return;
+                }
+                this.emit('sasl:handshake', response.mechanisms);
+                const callback = this.#onSaslAuthenticate.bind(this, host, port, diagnosticContext);
+                if (authenticate) {
+                    authenticate(mechanism, this, saslAuthenticate, username, password, token, callback);
+                }
+                else if (mechanism === SASLMechanisms.PLAIN) {
+                    saslPlain.authenticate(saslAuthenticate, this, username, password, callback);
+                }
+                else if (mechanism === SASLMechanisms.OAUTHBEARER) {
+                    saslOAuthBearer.authenticate(saslAuthenticate, this, token, oauthBearerExtensions, callback);
+                }
+                else if (mechanism === SASLMechanisms.GSSAPI) {
+                    callback(new UserError('No custom SASL/GSSAPI authenticator provided.'));
+                }
+                else {
+                    saslScramSha.authenticate(saslAuthenticate, this, mechanism.substring(6), username, password, defaultCrypto, callback);
+                }
+            });
+        });
+    }
+    /**
+     * Chooses the SaslAuthenticate version to authenticate with.
+     *
+     * The version cannot be assumed: v1 arrived in Apache Kafka 2.0 and v2 in 2.4, so pinning the
+     * newest makes authentication fail outright on older brokers, which answer an unparseable request
+     * with InvalidRequestException and drop the connection.
+     *
+     * Brokers accept ApiVersions before authentication precisely so that clients can ask, and it has
+     * to happen before SaslHandshake: once the handshake is sent the connection only accepts
+     * SaslAuthenticate. The result is cached because reauthentication runs this path again.
+     *
+     * SaslHandshake itself stays at v1. v0 signals the pre-1.0 flow, where the SASL tokens are written
+     * raw on the wire rather than wrapped in SaslAuthenticate requests, which this package does not
+     * implement.
+     */
+    #negotiateSaslAuthenticate(callback) {
+        if (this.#saslAuthenticateApi) {
+            callback(this.#saslAuthenticateApi);
+            return;
+        }
+        const candidates = [
+            [2, saslAuthenticateV2.api],
+            [1, saslAuthenticateV1.api],
+            [0, saslAuthenticateV0.api]
+        ];
+        apiVersionsV1.api(this, clientSoftwareName, clientSoftwareVersion, (error, response) => {
+            let selected;
+            /* c8 ignore next 3 - Only reachable against a broker which refuses ApiVersions before authentication */
             if (error) {
-                this.#onConnectionError(host, port, diagnosticContext, new AuthenticationError('Cannot find a suitable SASL mechanism.', { cause: error }));
-                return;
-            }
-            this.emit('sasl:handshake', response.mechanisms);
-            const callback = this.#onSaslAuthenticate.bind(this, host, port, diagnosticContext);
-            if (authenticate) {
-                authenticate(mechanism, this, saslAuthenticateV2.api, username, password, token, callback);
-            }
-            else if (mechanism === SASLMechanisms.PLAIN) {
-                saslPlain.authenticate(saslAuthenticateV2.api, this, username, password, callback);
-            }
-            else if (mechanism === SASLMechanisms.OAUTHBEARER) {
-                saslOAuthBearer.authenticate(saslAuthenticateV2.api, this, token, oauthBearerExtensions, callback);
-            }
-            else if (mechanism === SASLMechanisms.GSSAPI) {
-                callback(new UserError('No custom SASL/GSSAPI authenticator provided.'));
+                selected = undefined;
             }
             else {
-                saslScramSha.authenticate(saslAuthenticateV2.api, this, mechanism.substring(6), username, password, defaultCrypto, callback);
+                const advertised = response.apiKeys.find(api => api.apiKey === saslAuthenticateV2.api.key);
+                selected = candidates.find(([version]) => advertised && version >= advertised.minVersion && version <= advertised.maxVersion)?.[1];
             }
+            // Falling back to the newest version keeps the previous behaviour for brokers which do not
+            // answer the probe, rather than failing a connection which would otherwise have worked.
+            this.#saslAuthenticateApi = selected ?? saslAuthenticateV2.api;
+            callback(this.#saslAuthenticateApi);
         });
     }
     /*
@@ -582,12 +669,14 @@ export class Connection extends TypedEventEmitter {
         this.emit('close');
         const error = new NetworkError('Connection closed');
         for (const request of this.#afterDrainRequests) {
-            if (!request.noResponse) {
+            if (!request.noResponse && !request.timedOut) {
                 request.callback(error, undefined);
             }
         }
         for (const inflight of this.#inflightRequests.values()) {
-            inflight.callback(error, undefined);
+            if (!inflight.timedOut) {
+                inflight.callback(error, undefined);
+            }
         }
     }
     #onError(error) {

package/dist/protocol/compression.d.ts

@@ -1,7 +1,9 @@
 import { DynamicBuffer } from '@platformatic/dynamic-buffer';
 export type SyncCompressionPhase = (data: Buffer | DynamicBuffer) => Buffer;
+export type AsyncCompressionPhase = (data: Buffer | DynamicBuffer) => Promise<Buffer>;
 export type CompressionOperation = (data: Buffer) => Buffer;
 export interface CompressionAlgorithmSpecification {
+    compress?: AsyncCompressionPhase;
     compressSync: SyncCompressionPhase;
     decompressSync: SyncCompressionPhase;
     bitmask: number;
@@ -17,6 +19,7 @@ export declare const CompressionAlgorithms: {
 export declare const allowedCompressionsAlgorithms: CompressionAlgorithmValue[];
 export type CompressionAlgorithm = keyof typeof CompressionAlgorithms;
 export type CompressionAlgorithmValue = (typeof CompressionAlgorithms)[keyof typeof CompressionAlgorithms];
+declare function gzipAsync(data: Buffer | DynamicBuffer): Promise<Buffer>;
 export declare const compressionsAlgorithms: {
     readonly none: {
         readonly compressSync: (data: Buffer | DynamicBuffer) => Buffer;
@@ -25,6 +28,7 @@ export declare const compressionsAlgorithms: {
         readonly available: true;
     };
     readonly gzip: {
+        readonly compress: typeof gzipAsync;
         readonly compressSync: (data: Buffer | DynamicBuffer) => Buffer;
         readonly decompressSync: (data: Buffer | DynamicBuffer) => Buffer;
         readonly bitmask: 1;
@@ -56,6 +60,7 @@ export declare const compressionsAlgorithmsByBitmask: {
         readonly bitmask: 0;
         readonly available: true;
     } | {
+        readonly compress: typeof gzipAsync;
         readonly compressSync: (data: Buffer | DynamicBuffer) => Buffer;
         readonly decompressSync: (data: Buffer | DynamicBuffer) => Buffer;
         readonly bitmask: 1;
@@ -77,3 +82,4 @@ export declare const compressionsAlgorithmsByBitmask: {
         readonly available: boolean;
     };
 };
+export {};

package/dist/protocol/compression.js

@@ -2,7 +2,7 @@ import { DynamicBuffer } from '@platformatic/dynamic-buffer';
 import { lz4Compress, lz4Decompress, snappyCompress, snappyDecompress } from '@platformatic/wasm-utils';
 import zlib from 'node:zlib';
 import { UnsupportedCompressionError } from "../errors.js";
-const { zstdCompressSync, zstdDecompressSync, gzipSync, gunzipSync } = zlib;
+const { gzip, zstdCompressSync, zstdDecompressSync, gzipSync, gunzipSync } = zlib;
 export const CompressionAlgorithms = {
     NONE: 'none',
     GZIP: 'gzip',
@@ -14,6 +14,18 @@ export const allowedCompressionsAlgorithms = Object.values(CompressionAlgorithms
 function ensureBuffer(data) {
     return DynamicBuffer.isDynamicBuffer(data) ? data.buffer : data;
 }
+function gzipAsync(data) {
+    const { promise, resolve, reject } = Promise.withResolvers();
+    gzip(ensureBuffer(data), (error, result) => {
+        if (error) {
+            reject(error);
+        }
+        else {
+            resolve(result);
+        }
+    });
+    return promise;
+}
 const snappyCompressSync = snappyCompress;
 const lz4CompressFrameSync = lz4Compress;
 const lz4DecompressFrameSync = lz4Decompress;
@@ -53,6 +65,7 @@ export const compressionsAlgorithms = {
         available: true
     },
     gzip: {
+        compress: gzipAsync,
         compressSync(data) {
             return gzipSync(ensureBuffer(data));
         },

package/dist/protocol/definitions.js

@@ -7,5 +7,5 @@ export const EMPTY_BUFFER = Buffer.alloc(0);
 export const EMPTY_UUID = Buffer.alloc(UUID_SIZE);
 // Since it is serialized at either 0 (for nullable) or 1 (since length is stored as length + 1), it always uses a single byte
 export const EMPTY_OR_SINGLE_COMPACT_LENGTH_SIZE = INT8_SIZE;
-// TODO: Tagged fields are not supported yet
+// Flexible-version messages use this zero-length tagged-field section.
 export const EMPTY_TAGGED_FIELDS_BUFFER = Buffer.from([0]);

package/dist/protocol/reader.js

@@ -187,9 +187,13 @@ export class Reader {
         return this.readNullableString(compact, encoding) || '';
     }
     readUUID() {
-        const value = this.peekUUID();
+        const hex = this.peekUUID();
         this.position += UUID_SIZE;
-        return value.replace(/(.{8})(.{4})(.{4})(.{4})(.{12})/, '$1-$2-$3-$4-$5');
+        // Hyphenated by slicing rather than by a capture group regex. This runs once per topic per
+        // Fetch response from v13 up, and the regex form measured about fourteen times the cost, which
+        // made the newest Fetch versions measurably slower to decode than the ones identifying topics
+        // by name.
+        return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
     }
     readNullableBytes(compact = true) {
         let length;
@@ -300,7 +304,7 @@ export class Reader {
         }
         return reader();
     }
-    // TODO: Tagged fields are not supported yet
+    // Skip unknown tagged fields because codecs do not expose them to callers.
     readTaggedFields() {
         const length = this.readUnsignedVarInt();
         for (let i = 0; i < length; i++) {

package/dist/protocol/records.d.ts

@@ -123,5 +123,6 @@ export declare const messageSchema: {
 export declare function createRecord(message: MessageRecord, offsetDelta: number, firstTimestamp: bigint): Writer;
 export declare function readRecord(reader: Reader): KafkaRecord;
 export declare function createRecordsBatch(messages: MessageRecord[], options?: Partial<CreateRecordsBatchOptions>): Writer;
+export declare function createRecordsBatchAsync(messages: MessageRecord[], options?: Partial<CreateRecordsBatchOptions>): Promise<Writer>;
 export declare function readRecordsBatch(reader: Reader): RecordsBatch;
 export declare function readRecordsBatches(reader: Reader): RecordsBatch[];

package/dist/protocol/records.js

@@ -58,11 +58,11 @@ export function readRecord(reader) {
         headers: reader.readVarIntArray(r => [r.readVarIntBytes(), r.readVarIntBytes()])
     };
 }
-export function createRecordsBatch(messages, options = {}) {
+function prepareRecordsBatch(messages, options) {
     const now = BigInt(Date.now());
     const firstTimestamp = messages[0].timestamp ?? now;
     let maxTimestamp = firstTimestamp;
-    let buffer = new DynamicBuffer();
+    const buffer = new DynamicBuffer();
     for (let i = 0; i < messages.length; i++) {
         let ts = messages[i].timestamp ?? now;
         /* c8 ignore next 3 - Hard to test */
@@ -81,32 +81,34 @@ export function createRecordsBatch(messages, options = {}) {
         const firstMessage = messages[0];
         firstSequence = options.sequences.getWithDefault(`${firstMessage.topic}:${firstMessage.partition}`, 0);
     }
-    // Set the transaction
     if (options.transactionalId) {
         attributes |= IS_TRANSACTIONAL;
     }
-    // Set the compression, if any
-    if ((options.compression ?? 'none') !== 'none') {
-        const algorithm = compressionsAlgorithms[options.compression];
-        if (!algorithm) {
-            throw new UnsupportedCompressionError(`Unsupported compression algorithm ${options.compression}`);
-        }
-        attributes |= algorithm.bitmask;
-        const compressed = algorithm.compressSync(buffer.buffer);
-        buffer = new DynamicBuffer(compressed);
+    return { attributes, buffer, firstSequence, firstTimestamp, maxTimestamp };
+}
+function getCompressionAlgorithm(compression) {
+    if ((compression ?? 'none') === 'none') {
+        return undefined;
+    }
+    const algorithm = compressionsAlgorithms[compression];
+    if (!algorithm) {
+        throw new UnsupportedCompressionError(`Unsupported compression algorithm ${compression}`);
     }
+    return algorithm;
+}
+function finalizeRecordsBatch(messages, options, prepared) {
     const writer = Writer.create()
         // Phase 1: Prepare the message from Attributes (included) to the end
-        .appendInt16(attributes)
+        .appendInt16(prepared.attributes)
         // LastOffsetDelta, FirstTimestamp and MaxTimestamp are extracted from the messages
         .appendInt32(messages.length - 1)
-        .appendInt64(BigInt(firstTimestamp))
-        .appendInt64(BigInt(maxTimestamp))
+        .appendInt64(BigInt(prepared.firstTimestamp))
+        .appendInt64(BigInt(prepared.maxTimestamp))
         .appendInt64(options.producerId ?? -1n)
         .appendInt16(options.producerEpoch ?? 0)
-        .appendInt32(firstSequence)
+        .appendInt32(prepared.firstSequence)
         .appendInt32(messages.length) // Number of records
-        .appendFrom(buffer);
+        .appendFrom(prepared.buffer);
     // Phase 2: Prepend the PartitionLeaderEpoch, Magic and CRC, then the Length and firstOffset, in reverse order
     return (writer
         .appendUnsignedInt32(crc32c(writer.dynamicBuffer), false)
@@ -116,6 +118,27 @@ export function createRecordsBatch(messages, options = {}) {
         // FirstOffset is 0
         .appendInt64(0n, false));
 }
+export function createRecordsBatch(messages, options = {}) {
+    const prepared = prepareRecordsBatch(messages, options);
+    const algorithm = getCompressionAlgorithm(options.compression);
+    if (algorithm) {
+        prepared.attributes |= algorithm.bitmask;
+        prepared.buffer = new DynamicBuffer(algorithm.compressSync(prepared.buffer.buffer));
+    }
+    return finalizeRecordsBatch(messages, options, prepared);
+}
+export async function createRecordsBatchAsync(messages, options = {}) {
+    const prepared = prepareRecordsBatch(messages, options);
+    const algorithm = getCompressionAlgorithm(options.compression);
+    if (algorithm) {
+        prepared.attributes |= algorithm.bitmask;
+        const compressed = algorithm.compress
+            ? await algorithm.compress(prepared.buffer.buffer)
+            : algorithm.compressSync(prepared.buffer.buffer);
+        prepared.buffer = new DynamicBuffer(compressed);
+    }
+    return finalizeRecordsBatch(messages, options, prepared);
+}
 // TODO: Early bail out if there are not enough bytes to read all the records as it might be truncated
 export function readRecordsBatch(reader) {
     const initialPosition = reader.position;

package/dist/protocol/writer.js

@@ -1,6 +1,6 @@
 import { DynamicBuffer } from '@platformatic/dynamic-buffer';
 import { humanize } from "../utils.js";
-import { EMPTY_TAGGED_FIELDS_BUFFER, EMPTY_UUID } from "./definitions.js";
+import { EMPTY_TAGGED_FIELDS_BUFFER, EMPTY_UUID, UUID_SIZE } from "./definitions.js";
 const instanceIdentifier = Symbol('plt.kafka.writer.instanceIdentifier');
 export class Writer {
     context;
@@ -125,6 +125,12 @@ export class Writer {
             return this.append(EMPTY_UUID);
         }
         const buffer = Buffer.from(value.replaceAll('-', ''), 'hex');
+        // UUIDs are fixed width and carry no length prefix, so anything that is not exactly 16 bytes
+        // would silently desync the rest of the request. Buffer.from() stops at the first non hex
+        // character, so a topic name used as a topic id would append nothing at all here.
+        if (buffer.length !== UUID_SIZE) {
+            throw new RangeError(`Expected a UUID, got ${JSON.stringify(value)}.`);
+        }
         this.#buffer.append(buffer);
         return this;
     }
@@ -138,7 +144,9 @@ export class Writer {
         else {
             this.appendInt32(value.length);
         }
-        this.#buffer.append(value);
+        if (value.length > 0) {
+            this.#buffer.append(value);
+        }
         return this;
     }
     // Note that this does not follow the wire protocol specification and thus the length is not +1ed
@@ -147,7 +155,12 @@ export class Writer {
             return this.appendVarInt(-1);
         }
         this.appendVarInt(value.length);
-        this.#buffer.append(value);
+        // Appending an empty buffer corrupts DynamicBuffer's positional reads, so it must be skipped:
+        // see https://github.com/platformatic/dynamic-buffer/issues/12. Record keys and values are
+        // allowed to be empty without being null, so this is reachable.
+        if (value.length > 0) {
+            this.#buffer.append(value);
+        }
         return this;
     }
     appendArray(value, entryWriter, compact = true, appendTrailingTaggedFields = true) {
@@ -210,7 +223,7 @@ export class Writer {
         }
         return this;
     }
-    // TODO: Tagged fields are not supported yet
+    // This client emits only empty tagged-field sections; it does not expose tagged fields to callers.
     appendTaggedFields(_ = []) {
         return this.append(EMPTY_TAGGED_FIELDS_BUFFER);
     }

package/dist/registries/confluent-schema-registry.d.ts

@@ -4,7 +4,8 @@ import { type ConnectionOptions as TLSConnectionOptions } from 'node:tls';
 import { type Root } from 'protobufjs';
 import { type Callback } from '../apis/definitions.ts';
 import { type BeforeDeserializationHook, type BeforeHookPayloadType, type BeforeSerializationHook, type Deserializers, type Serializers } from '../clients/serde.ts';
-import { type CredentialProvider, UserError } from '../index.ts';
+import { UserError } from '../errors.ts';
+import { type CredentialProvider } from '../network/connection.ts';
 import { type MessageToConsume, type MessageToProduce } from '../protocol/records.ts';
 import { AbstractSchemaRegistry } from './abstract.ts';
 type ConfluentSchemaRegistryMessageToProduce = MessageToProduce<unknown, unknown, unknown, unknown>;

package/dist/registries/confluent-schema-registry.js

@@ -6,7 +6,8 @@ import avro from 'avsc';
 import { createRequire } from 'node:module';
 import { setTimeout as sleep } from 'node:timers/promises';
 import { jsonDeserializer, jsonSerializer, stringDeserializer, stringSerializer } from "../clients/serde.js";
-import { EMPTY_BUFFER, MultipleErrors, NetworkError, TimeoutError, UnsupportedFormatError, UserError } from "../index.js";
+import { MultipleErrors, NetworkError, TimeoutError, UnsupportedFormatError, UserError } from "../errors.js";
+import { EMPTY_BUFFER } from "../protocol/definitions.js";
 import { getCredential } from "../protocol/sasl/utils.js";
 import { AbstractSchemaRegistry } from "./abstract.js";
 const require = createRequire(import.meta.url);

package/dist/symbols.d.ts

@@ -1,6 +1,7 @@
 export declare const kInstance: unique symbol;
 export declare const kRefreshOffsetsAndFetch: unique symbol;
 export declare const kAutocommit: unique symbol;
+export declare const kUpdateCommittedOffset: unique symbol;
 export declare const kGetFetchNode: unique symbol;
 export declare const kDeserializationError: unique symbol;
 export declare const kTransaction: unique symbol;

package/dist/symbols.js

@@ -2,6 +2,7 @@
 export const kInstance = Symbol('plt.kafka.base.instance');
 export const kRefreshOffsetsAndFetch = Symbol('plt.kafka.messagesStream.refreshOffsetsAndFetch');
 export const kAutocommit = Symbol('plt.kafka.messagesStream.autocommit');
+export const kUpdateCommittedOffset = Symbol('plt.kafka.messagesStream.updateCommittedOffset');
 export const kGetFetchNode = Symbol('plt.kafka.consumer.getFetchNode');
 export const kDeserializationError = Symbol('plt.kafka.messagesStream.deserializationError');
 export const kTransaction = Symbol('plt.kafka.producer.transactions');

package/dist/typescript-4/dist/apis/admin/alter-client-quotas-v0.d.ts

@@ -0,0 +1,40 @@
+import { type NullableString } from "../../protocol/definitions";
+import { type Reader } from "../../protocol/reader";
+import { Writer } from "../../protocol/writer";
+import type { ClientQuotaEntityType, ClientQuotaKey } from "../enumerations";
+export type { ClientQuotaEntityType, ClientQuotaKey } from "../enumerations";
+export interface AlterClientQuotasRequestEntity {
+  entityType: ClientQuotaEntityType;
+  entityName?: NullableString;
+}
+export interface AlterClientQuotaRequestOpAddition {
+  key: ClientQuotaKey;
+  value: number;
+  remove: false;
+}
+export interface AlterClientQuotaRequestOpRemoval {
+  key: ClientQuotaKey;
+  remove: true;
+}
+export type AlterClientQuotasRequestOp = AlterClientQuotaRequestOpAddition | AlterClientQuotaRequestOpRemoval;
+export interface AlterClientQuotasRequestEntry {
+  entities: AlterClientQuotasRequestEntity[];
+  ops: AlterClientQuotasRequestOp[];
+}
+export type AlterClientQuotasRequest = Parameters<typeof createRequest>;
+export interface AlterClientQuotasResponseEntity {
+  entityType: ClientQuotaEntityType;
+  entityName: NullableString;
+}
+export interface AlterClientQuotasResponseEntries {
+  errorCode: number;
+  errorMessage: NullableString;
+  entity: AlterClientQuotasResponseEntity[];
+}
+export interface AlterClientQuotasResponse {
+  throttleTimeMs: number;
+  entries: AlterClientQuotasResponseEntries[];
+}
+export declare function createRequest(entries: AlterClientQuotasRequestEntry[], validateOnly: boolean): Writer;
+export declare function parseResponse(_correlationId: number, apiKey: number, apiVersion: number, reader: Reader): AlterClientQuotasResponse;
+export declare const api: import("../definitions").API<[entries: AlterClientQuotasRequestEntry[], validateOnly: boolean], AlterClientQuotasResponse>;

package/dist/typescript-4/dist/apis/admin/alter-client-quotas-v1.d.ts

@@ -1,18 +1,19 @@
 import { type NullableString } from "../../protocol/definitions";
 import { type Reader } from "../../protocol/reader";
 import { Writer } from "../../protocol/writer";
-import { type ClientQuotaEntityTypeValue, type ClientQuotaKeyValue } from "../enumerations";
+import type { ClientQuotaEntityType, ClientQuotaKey } from "../enumerations";
+export type { ClientQuotaEntityType, ClientQuotaKey } from "../enumerations";
 export interface AlterClientQuotasRequestEntity {
-  entityType: ClientQuotaEntityTypeValue;
+  entityType: ClientQuotaEntityType;
   entityName?: NullableString;
 }
 export interface AlterClientQuotaRequestOpAddition {
-  key: ClientQuotaKeyValue;
+  key: ClientQuotaKey;
   value: number;
   remove: false;
 }
 export interface AlterClientQuotaRequestOpRemoval {
-  key: ClientQuotaKeyValue;
+  key: ClientQuotaKey;
   remove: true;
 }
 export type AlterClientQuotasRequestOp = AlterClientQuotaRequestOpAddition | AlterClientQuotaRequestOpRemoval;
@@ -22,7 +23,7 @@ export interface AlterClientQuotasRequestEntry {
 }
 export type AlterClientQuotasRequest = Parameters<typeof createRequest>;
 export interface AlterClientQuotasResponseEntity {
-  entityType: string;
+  entityType: ClientQuotaEntityType;
   entityName: NullableString;
 }
 export interface AlterClientQuotasResponseEntries {