@platformatic/kafka 0.1.0

package/dist/apis/consumer/offset-fetch.js

@@ -0,0 +1,81 @@
+import { ResponseError } from "../../errors.js";
+import { Writer } from "../../protocol/writer.js";
+import { createAPI } from "../definitions.js";
+/*
+  OffsetFetch Request (Version: 9) => [groups] require_stable TAG_BUFFER
+    groups => group_id member_id member_epoch [topics] TAG_BUFFER
+      group_id => COMPACT_STRING
+      member_id => COMPACT_NULLABLE_STRING
+      member_epoch => INT32
+      topics => name [partition_indexes] TAG_BUFFER
+        name => COMPACT_STRING
+        partition_indexes => INT32
+    require_stable => BOOLEAN
+*/
+export function createRequest(groups, requireStable) {
+    return Writer.create()
+        .appendArray(groups, (w, g) => {
+        w.appendString(g.groupId)
+            .appendString(g.memberId)
+            .appendInt32(g.memberEpoch)
+            .appendArray(g.topics, (w, t) => {
+            w.appendString(t.name).appendArray(t.partitionIndexes, (w, i) => w.appendInt32(i), true, false);
+        });
+    })
+        .appendBoolean(requireStable)
+        .appendTaggedFields();
+}
+/*
+  OffsetFetch Response (Version: 9) => throttle_time_ms [groups] TAG_BUFFER
+    throttle_time_ms => INT32
+    groups => group_id [topics] error_code TAG_BUFFER
+      group_id => COMPACT_STRING
+      topics => name [partitions] TAG_BUFFER
+        name => COMPACT_STRING
+        partitions => partition_index committed_offset committed_leader_epoch metadata error_code TAG_BUFFER
+          partition_index => INT32
+          committed_offset => INT64
+          committed_leader_epoch => INT32
+          metadata => COMPACT_NULLABLE_STRING
+          error_code => INT16
+      error_code => INT16
+*/
+export function parseResponse(_correlationId, apiKey, apiVersion, reader) {
+    const errors = [];
+    const response = {
+        throttleTimeMs: reader.readInt32(),
+        groups: reader.readArray((r, i) => {
+            const group = {
+                groupId: r.readString(),
+                topics: r.readArray((r, j) => {
+                    return {
+                        name: r.readString(),
+                        partitions: r.readArray((r, k) => {
+                            const partition = {
+                                partitionIndex: r.readInt32(),
+                                committedOffset: r.readInt64(),
+                                committedLeaderEpoch: r.readInt32(),
+                                metadata: r.readNullableString(),
+                                errorCode: r.readInt16()
+                            };
+                            if (partition.errorCode !== 0) {
+                                errors.push([`/groups/${i}/topics/${j}/partitions/${k}`, partition.errorCode]);
+                            }
+                            return partition;
+                        })
+                    };
+                }),
+                errorCode: r.readInt16()
+            };
+            if (group.errorCode !== 0) {
+                errors.push([`/groups/${i}`, group.errorCode]);
+            }
+            return group;
+        })
+    };
+    if (errors.length) {
+        throw new ResponseError(apiKey, apiVersion, Object.fromEntries(errors), response);
+    }
+    return response;
+}
+export const api = createAPI(9, 9, createRequest, parseResponse);

package/dist/apis/consumer/sync-group.d.ts

