@platformatic/kafka 2.0.1 → 2.2.0

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

@@ -1,32 +1,124 @@
+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';
 import { createRequire } from 'node:module';
+import { setTimeout as sleep } from 'node:timers/promises';
 import { jsonDeserializer, jsonSerializer, stringDeserializer, stringSerializer } from "../clients/serde.js";
-import { ajv, EMPTY_BUFFER, UnsupportedFormatError, UserError } from "../index.js";
+import { EMPTY_BUFFER, MultipleErrors, NetworkError, TimeoutError, UnsupportedFormatError, UserError } from "../index.js";
 import { getCredential } from "../protocol/sasl/utils.js";
 import { AbstractSchemaRegistry } from "./abstract.js";
 const require = createRequire(import.meta.url);
+const AjvDraft04 = AjvDraft04Module.default;
+const undiciGlobalDispatcherSymbol = /^undici\.globalDispatcher\.(\d+)$/;
+export function createUndiciAgent(options) {
+    /*
+      The undici globals are installed the first time undici is loaded, which creating a Request is
+      enough to do and which performs no I/O.
+    */
+    new Request('http://localhost'); // eslint-disable-line no-new
+    /*
+      The symbol is versioned and more than one version is registered at the same time, pointing at
+      different objects: on Node 26 undici.globalDispatcher.1 is a backwards compatibility wrapper and
+      only undici.globalDispatcher.2 is the Agent. The highest version available therefore wins.
+    */
+    const globals = globalThis;
+    let version = -1;
+    let Agent;
+    for (const symbol of Object.getOwnPropertySymbols(globalThis)) {
+        const symbolVersion = symbol.description?.match(undiciGlobalDispatcherSymbol)?.[1];
+        if (typeof symbolVersion === 'undefined' || Number(symbolVersion) <= version) {
+            continue;
+        }
+        version = Number(symbolVersion);
+        Agent = globals[symbol]?.constructor;
+    }
+    /* c8 ignore next 6 - Only reachable on a Node.js build which does not bundle undici */
+    if (typeof Agent !== 'function') {
+        throw new UserError('Cannot access the undici Agent bundled with Node.js, which is required to configure TLS for the Schema Registry.');
+    }
+    return new Agent(options);
+}
+export const defaultConfluentSchemaRegistryOptions = {
+    timeout: 5000,
+    retries: 3,
+    retryDelay: 1000
+};
+// Statuses which are worth retrying: the registry is overloaded, restarting or behind a proxy which is
+export const retriableSchemaRegistryStatuses = [408, 425, 429, 500, 502, 503, 504];
+export class SchemaValidationError extends UserError {
+    constructor(message, properties) {
+        super(message, properties);
+        this.name = 'SchemaValidationError';
+    }
+}
+export function trackConsumedSchemaId(message, type, schemaId) {
+    /* c8 ignore next 3 - The message is always provided for keys and values */
+    if (!message) {
+        return;
+    }
+    const metadata = (message.metadata ??= {});
+    metadata.schemas ??= {};
+    metadata.schemas[type] = schemaId;
+}
+export function trackConsumedPayloadLength(message, type, data) {
+    /* c8 ignore next 3 - The message is always provided for keys and values */
+    if (!message) {
+        return;
+    }
+    const metadata = (message.metadata ??= {});
+    metadata.lengths ??= {};
+    metadata.lengths[type] = data.length;
+}
 /* c8 ignore next 8 */
 export function defaultProtobufTypeMapper(_, type, context) {
     // Confluent Schema Registry convention
     return `${context.topic}-${type}`;
 }
