@platformatic/kafka 2.10.0-alpha.1 → 2.11.0

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

@@ -5,7 +5,7 @@ import { consumerReceivesChannel, createDiagnosticContext, notifyCreation } from
 import { findErrorBy, protocolErrors, UserError } from "../../errors.js";
 import { IS_CONTROL } from "../../protocol/records.js";
 import { runAsyncSeries } from "../../registries/abstract.js";
-import { kAutocommit, kGetFetchNode, kInstance, kRefreshOffsetsAndFetch } from "../../symbols.js";
+import { kAutocommit, kDeserializationError, kGetFetchNode, kInstance, kRefreshOffsetsAndFetch } from "../../symbols.js";
 import { kConnections, kCreateConnectionPool, kInspect, kPrometheus } from "../base/base.js";
 import { ensureMetric } from "../metrics.js";
 import { defaultConsumerOptions } from "./options.js";
@@ -24,11 +24,12 @@ function messageToJSON() {
     return {
         key: this.key,
         value: this.value,
-        headers: Array.from(this.headers.entries()),
+        headers: this.headerEntries.map(([key, value]) => [key, value]),
         topic: this.topic,
         partition: this.partition,
         timestamp: this.timestamp.toString(),
         offset: this.offset.toString(),
+        leaderEpoch: this.leaderEpoch,
         metadata: this.metadata
     };
 }
@@ -309,7 +310,12 @@ export class MessagesStream extends Readable {
     _construct(callback) {
         this.#refreshOffsetsInflight = true;
         this.#refreshOffsets(error => {
+            const wasPending = this.#refreshOffsetsPending;
             this.#refreshOffsetsInflight = false;
+            this.#refreshOffsetsPending = false;
+            if (!error && wasPending) {
+                this.#scheduleRefreshOffsetsAndFetch();
+            }
             callback(error ?? undefined);
         });
     }