@@ -0,0 +1,18 @@
+import { type NullableString } from '../../protocol/definitions.ts';
+import { type Reader } from '../../protocol/reader.ts';
+import { Writer } from '../../protocol/writer.ts';
+export interface SyncGroupRequestAssignment {
+    memberId: string;
+    assignment: Buffer;
+}
+export type SyncGroupRequest = Parameters<typeof createRequest>;
+export interface SyncGroupResponse {
+    throttleTimeMs: number;
+    errorCode: number;
+    protocolType: NullableString;
+    protocolName: NullableString;
+    assignment: Buffer;
+}
+export declare function createRequest(groupId: string, generationId: number, memberId: string, groupInstanceId: NullableString, protocolType: NullableString, protocolName: NullableString, assignments: SyncGroupRequestAssignment[]): Writer;
+export declare function parseResponse(_correlationId: number, apiKey: number, apiVersion: number, reader: Reader): SyncGroupResponse;
+export declare const api: import("../definitions.ts").API<[groupId: string, generationId: number, memberId: string, groupInstanceId: NullableString, protocolType: NullableString, protocolName: NullableString, assignments: SyncGroupRequestAssignment[]], SyncGroupResponse>;

package/dist/apis/consumer/sync-group.js

@@ -0,0 +1,49 @@
+import { ResponseError } from "../../errors.js";
+import { Writer } from "../../protocol/writer.js";
+import { createAPI } from "../definitions.js";
+/*
+  SyncGroup Request (Version: 5) => group_id generation_id member_id group_instance_id protocol_type protocol_name [assignments] TAG_BUFFER
+    group_id => COMPACT_STRING
+    generation_id => INT32
+    member_id => COMPACT_STRING
+    group_instance_id => COMPACT_NULLABLE_STRING
+    protocol_type => COMPACT_NULLABLE_STRING
+    protocol_name => COMPACT_NULLABLE_STRING
+    assignments => member_id assignment TAG_BUFFER
+      member_id => COMPACT_STRING
+      assignment => COMPACT_BYTES
+
+*/
+export function createRequest(groupId, generationId, memberId, groupInstanceId, protocolType, protocolName, assignments) {
+    return Writer.create()
+        .appendString(groupId)
+        .appendInt32(generationId)
+        .appendString(memberId)
+        .appendString(groupInstanceId)
+        .appendString(protocolType)
+        .appendString(protocolName)
+        .appendArray(assignments, (w, a) => w.appendString(a.memberId).appendBytes(a.assignment))
+        .appendTaggedFields();
+}
+/*
+  SyncGroup Response (Version: 5) => throttle_time_ms error_code protocol_type protocol_name assignment TAG_BUFFER
+    throttle_time_ms => INT32
+    error_code => INT16
+    protocol_type => COMPACT_NULLABLE_STRING
+    protocol_name => COMPACT_NULLABLE_STRING
+    assignment => COMPACT_BYTES
+*/
+export function parseResponse(_correlationId, apiKey, apiVersion, reader) {
+    const response = {
+        throttleTimeMs: reader.readInt32(),
+        errorCode: reader.readInt16(),
+        protocolType: reader.readNullableString(),
+        protocolName: reader.readNullableString(),
+        assignment: reader.readBytes()
+    };
+    if (response.errorCode !== 0) {
+        throw new ResponseError(apiKey, apiVersion, { '': response.errorCode }, response);
+    }
+    return response;
+}
+export const api = createAPI(14, 5, createRequest, parseResponse);

package/dist/apis/definitions.d.ts

@@ -0,0 +1,16 @@
+import { type Connection } from '../network/connection.ts';
+import { type Reader } from '../protocol/reader.ts';
+import { type Writer } from '../protocol/writer.ts';
+export type Callback<ReturnType> = (error: Error | null, payload: ReturnType) => void;
+export type CallbackArguments<ReturnType> = [cb: Callback<ReturnType>];
+export type RequestCreator = (...args: any[]) => Writer;
+export type ResponseParser<ReturnType> = (correlationId: number, apiKey: number, apiVersion: number, reader: Reader) => ReturnType | Promise<ReturnType>;
+export type ResponseErrorWithLocation = [string, number];
+export type APIWithCallback<RequestArguments extends Array<unknown>, ResponseType> = (connection: Connection, ...args: [...RequestArguments, ...Partial<CallbackArguments<ResponseType>>]) => void;
+export type APIWithPromise<RequestArguments extends Array<unknown>, ResponseType> = (connection: Connection, ...args: RequestArguments) => Promise<ResponseType>;
+export type API<RequestType extends Array<unknown>, ResponseType> = APIWithCallback<RequestType, ResponseType> & {
+    async: APIWithPromise<RequestType, ResponseType>;
+    key: number;
+    version: number;
+};
+export declare function createAPI<RequestArguments extends Array<unknown>, ResponseType>(apiKey: number, apiVersion: number, createRequest: RequestCreator, parseResponse: ResponseParser<ResponseType>, hasRequestHeaderTaggedFields?: boolean, hasResponseHeaderTaggedFields?: boolean): API<RequestArguments, ResponseType>;