-// TODO(ShogunPanda): Authentication support
 export class ConfluentSchemaRegistry extends AbstractSchemaRegistry {
     #url;
     #schemas;
     #protobufParse;
     #protobufTypeMapper;
     #jsonValidateSend;
+    #jsonAjv;
+    #jsonAjvDraft7;
+    #jsonAjvDraft04;
+    #pendingFetches;
     #auth;
+    #headers;
+    #timeout;
+    #retries;
+    #retryDelay;
+    #tls;
+    #tlsDispatcher;
     constructor(options) {
         super();
         this.#url = options.url;
         this.#schemas = new Map();
         this.#protobufTypeMapper = options.protobufTypeMapper ?? defaultProtobufTypeMapper;
         this.#jsonValidateSend = options.jsonValidateSend ?? false;
+        const jsonAjvOptions = { allErrors: true, coerceTypes: false, strict: true, ...options.jsonAjvOptions };
+        this.#jsonAjv = new Ajv2020(jsonAjvOptions);
+        this.#jsonAjvDraft7 = new Ajv(jsonAjvOptions);
+        this.#jsonAjvDraft7.addMetaSchema(draft06MetaSchema);
+        this.#jsonAjvDraft04 = new AjvDraft04(jsonAjvOptions);
         this.#auth = options.auth;
+        this.#headers = options.headers;
+        this.#timeout = options.timeout ?? defaultConfluentSchemaRegistryOptions.timeout;
+        this.#retries = options.retries ?? defaultConfluentSchemaRegistryOptions.retries;
+        this.#retryDelay = options.retryDelay ?? defaultConfluentSchemaRegistryOptions.retryDelay;
+        this.#tls = options.tls ?? options.ssl;
+        this.#pendingFetches = new Map();
+        if (this.#tls && new URL(this.#url).protocol !== 'https:') {
+            throw new UserError('TLS options can only be used with a HTTPS Schema Registry URL.', { url: this.#url });
+        }
     }
     getSchemaId(message, type) {
+        if (message === null) {
+            return undefined;
+        }
         if (Buffer.isBuffer(message)) {
             if (type !== 'value') {
                 return undefined;
@@ -39,41 +131,15 @@ export class ConfluentSchemaRegistry extends AbstractSchemaRegistry {
         return this.#schemas.get(id);
     }
     async fetchSchema(id, callback) {
+        let fetch = this.#pendingFetches.get(id);
+        if (!fetch) {
+            fetch = this.#fetchSchema(id).finally(() => {
+                this.#pendingFetches.delete(id);
+            });
+            this.#pendingFetches.set(id, fetch);
+        }
         try {
-            const requestInit = {};
-            if (this.#auth) {
-                if (this.#auth.token) {
-                    const token = await getCredential('token', this.#auth.token);
-                    requestInit.headers = {
-                        Authorization: `Bearer ${token}`
-                    };
-                }
-                else {
-                    const username = await getCredential('username', this.#auth.username);
-                    const password = await getCredential('password', this.#auth.password);
-                    requestInit.headers = {
-                        Authorization: `Basic ${Buffer.from(`${username}:${password}`).toString('base64')}`
-                    };
-                }
-            }
-            const response = await fetch(`${this.#url}/schemas/ids/${id}`, requestInit);
-            if (!response.ok) {
-                throw new UserError(`Failed to fetch a schema: [HTTP ${response.status}]`, { response: await response.text() });
-            }
-            const responseBody = await response.json();
-            const { schema, schemaType } = responseBody;
-            switch (schemaType) {
-                case 'AVRO':
-                    this.#schemas.set(id, { id, type: 'avro', schema: avro.Type.forSchema(JSON.parse(schema)) });
-                    break;
-                case 'PROTOBUF':
-                    this.#protobufParse ??= this.#loadProtobuf();
-                    this.#schemas.set(id, { id, type: 'protobuf', schema: this.#protobufParse(schema).root });
-                    break;
-                case 'JSON':
-                    this.#schemas.set(id, { id, type: 'json', schema: ajv.compile(JSON.parse(schema)) });
-                    break;
-            }
+            await fetch;
             process.nextTick(callback);
         }
         catch (err) {
@@ -116,7 +182,7 @@ export class ConfluentSchemaRegistry extends AbstractSchemaRegistry {
     }
     getBeforeDeserializationHook() {
         const registry = this;
-        return function beforeDeserialization(payload, type, _message, callback) {
+        return function beforeDeserialization(payload, type, message, callback) {
             // Extract the schema ID from the message metadata
             const schemaId = registry.getSchemaId(payload, type);
             // When no schema ID is found, nothing to do
@@ -124,6 +190,11 @@ export class ConfluentSchemaRegistry extends AbstractSchemaRegistry {
                 callback(null);
                 return;
             }
+            /*
+              Track the schema ID before fetching, so that it is exposed on the message metadata even when
+              the schema cannot be fetched or the payload cannot be decoded.
+            */
+            trackConsumedSchemaId(message, type, schemaId);
             // The schema is already fetch
             if (registry.get(schemaId)) {
                 callback(null);
@@ -132,6 +203,115 @@ export class ConfluentSchemaRegistry extends AbstractSchemaRegistry {
             registry.fetchSchema(schemaId, callback);
         };
     }
+    async #requestHeaders() {
+        let headers;
+        if (this.#headers) {
+            headers = { ...(typeof this.#headers === 'function' ? await this.#headers() : this.#headers) };
+        }
+        // Authentication headers are applied last so that auth options always win over custom headers
+        if (this.#auth) {
+            headers ??= {};
+            if (this.#auth.token) {
+                const token = await getCredential('token', this.#auth.token);
+                headers.Authorization = `Bearer ${token}`;
+            }
+            else {
+                const username = await getCredential('username', this.#auth.username);
+                const password = await getCredential('password', this.#auth.password);
+                headers.Authorization = `Basic ${Buffer.from(`${username}:${password}`).toString('base64')}`;
+            }
+        }
+        return headers;
+    }
+    async #requestSchema(id) {
+        const requestInit = {};
+        const headers = await this.#requestHeaders();
+        if (headers) {
+            requestInit.headers = headers;
+        }
+        if (this.#tls) {
+            // Created once per registry, so that connections are pooled across schema fetches
+            this.#tlsDispatcher ??= createUndiciAgent({ connect: this.#tls });
+            requestInit.dispatcher = this.#tlsDispatcher;
+        }
+        if (this.#timeout > 0) {
+            requestInit.signal = AbortSignal.timeout(this.#timeout);
+        }
+        let response;
+        try {
+            response = await fetch(`${this.#url}/schemas/ids/${id}`, requestInit);
+        }
+        catch (error) {
+            if (error.name === 'TimeoutError') {
+                throw new TimeoutError(`Fetching a schema timed out after ${this.#timeout} ms.`, {
+                    canRetry: true,
+                    cause: error
+                });
+            }
+            throw new NetworkError('Failed to fetch a schema.', { cause: error });
+        }
+        if (!response.ok) {
+            throw new UserError(`Failed to fetch a schema: [HTTP ${response.status}]`, {
+                response: await response.text(),
+                canRetry: retriableSchemaRegistryStatuses.includes(response.status)
+            });
+        }
+        return (await response.json());
+    }
+    async #requestSchemaWithRetries(id) {
+        const errors = [];
+        for (let attempt = 0;; attempt++) {
+            try {
+                return await this.#requestSchema(id);
+            }
+            catch (error) {
+                errors.push(error);
+                if (attempt >= this.#retries || error.canRetry !== true) {
+                    if (errors.length === 1) {
+                        throw errors[0];
+                    }
+                    throw new MultipleErrors(`Failed to fetch a schema after ${errors.length} attempts.`, errors);
+                }
+                const delay = typeof this.#retryDelay === 'function'
+                    ? this.#retryDelay(attempt + 1, this.#retries, error)
+                    : this.#retryDelay;
+                if (delay > 0) {
+                    await sleep(delay);
+                }
+            }
+        }
+    }
+    async #fetchSchema(id) {
+        const responseBody = await this.#requestSchemaWithRetries(id);
+        const { schema } = responseBody;
+        const schemaType = responseBody.schemaType ?? 'AVRO';
+        switch (schemaType) {
+            case 'AVRO':
+                this.#schemas.set(id, { id, type: 'avro', schema: avro.Type.forSchema(JSON.parse(schema)) });
+                break;
+            case 'PROTOBUF':
+                this.#protobufParse ??= this.#loadProtobuf();
+                this.#schemas.set(id, { id, type: 'protobuf', schema: this.#protobufParse(schema).root });
+                break;
+            case 'JSON': {
+                const jsonSchema = JSON.parse(schema);
+                this.#schemas.set(id, { id, type: 'json', schema: this.#getJsonAjv(jsonSchema).compile(jsonSchema) });
+                break;
+            }
+        }
+    }
+    #getJsonAjv(schema) {
+        if (typeof schema !== 'object' || schema === null || typeof schema.$schema !== 'string') {
+            return this.#jsonAjv;
+        }
+        if (schema.$schema.includes('draft-04')) {
+            return this.#jsonAjvDraft04;
+        }
+        if (schema.$schema.includes('draft-06') || schema.$schema.includes('draft-07')) {
+            return this.#jsonAjvDraft7;
+        }
+        return this.#jsonAjv;
+    }
     #schemaSerializer(type, fallbackSerializer, data, headers, message) {
         /* c8 ignore next 3 - Hard to test */
         if (typeof data === 'undefined') {
@@ -165,7 +345,16 @@ export class ConfluentSchemaRegistry extends AbstractSchemaRegistry {
                     const validate = schema.schema;
                     const valid = validate(data);
                     if (!valid) {
-                        throw new UserError(`JSON Schema validation failed before serialization: ${ajv.errorsText(validate.errors)}`, { type, data, headers, validationErrors: validate.errors });
+                        throw new SchemaValidationError(`JSON Schema validation failed before serialization: ${this.#jsonAjv.errorsText(validate.errors)}`, {
+                            schemaId,
+                            schemaType: 'json',
+                            phase: 'serialization',
+                            payloadType: type,
+                            type,
+                            data,
+                            headers,
+                            validationErrors: validate.errors
+                        });
                     }
                 }
                 encodedMessage = Buffer.from(JSON.stringify(data));
@@ -176,17 +365,32 @@ export class ConfluentSchemaRegistry extends AbstractSchemaRegistry {
         return Buffer.concat([header, encodedMessage]);
     }
     #schemaDeserializer(type, fallbackDeserializer, data, headers, message) {
+        /*
+          Deserializing replaces the original payload, so record its size beforehand: it is the only
+          chance callers have to account for the actual ingress size of the message.
+        */
+        if ((type === 'key' || type === 'value') && Buffer.isBuffer(data)) {
+            trackConsumedPayloadLength(message, type, data);
+        }
         /* c8 ignore next 3 - Hard to test */
         if (typeof data === 'undefined' || data.length === 0) {
             return EMPTY_BUFFER;
         }
-        if (type === 'headerKey' || type === 'headerValue') {
+        const isHeader = type === 'headerKey' || type === 'headerValue';
+        if (isHeader) {
             message = headers;
         }
         const schemaId = this.getSchemaId(data, type);
         if (!schemaId) {
             return fallbackDeserializer(data);
         }
+        /*
+          Also track the schema ID here, so that it is exposed on the message metadata even when the
+          deserializers are used without the before-deserialization hook of this registry.
+        */
+        if (!isHeader) {
+            trackConsumedSchemaId(message, type, schemaId);
+        }
         const schema = this.#schemas.get(schemaId);
         if (!schema) {
             throw new UserError(`Schema with ID ${schemaId} not found.`, { missingSchema: schemaId });
@@ -204,7 +408,16 @@ export class ConfluentSchemaRegistry extends AbstractSchemaRegistry {
                 const validate = schema.schema;
                 const valid = validate(parsed);
                 if (!valid) {
-                    throw new UserError(`JSON Schema validation failed before deserialization: ${ajv.errorsText(validate.errors)}`, { type, data: parsed, headers, validationErrors: validate.errors });
+                    throw new SchemaValidationError(`JSON Schema validation failed before deserialization: ${this.#jsonAjv.errorsText(validate.errors)}`, {
+                        schemaId,
+                        schemaType: 'json',
+                        phase: 'deserialization',
+                        payloadType: type,
+                        type,
+                        data: parsed,
+                        headers,
+                        validationErrors: validate.errors
+                    });
                 }
                 return parsed;
             }

package/dist/symbols.d.ts

@@ -1,6 +1,8 @@
 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

@@ -2,6 +2,8 @@
 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/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 {

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

@@ -0,0 +1,7 @@
+import { type Reader } from "../../protocol/reader";
+import { Writer } from "../../protocol/writer";
+import { type AlterConfigsRequestResource, type AlterConfigsResponse } from "./alter-configs-v2";
+export * from "./alter-configs-v2";
+export declare function createRequest(resources: AlterConfigsRequestResource[], validateOnly: boolean): Writer;
+export declare function parseResponse(_: number, apiKey: number, apiVersion: number, reader: Reader): AlterConfigsResponse;
+export declare const api: import("../definitions").API<unknown[], AlterConfigsResponse>;

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

@@ -0,0 +1,2 @@
+export * from "./alter-configs-v0";
+export declare const api: import("../definitions").API<unknown[], import("./alter-configs-v2").AlterConfigsResponse>;

package/dist/typescript-4/dist/apis/admin/alter-partition-reassignments-v0.d.ts

@@ -1,9 +1,9 @@
-import { type NullableString } from "../../protocol/definitions";
+import { type Nullable, type NullableString } from "../../protocol/definitions";
 import { type Reader } from "../../protocol/reader";
 import { Writer } from "../../protocol/writer";
 export interface AlterPartitionReassignmentsRequestPartition {
   partitionIndex: number;
-  replicas: number[];
+  replicas: Nullable<number[]>;
 }
 export interface AlterPartitionReassignmentsRequestTopic {
   name: string;
@@ -21,6 +21,7 @@ export interface AlterPartitionReassignmentsResponseResponse {
 }
 export interface AlterPartitionReassignmentsResponse {
   throttleTimeMs: number;
+  allowReplicationFactorChange: boolean;
   errorCode: number;
   errorMessage: NullableString;
   responses: AlterPartitionReassignmentsResponseResponse[];

package/dist/typescript-4/dist/apis/admin/alter-partition-reassignments-v1.d.ts

@@ -1,9 +1,9 @@
-import { type NullableString } from "../../protocol/definitions";
+import { type Nullable, type NullableString } from "../../protocol/definitions";
 import { type Reader } from "../../protocol/reader";
 import { Writer } from "../../protocol/writer";
 export interface AlterPartitionReassignmentsRequestPartition {
   partitionIndex: number;
-  replicas: number[];
+  replicas: Nullable<number[]>;
 }
 export interface AlterPartitionReassignmentsRequestTopic {
   name: string;
@@ -15,15 +15,17 @@ export interface AlterPartitionReassignmentsResponsePartition {
   errorCode: number;
   errorMessage: NullableString;
 }
-export interface AlterPartitionReassignmentsResponseResponse {
+export interface AlterPartitionReassignmentsResponseTopic {
   name: string;
   partitions: AlterPartitionReassignmentsResponsePartition[];
 }
+export type AlterPartitionReassignmentsResponseResponse = AlterPartitionReassignmentsResponseTopic;
 export interface AlterPartitionReassignmentsResponse {
   throttleTimeMs: number;
+  allowReplicationFactorChange: boolean;
   errorCode: number;
   errorMessage: NullableString;
-  responses: AlterPartitionReassignmentsResponseResponse[];
+  responses: AlterPartitionReassignmentsResponseTopic[];
 }
 export declare function createRequest(timeoutMs: number, allowReplicationFactorChange: boolean, topics: AlterPartitionReassignmentsRequestTopic[]): Writer;
 export declare function parseResponse(_correlationId: number, apiKey: number, apiVersion: number, reader: Reader): AlterPartitionReassignmentsResponse;

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

@@ -0,0 +1,40 @@
+import { type Reader } from "../../protocol/reader";
+import { Writer } from "../../protocol/writer";
+export interface AlterPartitionRequestPartition {
+  partitionIndex: number;
+  leaderEpoch: number;
+  newIsrWithEpochs: AlterPartitionRequestBroker[];
+  leaderRecoveryState?: number;
+  partitionEpoch: number;
+}
+export interface AlterPartitionRequestBroker {
+  brokerId: number;
+  brokerEpoch: bigint;
+}
+export interface AlterPartitionRequestTopic {
+  topicName: string;
+  partitions: AlterPartitionRequestPartition[];
+}
+export type AlterPartitionRequest = Parameters<typeof createRequest>;
+export interface AlterPartitionResponsePartition {
+  partitionIndex: number;
+  errorCode: number;
+  leaderId: number;
+  leaderEpoch: number;
+  isr: number[];
+  leaderRecoveryState: number;
+  partitionEpoch: number;
+}
+export interface AlterPartitionResponseTopic {
+  topicName: string;
+  topicId: string;
+  partitions: AlterPartitionResponsePartition[];
+}
+export interface AlterPartitionResponse {
+  throttleTimeMs: number;
+  errorCode: number;
+  topics: AlterPartitionResponseTopic[];
+}
+export declare function createRequest(brokerId: number, brokerEpoch: bigint, topics: AlterPartitionRequestTopic[]): Writer;
+export declare function parseResponse(_correlationId: number, apiKey: number, apiVersion: number, reader: Reader): AlterPartitionResponse;
+export declare const api: import("../definitions").API<[brokerId: number, brokerEpoch: bigint, topics: AlterPartitionRequestTopic[]], AlterPartitionResponse>;

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

@@ -0,0 +1,37 @@
+import { type Reader } from "../../protocol/reader";
+import { Writer } from "../../protocol/writer";
+import type { AlterPartitionRequestBroker } from "./alter-partition-v0";
+export interface AlterPartitionRequestPartition {
+  partitionIndex: number;
+  leaderEpoch: number;
+  newIsrWithEpochs: AlterPartitionRequestBroker[];
+  leaderRecoveryState: number;
+  partitionEpoch: number;
+}
+export interface AlterPartitionRequestTopic {
+  topicName: string;
+  partitions: AlterPartitionRequestPartition[];
+}
+export type AlterPartitionRequest = Parameters<typeof createRequest>;
+export interface AlterPartitionResponsePartition {
+  partitionIndex: number;
+  errorCode: number;
+  leaderId: number;
+  leaderEpoch: number;
+  isr: number[];
+  leaderRecoveryState: number;
+  partitionEpoch: number;
+}
+export interface AlterPartitionResponseTopic {
+  topicName: string;
+  topicId: string;
+  partitions: AlterPartitionResponsePartition[];
+}
+export interface AlterPartitionResponse {
+  throttleTimeMs: number;
+  errorCode: number;
+  topics: AlterPartitionResponseTopic[];
+}
+export declare function createRequest(brokerId: number, brokerEpoch: bigint, topics: AlterPartitionRequestTopic[]): Writer;
+export declare function parseResponse(_correlationId: number, apiKey: number, apiVersion: number, reader: Reader): AlterPartitionResponse;
+export declare const api: import("../definitions").API<[brokerId: number, brokerEpoch: bigint, topics: AlterPartitionRequestTopic[]], AlterPartitionResponse>;

package/dist/typescript-4/dist/apis/admin/alter-partition-v2.d.ts

@@ -0,0 +1,36 @@
+import { type Reader } from "../../protocol/reader";
+import { Writer } from "../../protocol/writer";
+import type { AlterPartitionRequestBroker } from "./alter-partition-v0";
+export interface AlterPartitionRequestPartition {
+  partitionIndex: number;
+  leaderEpoch: number;
+  newIsrWithEpochs: AlterPartitionRequestBroker[];
+  leaderRecoveryState: number;
+  partitionEpoch: number;
+}
+export interface AlterPartitionRequestTopic {
+  topicId: string;
+  partitions: AlterPartitionRequestPartition[];
+}
+export type AlterPartitionRequest = Parameters<typeof createRequest>;
+export interface AlterPartitionResponsePartition {
+  partitionIndex: number;
+  errorCode: number;
+  leaderId: number;
+  leaderEpoch: number;
+  isr: number[];
+  leaderRecoveryState: number;
+  partitionEpoch: number;
+}
+export interface AlterPartitionResponseTopic {
+  topicId: string;
+  partitions: AlterPartitionResponsePartition[];
+}
+export interface AlterPartitionResponse {
+  throttleTimeMs: number;
+  errorCode: number;
+  topics: AlterPartitionResponseTopic[];
+}
+export declare function createRequest(brokerId: number, brokerEpoch: bigint, topics: AlterPartitionRequestTopic[]): Writer;
+export declare function parseResponse(_correlationId: number, apiKey: number, apiVersion: number, reader: Reader): AlterPartitionResponse;
+export declare const api: import("../definitions").API<[brokerId: number, brokerEpoch: bigint, topics: AlterPartitionRequestTopic[]], AlterPartitionResponse>;