@@ -610,11 +616,20 @@ export class MessagesStream extends Readable {
                             : this.#commit.bind(this, topic, partition, offset + 1n, leaderEpoch);
                         try {
                             const headers = new Map();
+                            const headerEntries = [];
                             let payloadType = 'headerKey';
                             let deserializedKey;
                             let deserializedValue;
                             let deserializationError;
+                            let hookFailed = false;
                             try {
+                                // A before-deserialization hook already failed for this message, report it as is
+                                const hookError = messageToConsume[kDeserializationError];
+                                if (hookError) {
+                                    hookFailed = true;
+                                    payloadType = hookError.payloadType;
+                                    throw hookError.error;
+                                }
                                 for (const [headerKey, headerValue] of record.headers) {
                                     payloadType = 'headerKey';
                                     /* c8 ignore next - Hard to test */
@@ -623,6 +638,7 @@ export class MessagesStream extends Readable {
                                     /* c8 ignore next - Hard to test */
                                     const deserializedHeaderValue = headerValueDeserializer(headerValue ?? undefined, messageToConsume);
                                     headers.set(deserializedHeaderKey, deserializedHeaderValue);
+                                    headerEntries.push([deserializedHeaderKey, deserializedHeaderValue]);
                                 }
                                 payloadType = 'key';
                                 /* c8 ignore next - Hard to test */
@@ -659,11 +675,14 @@ export class MessagesStream extends Readable {
                                     */
                                     diagnosticContext.error = error;
                                     consumerReceivesChannel.error.publish(diagnosticContext);
-                                    const headersFailed = payloadType === 'headerKey' || payloadType === 'headerValue';
+                                    // A hook failure happens before anything is deserialized, so nothing can be kept
+                                    const headersFailed = hookFailed || payloadType === 'headerKey' || payloadType === 'headerValue';
                                     if (headersFailed) {
                                         headers.clear();
+                                        headerEntries.length = 0;
                                         for (const [headerKey, headerValue] of record.headers) {
                                             headers.set(headerKey, headerValue);
+                                            headerEntries.push([headerKey, headerValue]);
                                         }
                                     }
                                     if (headersFailed || payloadType === 'key') {
@@ -678,7 +697,7 @@ export class MessagesStream extends Readable {
                                 else {
                                     diagnosticContext.error = error;
                                     consumerReceivesChannel.error.publish(diagnosticContext);
-                                    this.destroy(new UserError('Failed to deserialize a message.', { cause: error }));
+                                    this.destroy(hookFailed ? error : new UserError('Failed to deserialize a message.', { cause: error }));
                                     return;
                                 }
                             }
@@ -687,10 +706,14 @@ export class MessagesStream extends Readable {
                                 key: deserializedKey,
                                 value: deserializedValue,
                                 headers,
+                                headerEntries,
                                 topic,
                                 partition,
                                 timestamp: firstTimestamp + record.timestampDelta,
                                 offset,
+                                // The batch header epoch is the epoch of the record itself, which is what
+                                // OffsetCommit expects as committedLeaderEpoch (KIP-320).
+                                leaderEpoch: batch.partitionLeaderEpoch,
                                 commit,
                                 // Deserializers and hooks can enrich the metadata of the message they processed
                                 metadata: deserializationError
@@ -773,6 +796,16 @@ export class MessagesStream extends Readable {
         if (this.#offsetsToCommit.size === 0) {
             return;
         }
+        // Skip this tick while the consumer is mid-(re)join: a commit attempted here would fail
+        // with a rejoin-required error (ILLEGAL_GENERATION/UNKNOWN_MEMBER_ID/REBALANCE_IN_PROGRESS),
+        // and — since this runs on its own timer, independently of the group's own rejoin flow —
+        // each such failure calls joinGroup again. With a short autocommit interval and many
+        // consumers in the group, this can fire fresh JoinGroups fast enough that the group never
+        // completes a rebalance round. Leave the offsets queued; they are committed once the
+        // consumer becomes active again (next tick, or the final flush on close/destroy).
+        if (!this.#consumer.isActive()) {
+            return;
+        }
         this.#autocommitInflight = true;
         const offsets = Array.from(this.#offsetsToCommit.values());
         this.#offsetsToCommit.clear();
@@ -831,7 +864,10 @@ export class MessagesStream extends Readable {
                 topics.push(assignment);
             }
             if (!topics.length) {
-                this.#assignOffsets(offsets, new Map(), callback);
+                // No assignment yet: do not seed fallback offsets for the whole topic.
+                // consumer:group:join will refresh once partitions are assigned.
+                this.emit('offsets');
+                callback(null);
                 return;
             }
             this.#consumer.listCommittedOffsets({ topics }, (error, commits) => {
@@ -858,6 +894,7 @@ export class MessagesStream extends Readable {
         this.#refreshOffsetsInflight = true;
         this.#refreshOffsets(error => {
             const shouldDestroyOnError = this.#refreshOffsetsDestroyOnError;
+            const wasPending = this.#refreshOffsetsPending;
             this.#refreshOffsetsInflight = false;
             this.#refreshOffsetsDestroyOnError = false;
             this.#refreshOffsetsPending = false;
@@ -869,8 +906,7 @@ export class MessagesStream extends Readable {
                 return;
             }
             // A new one was scheduled while the previous one was inflight, we need to run it immediately
-            /* c8 ignore next 4 - Hard to test */
-            if (this.#refreshOffsetsPending) {
+            if (wasPending) {
                 this.#scheduleRefreshOffsetsAndFetch(shouldDestroyOnError);
                 return;
             }
@@ -972,9 +1008,23 @@ export class MessagesStream extends Readable {
         }
         runAsyncSeries((request, cb) => {
             const [data, type, message] = request;
-            const result = hook(data, type, message, cb);
+            /*
+              Without an error handler a failing hook destroys the stream, as it always did. With one,
+              the failure is recorded on the message it belongs to and reported to the handler in
+              #pushRecords, together with everything else which can fail while deserializing, so that
+              the caller can skip or degrade that single message instead of losing the stream.
+            */
+            const onHookSettled = error => {
+                if (error && this.#deserializationErrorHandler) {
+                    message[kDeserializationError] ??= { error, payloadType: type };
+                    cb(null);
+                    return;
+                }
+                cb(error);
+            };
+            const result = hook(data, type, message, onHookSettled);
             if (typeof result?.then === 'function') {
-                result.then(() => cb(null), cb);
+                result.then(() => onHookSettled(null), onHookSettled);
             }
         }, requests, 0, error => {
             if (error) {

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

@@ -15,6 +15,10 @@ export declare const groupOptionsProperties: {
         type: string;
         minimum: number;
     };
+    heartbeatStallTimeout: {
+        type: string;
+        minimum: number;
+    };
     groupProtocol: {
         type: string;
         enum: ("consumer" | "classic")[];
@@ -160,6 +164,10 @@ export declare const groupOptionsSchema: {
             type: string;
             minimum: number;
         };
+        heartbeatStallTimeout: {
+            type: string;
+            minimum: number;
+        };
         groupProtocol: {
             type: string;
             enum: ("consumer" | "classic")[];
@@ -283,6 +291,10 @@ export declare const consumeOptionsSchema: {
             type: string;
             minimum: number;
         };
+        heartbeatStallTimeout: {
+            type: string;
+            minimum: number;
+        };
         groupProtocol: {
             type: string;
             enum: ("consumer" | "classic")[];
@@ -455,6 +467,10 @@ export declare const consumerOptionsSchema: {
             type: string;
             minimum: number;
         };
+        heartbeatStallTimeout: {
+            type: string;
+            minimum: number;
+        };
         groupProtocol: {
             type: string;
             enum: ("consumer" | "classic")[];
@@ -585,6 +601,10 @@ export declare const fetchOptionsSchema: {
             type: string;
             minimum: number;
         };
+        heartbeatStallTimeout: {
+            type: string;
+            minimum: number;
+        };
         groupProtocol: {
             type: string;
             enum: ("consumer" | "classic")[];

package/dist/clients/consumer/options.js

@@ -8,6 +8,7 @@ export const groupOptionsProperties = {
     sessionTimeout: { type: 'number', minimum: 0 },
     rebalanceTimeout: { type: 'number', minimum: 0 },
     heartbeatInterval: { type: 'number', minimum: 0 },
+    heartbeatStallTimeout: { type: 'number', minimum: 0 },
     groupProtocol: { type: 'string', enum: allowedGroupProtocols },
     groupRemoteAssignor: { type: 'string' },
     protocols: {

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

@@ -82,6 +82,7 @@ export interface GroupOptions {
     sessionTimeout?: number;
     rebalanceTimeout?: number;
     heartbeatInterval?: number;
+    heartbeatStallTimeout?: number;
     protocols?: GroupProtocolSubscription[];
     protocolsMetadata?: GroupProtocolsMetadataCallback;
     partitionAssigner?: GroupPartitionsAssigner;
@@ -92,6 +93,7 @@ export interface ConsumerGroupOptions {
     groupInstanceId?: string;
     groupRemoteAssignor?: string;
     rebalanceTimeout?: number;
+    heartbeatStallTimeout?: number;
     assignmentUserData?: Buffer;
 }
 export interface ConsumeBaseOptions<Key, Value, HeaderKey, HeaderValue> {
@@ -169,3 +171,8 @@ export interface ConsumerHeartbeatPayload {
 export interface ConsumerHeartbeatErrorPayload extends ConsumerHeartbeatPayload {
     error: Error;
 }
+export interface ConsumerHeartbeatStalledPayload {
+    lastError?: Error;
+    lastHeartbeat: Date | null;
+    stalledFor: number;
+}

package/dist/clients/producer/producer.js

@@ -2,7 +2,7 @@ import { randomUUID } from 'crypto';
 import { createPromisifiedCallback, kCallbackPromise, runConcurrentCallbacks } from "../../apis/callbacks.js";
 import { FindCoordinatorKeyTypes, ProduceAcks } from "../../apis/enumerations.js";
 import { createDiagnosticContext, producerInitIdempotentChannel, producerSendsChannel, producerTransactionsChannel } from "../../diagnostic.js";
-import { findErrorBy, UserError } from "../../errors.js";
+import { findErrorBy, NetworkError, UserError } from "../../errors.js";
 import { runAsyncSeries } from "../../registries/abstract.js";
 import { kInstance, kTransaction, kTransactionAddOffsets, kTransactionAddPartitions, kTransactionCancel, kTransactionCommitOffset, kTransactionEnd, kTransactionFindCoordinator, kTransactionPrepare } from "../../symbols.js";
 import { emitExperimentalApiWarning, NumericMap } from "../../utils.js";
@@ -749,65 +749,71 @@ export class Producer extends Base {
         });
     }
     #performSingleDestinationSend(topics, messages, timeout, acks, autocreateTopics, repeatOnStaleMetadata, produceOptions, recoverOnProducerStateLoss, callback) {
-        // Get the metadata with the topic/partitions informations
-        this[kMetadata]({ topics, autocreateTopics }, (error, metadata) => {
-            if (error) {
-                callback(error);
-                return;
-            }
-            const { topic, partition } = messages[0];
-            const leader = metadata.topics.get(topic).partitions[partition].leader;
-            this[kPerformWithRetry]('produce', retryCallback => {
+        const { topic, partition } = messages[0];
+        let refreshMetadata = false;
+        this[kPerformWithRetry]('produce', retryCallback => {
+            this[kMetadata]({ topics, autocreateTopics, forceUpdate: refreshMetadata }, (error, metadata) => {
+                if (error) {
+                    refreshMetadata = NetworkError.isRetryable(error);
+                    retryCallback(error);
+                    return;
+                }
+                refreshMetadata = false;
+                const leader = metadata.topics.get(topic).partitions[partition].leader;
                 this[kGetConnection](metadata.brokers.get(leader), (error, connection) => {
                     if (error) {
+                        refreshMetadata = NetworkError.isRetryable(error);
                         retryCallback(error);
                         return;
                     }
                     this[kGetApi]('Produce', (error, api) => {
                         if (error) {
+                            refreshMetadata = NetworkError.isRetryable(error);
                             retryCallback(error);
                             return;
                         }
-                        api(connection, acks, timeout, messages, produceOptions, retryCallback);
+                        api(connection, acks, timeout, messages, produceOptions, (error, response) => {
+                            refreshMetadata = NetworkError.isRetryable(error);
+                            retryCallback(error, response);
+                        });
                     });
                 });
-            }, (error, results) => {
-                if (error) {
-                    // If the last error was due to stale metadata, we retry the operation with this set of messages
-                    // since the partition is already set, it should attempt on the new destination
-                    /* c8 ignore next - Hard to test */
-                    const hasStaleMetadata = findErrorBy(error, 'hasStaleMetadata', true);
-                    if (hasStaleMetadata && repeatOnStaleMetadata) {
-                        this.clearMetadata();
-                        this.#performSingleDestinationSend(topics, messages, timeout, acks, autocreateTopics, false, produceOptions, recoverOnProducerStateLoss, callback);
-                        return;
-                    }
-                    if (recoverOnProducerStateLoss && !this.#transaction && this.#isProducerStateLost(error)) {
-                        this.#recoverIdempotentProducer(messages, produceOptions, (error, recoveredProduceOptions) => {
-                            if (error) {
-                                callback(error);
-                                return;
-                            }
-                            this.#performSingleDestinationSend(topics, messages, timeout, acks, autocreateTopics, repeatOnStaleMetadata, recoveredProduceOptions, false, callback);
-                        });
-                        return;
-                    }
-                    callback(error, results);
+            });
+        }, (error, results) => {
+            if (error) {
+                // If the last error was due to stale metadata, we retry the operation with this set of messages
+                // since the partition is already set, it should attempt on the new destination
+                /* c8 ignore next - Hard to test */
+                const hasStaleMetadata = findErrorBy(error, 'hasStaleMetadata', true);
+                if (hasStaleMetadata && repeatOnStaleMetadata) {
+                    this.clearMetadata();
+                    this.#performSingleDestinationSend(topics, messages, timeout, acks, autocreateTopics, false, produceOptions, recoverOnProducerStateLoss, callback);
                     return;
                 }
-                callback(error, results);
-            }, 0, [], error => {
-                /* c8 ignore next 3 - Hard to test */
-                if (!repeatOnStaleMetadata) {
-                    return false;
+                if (recoverOnProducerStateLoss && !this.#transaction && this.#isProducerStateLost(error)) {
+                    this.#recoverIdempotentProducer(messages, produceOptions, (error, recoveredProduceOptions) => {
+                        if (error) {
+                            callback(error);
+                            return;
+                        }
+                        this.#performSingleDestinationSend(topics, messages, timeout, acks, autocreateTopics, repeatOnStaleMetadata, recoveredProduceOptions, false, callback);
+                    });
+                    return;
                 }
-                return !!findErrorBy(error, 'hasStaleMetadata', true);
-            });
+                callback(error, results);
+                return;
+            }
+            callback(error, results);
+        }, 0, [], error => {
+            /* c8 ignore next 3 - Hard to test */
+            if (!repeatOnStaleMetadata) {
+                return false;
+            }
+            return !!findErrorBy(error, 'hasStaleMetadata', true);
         });
     }
     #isProducerStateLost(error) {
-        return !!(findErrorBy(error, 'apiId', 'UNKNOWN_PRODUCER_ID') ||
-            findErrorBy(error, 'apiId', 'OUT_OF_ORDER_SEQUENCE_NUMBER'));
+        return !!(findErrorBy(error, 'apiId', 'UNKNOWN_PRODUCER_ID') || findErrorBy(error, 'apiId', 'OUT_OF_ORDER_SEQUENCE_NUMBER'));
     }
     #recoverIdempotentProducer(messages, produceOptions, callback) {
         this.#producerInfo = undefined;

package/dist/errors.d.ts

@@ -36,6 +36,7 @@ export declare class AuthenticationError extends GenericError {
 }
 export declare class NetworkError extends GenericError {
     static code: ErrorCode;
+    static isRetryable(error: Error | null | undefined): boolean;
     constructor(message: string, properties?: ErrorProperties);
 }
 export declare class ProtocolError extends GenericError {

package/dist/errors.js

@@ -119,6 +119,10 @@ export class AuthenticationError extends GenericError {
 }
 export class NetworkError extends GenericError {
     static code = 'PLT_KFK_NETWORK';
+    static isRetryable(error) {
+        const networkError = findErrorBy(error, 'code', NetworkError.code);
+        return networkError?.canRetry === true;
+    }
     constructor(message, properties = {}) {
         super(NetworkError.code, message, { canRetry: true, ...properties });
     }

package/dist/network/utils.js

@@ -1,12 +1,30 @@
+const BRACKETED_BROKER_RE = /^\[([^\]]+)](?::(\d*))?$/;
 export function parseBroker(broker, defaultPort = 9092) {
-    if (typeof broker === 'string') {
-        if (broker.includes(':')) {
-            const [host, port] = broker.split(':');
-            return { host, port: Number(port) };
-        }
-        else {
-            return { host: broker, port: defaultPort };
+    if (typeof broker !== 'string') {
+        const host = stripBrackets(broker.host);
+        if (host === broker.host) {
+            return broker;
         }
+        return { ...broker, host };
+    }
+    const bracketed = BRACKETED_BROKER_RE.exec(broker);
+    if (bracketed) {
+        return { host: bracketed[1], port: parsePort(bracketed[2], defaultPort) };
+    }
+    const separator = broker.lastIndexOf(':');
+    // Bare IPv6 addresses contain multiple colons and no port. The host:port form
+    // is unambiguous only with a single colon, or with brackets around the host.
+    if (separator === -1 || broker.indexOf(':') !== separator) {
+        return { host: broker, port: defaultPort };
+    }
+    return { host: broker.slice(0, separator), port: parsePort(broker.slice(separator + 1), defaultPort) };
+}
+function parsePort(port, defaultPort) {
+    return port === undefined || port.length === 0 ? defaultPort : Number(port);
+}
+function stripBrackets(host) {
+    if (host.startsWith('[') && host.endsWith(']')) {
+        return host.slice(1, -1);
     }
-    return broker;
+    return host;
 }

package/dist/protocol/records.d.ts

@@ -33,11 +33,14 @@ export interface MessageJSON<Key = unknown, Value = unknown, HeaderKey = unknown
     partition: number;
     timestamp: string;
     offset: string;
+    leaderEpoch: number;
     metadata: Record<string, unknown>;
 }
 export interface Message<Key = Buffer, Value = Buffer, HeaderKey = Buffer, HeaderValue = Buffer> extends Required<MessageBase<Key, Value>> {
     headers: Map<HeaderKey, HeaderValue>;
+    headerEntries: Array<[HeaderKey, HeaderValue]>;
     offset: bigint;
+    leaderEpoch: number;
     metadata: Record<string, unknown>;
     commit(callback?: (error?: Error) => void): void | Promise<void>;
     toJSON(): MessageJSON<Key, Value, HeaderKey, HeaderValue>;

package/dist/registries/abstract.js

@@ -1,19 +1,38 @@
 export function runAsyncSeries(operation, collection, index, callback) {
-    if (collection.length === 0 || index >= collection.length) {
+    const length = collection.length;
+    if (length === 0 || index >= length) {
         callback(null);
         return;
     }
-    operation(collection[index], error => {
-        if (error) {
-            callback(error);
+    while (index < length) {
+        let invocationReturned = false;
+        let cbCalled = false;
+        let cbError;
+        operation(collection[index], error => {
+            if (invocationReturned) {
+                // The callback was invoked asynchronously, so continuing recursively does not grow the current stack.
+                if (error) {
+                    callback(error);
+                    return;
+                }
+                runAsyncSeries(operation, collection, index + 1, callback);
+                return;
+            }
+            cbCalled = true;
+            cbError = error;
+        });
+        invocationReturned = true;
+        if (!cbCalled) {
+            // Wait for the async callback to continue the series.
             return;
         }
-        else if (index === collection.length - 1) {
-            callback(null);
+        if (cbError) {
+            callback(cbError);
             return;
         }
-        runAsyncSeries(operation, collection, index + 1, callback);
-    });
+        index++;
+    }
+    callback(null);
 }
 /* c8 ignore start */
 export class AbstractSchemaRegistry {

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

@@ -1,3 +1,5 @@
+import * as AjvDraft04Module from 'ajv-draft-04';
+import draft06MetaSchema from 'ajv/dist/refs/json-schema-draft-06.json' with { type: 'json' };
 import { Ajv } from 'ajv';
 import { Ajv2020 } from 'ajv/dist/2020.js';
 import avro from 'avsc';
@@ -8,8 +10,7 @@ import { EMPTY_BUFFER, MultipleErrors, NetworkError, TimeoutError, UnsupportedFo
 import { getCredential } from "../protocol/sasl/utils.js";
 import { AbstractSchemaRegistry } from "./abstract.js";
 const require = createRequire(import.meta.url);
-const AjvDraft04 = require('ajv-draft-04');
-const draft06MetaSchema = require('ajv/dist/refs/json-schema-draft-06.json');
+const AjvDraft04 = AjvDraft04Module.default;
 const undiciGlobalDispatcherSymbol = /^undici\.globalDispatcher\.(\d+)$/;
 export function createUndiciAgent(options) {
     /*

package/dist/symbols.d.ts

@@ -2,6 +2,7 @@ export declare const kInstance: unique symbol;
 export declare const kRefreshOffsetsAndFetch: unique symbol;
 export declare const kAutocommit: unique symbol;
 export declare const kGetFetchNode: unique symbol;
+export declare const kDeserializationError: unique symbol;
 export declare const kTransaction: unique symbol;
 export declare const kTransactionPrepare: unique symbol;
 export declare const kTransactionAddPartitions: unique symbol;

package/dist/symbols.js

@@ -3,6 +3,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 kGetFetchNode = Symbol('plt.kafka.consumer.getFetchNode');
+export const kDeserializationError = Symbol('plt.kafka.messagesStream.deserializationError');
 export const kTransaction = Symbol('plt.kafka.producer.transactions');
 export const kTransactionPrepare = Symbol('plt.kafka.producer.transactions.prepare');
 export const kTransactionAddPartitions = Symbol('plt.kafka.producer.transactions.addPartitions');

package/dist/typescript-4/dist/clients/admin/options.d.ts

@@ -14,8 +14,48 @@ export declare const createTopicOptionsSchema: {
     topics: {
       type: string;
       items: {
-        type: string;
-        pattern: string;
+        oneOf: ({
+          type: string;
+          pattern: string;
+        } | {
+          type: string;
+          properties: {
+            topic: {
+              type: string;
+              pattern: string;
+            };
+            partitions: {
+              type: string;
+            };
+            replicas: {
+              type: string;
+            };
+            assignments: {
+              type: string;
+              items: {
+                type: string;
+                properties: {
+                  partition: {
+                    type: string;
+                    minimum: number;
+                  };
+                  brokers: {
+                    type: string;
+                    items: {
+                      type: string;
+                    };
+                    minItems: number;
+                  };
+                };
+                required: string[];
+                additionalProperties: boolean;
+              };
+              minItems: number;
+            };
+          };
+          required: string[];
+          additionalProperties: boolean;
+        })[];
       };
     };
     partitions: {
@@ -46,6 +86,22 @@ export declare const createTopicOptionsSchema: {
       };
       minItems: number;
     };
+    configs: {
+      type: string;
+      items: {
+        type: string;
+        properties: {
+          name: {
+            type: string;
+          };
+          value: {
+            type: string[];
+          };
+        };
+        required: string[];
+        additionalProperties: boolean;
+      };
+    };
   };
   required: string[];
   additionalProperties: boolean;

package/dist/typescript-4/dist/clients/admin/types.d.ts

@@ -42,8 +42,14 @@ export interface Group extends Omit<GroupBase, 'groupType'> {
   authorizedOperations: number;
 }
 export interface AdminOptions extends BaseOptions {}
+export interface CreateTopicsTopicOptions {
+  topic: string;
+  partitions?: number;
+  replicas?: number;
+  assignments?: BrokerAssignment[];
+}
 export interface CreateTopicsOptions {
-  topics: string[];
+  topics: (string | CreateTopicsTopicOptions)[];
   partitions?: number;
   replicas?: number;
   assignments?: BrokerAssignment[];

package/dist/typescript-4/dist/clients/consumer/consumer.d.ts

@@ -6,7 +6,7 @@ import { Base, type BaseEvents, kCreateConnectionPool } from "../base/base";
 import { type ClusterMetadata } from "../base/types";
 import { MessagesStream } from "./messages-stream";
 import { TopicsMap } from "./topics-map";
-import { type CommitOptions, type ConsumeOptions, type ConsumerGroupJoinPayload, type ConsumerGroupLeavePayload, type ConsumerGroupRebalancePayload, type ConsumerHeartbeatErrorPayload, type ConsumerHeartbeatPayload, type ConsumerOptions, type FetchOptions, type GetLagOptions, type GroupAssignment, type GroupOptions, type ListCommitsOptions, type ListOffsetsOptions, type Offsets, type OffsetsWithTimestamps } from "./types";
+import { type CommitOptions, type ConsumeOptions, type ConsumerGroupJoinPayload, type ConsumerGroupLeavePayload, type ConsumerGroupRebalancePayload, type ConsumerHeartbeatErrorPayload, type ConsumerHeartbeatPayload, type ConsumerHeartbeatStalledPayload, type ConsumerOptions, type FetchOptions, type GetLagOptions, type GroupAssignment, type GroupOptions, type ListCommitsOptions, type ListOffsetsOptions, type Offsets, type OffsetsWithTimestamps } from "./types";
 export interface ConsumerEvents extends BaseEvents {
   'consumer:group:join': (payload: ConsumerGroupJoinPayload) => void;
   'consumer:group:leave': (payload: ConsumerGroupLeavePayload) => void;
@@ -16,6 +16,7 @@ export interface ConsumerEvents extends BaseEvents {
   'consumer:heartbeat:cancel': (payload: ConsumerHeartbeatPayload) => void;
   'consumer:heartbeat:end': (payload?: ConsumerHeartbeatPayload) => void;
   'consumer:heartbeat:error': (payload: ConsumerHeartbeatErrorPayload) => void;
+  'consumer:heartbeat:stalled': (payload: ConsumerHeartbeatStalledPayload) => void;
   'consumer:lag': (lag: Offsets) => void;
   'consumer:lag:error': (error: Error) => void;
 }