package/dist/apis/definitions.js

@@ -0,0 +1,12 @@
+import { promisify } from 'node:util';
+export function createAPI(apiKey, apiVersion, createRequest, parseResponse, hasRequestHeaderTaggedFields = true, hasResponseHeaderTaggedFields = true) {
+    const api = function api(connection, ...args) {
+        /* c8 ignore next */
+        const cb = typeof args[args.length - 1] === 'function' ? args.pop() : () => { };
+        connection.send(apiKey, apiVersion, () => createRequest(...args), parseResponse, hasRequestHeaderTaggedFields, hasResponseHeaderTaggedFields, cb);
+    };
+    api.async = promisify(api);
+    api.key = apiKey;
+    api.version = apiVersion;
+    return api;
+}

package/dist/apis/enumerations.d.ts

@@ -0,0 +1,114 @@
+export declare const FindCoordinatorKeyTypes: {
+    readonly GROUP: 0;
+    readonly TRANSACTION: 1;
+    readonly SHARE: 2;
+};
+export type FindCoordinatorKeyType = keyof typeof FindCoordinatorKeyTypes;
+export declare const ProduceAcks: {
+    readonly ALL: -1;
+    readonly NO_RESPONSE: 0;
+    readonly LEADER: 1;
+};
+export type ProduceAck = keyof typeof ProduceAcks;
+export declare const FetchIsolationLevels: {
+    READ_UNCOMMITTED: number;
+    READ_COMMITTED: number;
+};
+export type FetchIsolationLevel = keyof typeof FetchIsolationLevels;
+export declare const ListOffsetTimestamps: {
+    LATEST: bigint;
+    EARLIEST: bigint;
+};
+export type ListOffsetTimestamp = keyof typeof ListOffsetTimestamps;
+export declare const ResourceTypes: {
+    readonly UNKNOWN: 0;
+    readonly ANY: 1;
+    readonly TOPIC: 2;
+    readonly GROUP: 3;
+    readonly CLUSTER: 4;
+    readonly TRANSACTIONAL_ID: 5;
+    readonly DELEGATION_TOKEN: 6;
+};
+export type ResourceType = keyof typeof ResourceTypes;
+export declare const ResourcePatternTypes: {
+    readonly UNKNOWN: 0;
+    readonly ANY: 1;
+    readonly MATCH: 2;
+    readonly LITERAL: 3;
+    readonly PREFIXED: 4;
+};
+export type ResourcePatternType = keyof typeof ResourcePatternTypes;
+export declare const AclOperations: {
+    readonly UNKNOWN: 0;
+    readonly ANY: 1;
+    readonly ALL: 2;
+    readonly READ: 3;
+    readonly WRITE: 4;
+    readonly CREATE: 5;
+    readonly DELETE: 6;
+    readonly ALTER: 7;
+    readonly DESCRIBE: 8;
+    readonly CLUSTER_ACTION: 9;
+    readonly DESCRIBE_CONFIGS: 10;
+    readonly ALTER_CONFIGS: 11;
+    readonly IDEMPOTENT_WRITE: 12;
+};
+export type AclOperation = keyof typeof AclOperations;
+export declare const AclPermissionTypes: {
+    readonly UNKNOWN: 0;
+    readonly ANY: 1;
+    readonly DENY: 2;
+    readonly ALLOW: 3;
+};
+export type AclPermissionType = keyof typeof AclPermissionTypes;
+export declare const ConfigSources: {
+    readonly UNKNOWN: 0;
+    readonly TOPIC_CONFIG: 1;
+    readonly DYNAMIC_BROKER_CONFIG: 2;
+    readonly DYNAMIC_DEFAULT_BROKER_CONFIG: 3;
+    readonly STATIC_BROKER_CONFIG: 4;
+    readonly DEFAULT_CONFIG: 5;
+    readonly DYNAMIC_BROKER_LOGGER_CONFIG: 6;
+};
+export type ConfigSource = keyof typeof ConfigSources;
+export declare const ConfigTypes: {
+    readonly UNKNOWN: 0;
+    readonly TOPIC: 2;
+    readonly BROKER: 4;
+    readonly BROKER_LOGGER: 8;
+};
+export type ConfigType = keyof typeof ConfigTypes;
+export declare const IncrementalAlterConfigTypes: {
+    SET: number;
+    DELETE: number;
+    APPEND: number;
+    SUBTRACT: number;
+};
+export type IncrementalAlterConfigType = keyof typeof IncrementalAlterConfigTypes;
+export declare const ClientQuotaMatchTypes: {
+    readonly EXACT: 0;
+    readonly DEFAULT: 1;
+    readonly ANY: 2;
+};
+export type ClientQuotaMatchType = keyof typeof ClientQuotaMatchTypes;
+export declare const ScramMechanisms: {
+    readonly UNKNOWN: 0;
+    readonly SCRAM_SHA_256: 1;
+    readonly SCRAM_SHA_512: 2;
+};
+export type ScramMechanism = keyof typeof ScramMechanisms;
+export declare const DescribeClusterEndpointTypes: {
+    BROKERS: number;
+    CONTROLLERS: number;
+};
+export type DescribeClusterEndpointType = keyof typeof DescribeClusterEndpointTypes;
+export declare const ConsumerGroupStates: readonly ["PREPARING_REBALANCE", "COMPLETING_REBALANCE", "STABLE", "DEAD", "EMPTY"];
+export type ConsumerGroupState = (typeof ConsumerGroupStates)[number];
+export declare const TransactionStates: readonly ["EMPTY", "ONGOING", "PREPARE_ABORT", "COMMITTING", "ABORTING", "COMPLETE_COMMIT", "COMPLETE_ABORT"];
+export type TransactionState = (typeof TransactionStates)[number];
+export declare const FeatureUpgradeTypes: {
+    readonly UPGRADE: 1;
+    readonly SAFE_DOWNGRADE: 2;
+    readonly UNSAFE_DOWNGRADE: 3;
+};
+export type FeatureUpgradeType = keyof typeof FeatureUpgradeTypes;

package/dist/apis/enumerations.js

@@ -0,0 +1,78 @@
+// Metadata API
+// ./metadata/find-coordinator.ts
+export const FindCoordinatorKeyTypes = { GROUP: 0, TRANSACTION: 1, SHARE: 2 };
+// Producer API
+export const ProduceAcks = {
+    ALL: -1,
+    NO_RESPONSE: 0,
+    LEADER: 1
+};
+// Consumer API
+// ./consumer/fetch.ts
+export const FetchIsolationLevels = { READ_UNCOMMITTED: 0, READ_COMMITTED: 1 };
+export const ListOffsetTimestamps = { LATEST: -1n, EARLIEST: -2n };
+// Admin API
+// ./admin/*-acls.ts - See: https://cwiki.apache.org/confluence/display/KAFKA/KIP-140%3A+Add+administrative+RPCs+for+adding%2C+deleting%2C+and+listing+ACLs
+export const ResourceTypes = {
+    UNKNOWN: 0,
+    ANY: 1,
+    TOPIC: 2,
+    GROUP: 3,
+    CLUSTER: 4,
+    TRANSACTIONAL_ID: 5,
+    DELEGATION_TOKEN: 6
+};
+export const ResourcePatternTypes = { UNKNOWN: 0, ANY: 1, MATCH: 2, LITERAL: 3, PREFIXED: 4 };
+export const AclOperations = {
+    UNKNOWN: 0,
+    ANY: 1,
+    ALL: 2,
+    READ: 3,
+    WRITE: 4,
+    CREATE: 5,
+    DELETE: 6,
+    ALTER: 7,
+    DESCRIBE: 8,
+    CLUSTER_ACTION: 9,
+    DESCRIBE_CONFIGS: 10,
+    ALTER_CONFIGS: 11,
+    IDEMPOTENT_WRITE: 12
+};
+export const AclPermissionTypes = { UNKNOWN: 0, ANY: 1, DENY: 2, ALLOW: 3 };
+// ./admin/*-configs.ts
+export const ConfigSources = {
+    UNKNOWN: 0,
+    TOPIC_CONFIG: 1,
+    DYNAMIC_BROKER_CONFIG: 2,
+    DYNAMIC_DEFAULT_BROKER_CONFIG: 3,
+    STATIC_BROKER_CONFIG: 4,
+    DEFAULT_CONFIG: 5,
+    DYNAMIC_BROKER_LOGGER_CONFIG: 6
+};
+export const ConfigTypes = {
+    UNKNOWN: 0,
+    TOPIC: 2,
+    BROKER: 4,
+    BROKER_LOGGER: 8
+};
+export const IncrementalAlterConfigTypes = { SET: 0, DELETE: 1, APPEND: 2, SUBTRACT: 3 };
+// ./admin/*-client-quotas.ts
+export const ClientQuotaMatchTypes = { EXACT: 0, DEFAULT: 1, ANY: 2 };
+// ./admin/*-scram-credentials.ts
+export const ScramMechanisms = { UNKNOWN: 0, SCRAM_SHA_256: 1, SCRAM_SHA_512: 2 };
+// ./admin/describe-cluster.ts
+export const DescribeClusterEndpointTypes = { BROKERS: 1, CONTROLLERS: 2 };
+// ./admin/list-groups.ts
+export const ConsumerGroupStates = ['PREPARING_REBALANCE', 'COMPLETING_REBALANCE', 'STABLE', 'DEAD', 'EMPTY'];
+// ./admin/list-transactions.ts
+export const TransactionStates = [
+    'EMPTY',
+    'ONGOING',
+    'PREPARE_ABORT',
+    'COMMITTING',
+    'ABORTING',
+    'COMPLETE_COMMIT',
+    'COMPLETE_ABORT'
+];
+// ./admin/update-features.ts
+export const FeatureUpgradeTypes = { UPGRADE: 1, SAFE_DOWNGRADE: 2, UNSAFE_DOWNGRADE: 3 };

package/dist/apis/index.d.ts

@@ -0,0 +1,8 @@
+export * from './definitions.ts';
+export * from './enumerations.ts';
+export * from './admin/index.ts';
+export * from './consumer/index.ts';
+export * from './metadata/index.ts';
+export * from './producer/index.ts';
+export * from './security/index.ts';
+export * from './telemetry/index.ts';

package/dist/apis/index.js

@@ -0,0 +1,10 @@
+// Generics
+export * from "./definitions.js";
+export * from "./enumerations.js";
+// Low-level APIs
+export * from "./admin/index.js";
+export * from "./consumer/index.js";
+export * from "./metadata/index.js";
+export * from "./producer/index.js";
+export * from "./security/index.js";
+export * from "./telemetry/index.js";

package/dist/apis/metadata/api-versions.d.ts

@@ -0,0 +1,17 @@
+import { type Reader } from '../../protocol/reader.ts';
+import { Writer } from '../../protocol/writer.ts';
+export type ApiVersionsRequest = Parameters<typeof createRequest>;
+export interface ApiVersionsResponseApi {
+    apiKey: number;
+    name: string;
+    minVersion: number;
+    maxVersion: number;
+}
+export type ApiVersionsResponse = {
+    errorCode: number;
+    apiKeys: ApiVersionsResponseApi[];
+    throttleTimeMs: number;
+};
+export declare function createRequest(clientSoftwareName: string, clientSoftwareVersion: string): Writer;
+export declare function parseResponse(_correlationId: number, apiKey: number, apiVersion: number, reader: Reader): ApiVersionsResponse;
+export declare const api: import("../definitions.ts").API<[clientSoftwareName: string, clientSoftwareVersion: string], ApiVersionsResponse>;

package/dist/apis/metadata/api-versions.js

@@ -0,0 +1,41 @@
+import { ResponseError } from "../../errors.js";
+import { protocolAPIsById } from "../../protocol/apis.js";
+import { Writer } from "../../protocol/writer.js";
+import { createAPI } from "../definitions.js";
+/*
+  ApiVersions Request (Version: 4) => client_software_name client_software_version TAG_BUFFER
+    client_software_name => COMPACT_STRING
+    client_software_version => COMPACT_STRING
+*/
+export function createRequest(clientSoftwareName, clientSoftwareVersion) {
+    return Writer.create().appendString(clientSoftwareName).appendString(clientSoftwareVersion).appendTaggedFields();
+}
+/*
+  ApiVersions Response (Version: 4) => error_code [api_keys] throttle_time_ms TAG_BUFFER
+    error_code => INT16
+    api_keys => api_key min_version max_version TAG_BUFFER
+      api_key => INT16
+      min_version => INT16
+      max_version => INT16
+    throttle_time_ms => INT32
+*/
+export function parseResponse(_correlationId, apiKey, apiVersion, reader) {
+    const response = {
+        errorCode: reader.readInt16(),
+        apiKeys: reader.readArray(r => {
+            const apiKey = r.readInt16();
+            return {
+                apiKey,
+                name: protocolAPIsById[apiKey],
+                minVersion: r.readInt16(),
+                maxVersion: r.readInt16()
+            };
+        }),
+        throttleTimeMs: reader.readInt32()
+    };
+    if (response.errorCode !== 0) {
+        throw new ResponseError(apiKey, apiVersion, { '': response.errorCode }, response);
+    }
+    return response;
+}
+export const api = createAPI(18, 4, createRequest, parseResponse, true, false);

package/dist/apis/metadata/find-coordinator.d.ts

@@ -0,0 +1,19 @@
+import { type NullableString } from '../../protocol/definitions.ts';
+import { type Reader } from '../../protocol/reader.ts';
+import { Writer } from '../../protocol/writer.ts';
+export type FindCoordinatorRequest = Parameters<typeof createRequest>;
+export interface FindCoordinatorResponseCoordinator {
+    key: string;
+    nodeId: number;
+    host: string;
+    port: number;
+    errorCode: number;
+    errorMessage: NullableString;
+}
+export interface FindCoordinatorResponse {
+    throttleTimeMs: number;
+    coordinators: FindCoordinatorResponseCoordinator[];
+}
+export declare function createRequest(keyType: number, coordinatorKeys: string[]): Writer;
+export declare function parseResponse(_correlationId: number, apiKey: number, apiVersion: number, reader: Reader): FindCoordinatorResponse;
+export declare const api: import("../definitions.ts").API<[keyType: number, coordinatorKeys: string[]], FindCoordinatorResponse>;

package/dist/apis/metadata/find-coordinator.js

@@ -0,0 +1,50 @@
+import { ResponseError } from "../../errors.js";
+import { Writer } from "../../protocol/writer.js";
+import { createAPI } from "../definitions.js";
+/*
+  FindCoordinator Request (Version: 6) => key_type [coordinator_keys] TAG_BUFFER
+    key_type => INT8
+    coordinator_keys => COMPACT_STRING
+*/
+export function createRequest(keyType, coordinatorKeys) {
+    return Writer.create()
+        .appendInt8(keyType)
+        .appendArray(coordinatorKeys, (w, k) => w.appendString(k), true, false)
+        .appendTaggedFields();
+}
+/*
+  FindCoordinator Response (Version: 6) => throttle_time_ms [coordinators] TAG_BUFFER
+    throttle_time_ms => INT32
+    coordinators => key node_id host port error_code error_message TAG_BUFFER
+      key => COMPACT_STRING
+      node_id => INT32
+      host => COMPACT_STRING
+      port => INT32
+      error_code => INT16
+      error_message => COMPACT_NULLABLE_STRING
+*/
+export function parseResponse(_correlationId, apiKey, apiVersion, reader) {
+    const errors = [];
+    const response = {
+        throttleTimeMs: reader.readInt32(),
+        coordinators: reader.readArray((r, i) => {
+            const coordinator = {
+                key: r.readString(),
+                nodeId: r.readInt32(),
+                host: r.readString(),
+                port: r.readInt32(),
+                errorCode: r.readInt16(),
+                errorMessage: r.readNullableString()
+            };
+            if (coordinator.errorCode !== 0) {
+                errors.push([`/coordinators/${i}`, coordinator.errorCode]);
+            }
+            return coordinator;
+        })
+    };
+    if (errors.length) {
+        throw new ResponseError(apiKey, apiVersion, Object.fromEntries(errors), response);
+    }
+    return response;
+}
+export const api = createAPI(10, 6, createRequest, parseResponse);

package/dist/apis/metadata/index.d.ts

@@ -0,0 +1,3 @@
+export * as apiVersionsV4 from './api-versions.ts';
+export * as findCoordinatorV6 from './find-coordinator.ts';
+export * as metadataV12 from './metadata.ts';

package/dist/apis/metadata/index.js

@@ -0,0 +1,3 @@
+export * as apiVersionsV4 from "./api-versions.js";
+export * as findCoordinatorV6 from "./find-coordinator.js";
+export * as metadataV12 from "./metadata.js";

package/dist/apis/metadata/metadata.d.ts

@@ -0,0 +1,37 @@
+import { type NullableString } from '../../protocol/definitions.ts';
+import { type Reader } from '../../protocol/reader.ts';
+import { Writer } from '../../protocol/writer.ts';
+export type MetadataRequest = Parameters<typeof createRequest>;
+export interface MetadataResponsePartition {
+    errorCode: number;
+    partitionIndex: number;
+    leaderId: number;
+    leaderEpoch: number;
+    replicaNodes: number[];
+    isrNodes: number[];
+    offlineReplicas: number[];
+}
+export interface MetadataResponseTopic {
+    errorCode: number;
+    name: NullableString;
+    topicId: string;
+    isInternal: boolean;
+    partitions: MetadataResponsePartition[];
+    topicAuthorizedOperations: number;
+}
+export interface MetadataResponseBroker {
+    nodeId: number;
+    host: string;
+    port: number;
+    rack: NullableString;
+}
+export interface MetadataResponse {
+    throttleTimeMs: number;
+    brokers: MetadataResponseBroker[];
+    clusterId: NullableString;
+    controllerId: number;
+    topics: MetadataResponseTopic[];
+}
+export declare function createRequest(topics: string[] | null, allowAutoTopicCreation?: boolean, includeTopicAuthorizedOperations?: boolean): Writer;
+export declare function parseResponse(_correlationId: number, apiKey: number, apiVersion: number, reader: Reader): MetadataResponse;
+export declare const api: import("../definitions.ts").API<[topics: string[] | null, allowAutoTopicCreation?: boolean | undefined, includeTopicAuthorizedOperations?: boolean | undefined], MetadataResponse>;

package/dist/apis/metadata/metadata.js

@@ -0,0 +1,92 @@
+import { ResponseError } from "../../errors.js";
+import { Writer } from "../../protocol/writer.js";
+import { createAPI } from "../definitions.js";
+/*
+  Metadata Request (Version: 12) => [topics] allow_auto_topic_creation include_topic_authorized_operations TAG_BUFFER
+    topics => topic_id name TAG_BUFFER
+      topic_id => UUID
+      name => COMPACT_NULLABLE_STRING
+    allow_auto_topic_creation => BOOLEAN
+    include_topic_authorized_operations => BOOLEAN
+*/
+export function createRequest(topics, allowAutoTopicCreation = false, includeTopicAuthorizedOperations = false) {
+    return Writer.create()
+        .appendArray(topics, (w, topic) => w.appendUUID(null).appendString(topic))
+        .appendBoolean(allowAutoTopicCreation)
+        .appendBoolean(includeTopicAuthorizedOperations)
+        .appendTaggedFields();
+}
+/*
+  Metadata Response (Version: 12) => throttle_time_ms [brokers] cluster_id controller_id [topics] TAG_BUFFER
+    throttle_time_ms => INT32
+    brokers => node_id host port rack TAG_BUFFER
+      node_id => INT32
+      host => COMPACT_STRING
+      port => INT32
+      rack => COMPACT_NULLABLE_STRING
+    cluster_id => COMPACT_NULLABLE_STRING
+    controller_id => INT32
+    topics => error_code name topic_id is_internal [partitions] topic_authorized_operations TAG_BUFFER
+      error_code => INT16
+      name => COMPACT_NULLABLE_STRING
+      topic_id => UUID
+      is_internal => BOOLEAN
+      partitions => error_code partition_index leader_id leader_epoch [replica_nodes] [isr_nodes] [offline_replicas] TAG_BUFFER
+        error_code => INT16
+        partition_index => INT32
+        leader_id => INT32
+        leader_epoch => INT32
+        replica_nodes => INT32
+        isr_nodes => INT32
+        offline_replicas => INT32
+      topic_authorized_operations => INT32
+*/
+export function parseResponse(_correlationId, apiKey, apiVersion, reader) {
+    const errors = [];
+    const response = {
+        throttleTimeMs: reader.readInt32(),
+        brokers: reader.readArray(r => {
+            return {
+                nodeId: r.readInt32(),
+                host: r.readString(),
+                port: r.readInt32(),
+                rack: r.readNullableString()
+            };
+        }),
+        clusterId: reader.readNullableString(),
+        controllerId: reader.readInt32(),
+        topics: reader.readArray((r, i) => {
+            const errorCode = r.readInt16();
+            if (errorCode !== 0) {
+                errors.push([`/topics/${i}`, errorCode]);
+            }
+            return {
+                errorCode,
+                name: r.readNullableString(),
+                topicId: r.readUUID(),
+                isInternal: r.readBoolean(),
+                partitions: r.readArray((r, j) => {
+                    const errorCode = r.readInt16();
+                    if (errorCode !== 0) {
+                        errors.push([`/topics/${i}/partitions/${j}`, errorCode]);
+                    }
+                    return {
+                        errorCode,
+                        partitionIndex: r.readInt32(),
+                        leaderId: r.readInt32(),
+                        leaderEpoch: r.readInt32(),
+                        replicaNodes: r.readArray(() => r.readInt32(), true, false),
+                        isrNodes: r.readArray(() => r.readInt32(), true, false),
+                        offlineReplicas: r.readArray(() => r.readInt32(), true, false)
+                    };
+                }),
+                topicAuthorizedOperations: reader.readInt32()
+            };
+        })
+    };
+    if (errors.length) {
+        throw new ResponseError(apiKey, apiVersion, Object.fromEntries(errors), response);
+    }
+    return response;
+}
+export const api = createAPI(3, 12, createRequest, parseResponse);