@platformatic/kafka 0.1.0

package/dist/apis/telemetry/get-telemetry-subscriptions.js

@@ -0,0 +1,46 @@
+import { ResponseError } from "../../errors.js";
+import { Writer } from "../../protocol/writer.js";
+import { createAPI } from "../definitions.js";
+/*
+  GetTelemetrySubscriptions Request (Version: 0) => client_instance_id TAG_BUFFER
+    client_instance_id => UUID
+*/
+export function createRequest(clientInstanceId) {
+    return Writer.create().appendUUID(clientInstanceId).appendTaggedFields();
+}
+/*
+  GetTelemetrySubscriptions Response (Version: 0) => throttle_time_ms error_code client_instance_id subscription_id [accepted_compression_types] push_interval_ms telemetry_max_bytes delta_temporality [requested_metrics] TAG_BUFFER
+    throttle_time_ms => INT32
+    error_code => INT16
+    client_instance_id => UUID
+    subscription_id => INT32
+    accepted_compression_types => INT8
+    push_interval_ms => INT32
+    telemetry_max_bytes => INT32
+    delta_temporality => BOOLEAN
+    requested_metrics => COMPACT_STRING
+*/
+export function parseResponse(_correlationId, apiKey, apiVersion, reader) {
+    const errors = [];
+    const throttleTimeMs = reader.readInt32();
+    const errorCode = reader.readInt16();
+    if (errorCode !== 0) {
+        errors.push(['', errorCode]);
+    }
+    const response = {
+        throttleTimeMs,
+        errorCode,
+        clientInstanceId: reader.readUUID(),
+        subscriptionId: reader.readInt32(),
+        acceptedCompressionTypes: reader.readArray(r => r.readInt8(), true, false),
+        pushIntervalMs: reader.readInt32(),
+        telemetryMaxBytes: reader.readInt32(),
+        deltaTemporality: reader.readBoolean(),
+        requestedMetrics: reader.readArray(r => r.readString(), true, false)
+    };
+    if (errors.length) {
+        throw new ResponseError(apiKey, apiVersion, Object.fromEntries(errors), response);
+    }
+    return response;
+}
+export const api = createAPI(71, 0, createRequest, parseResponse);

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

@@ -0,0 +1,3 @@
+export * as getTelemetrySubscriptionsV0 from './get-telemetry-subscriptions.ts';
+export * as listClientMetricsResourcesV0 from './list-client-metrics-resources.ts';
+export * as pushTelemetryV0 from './push-telemetry.ts';

package/dist/apis/telemetry/index.js

@@ -0,0 +1,3 @@
+export * as getTelemetrySubscriptionsV0 from "./get-telemetry-subscriptions.js";
+export * as listClientMetricsResourcesV0 from "./list-client-metrics-resources.js";
+export * as pushTelemetryV0 from "./push-telemetry.js";

package/dist/apis/telemetry/list-client-metrics-resources.d.ts

@@ -0,0 +1,14 @@
+import { type Reader } from '../../protocol/reader.ts';
+import { Writer } from '../../protocol/writer.ts';
+export type ListClientMetricsResourcesRequest = Parameters<typeof createRequest>;
+export interface ListClientMetricsResourcesResource {
+    name: string;
+}
+export interface ListClientMetricsResourcesResponse {
+    throttleTimeMs: number;
+    errorCode: number;
+    clientMetricsResources: ListClientMetricsResourcesResource[];
+}
+export declare function createRequest(): Writer;
+export declare function parseResponse(_correlationId: number, apiKey: number, apiVersion: number, reader: Reader): ListClientMetricsResourcesResponse;
+export declare const api: import("../definitions.ts").API<[], ListClientMetricsResourcesResponse>;

package/dist/apis/telemetry/list-client-metrics-resources.js

@@ -0,0 +1,32 @@
+import { ResponseError } from "../../errors.js";
+import { Writer } from "../../protocol/writer.js";
+import { createAPI } from "../definitions.js";
+/*
+  ListClientMetricsResources Request (Version: 0) => TAG_BUFFER
+*/
+export function createRequest() {
+    return Writer.create().appendTaggedFields();
+}
+/*
+ListClientMetricsResources Response (Version: 0) => throttle_time_ms error_code [client_metrics_resources] TAG_BUFFER
+  throttle_time_ms => INT32
+  error_code => INT16
+  client_metrics_resources => name TAG_BUFFER
+    name => COMPACT_STRING
+*/
+export function parseResponse(_correlationId, apiKey, apiVersion, reader) {
+    const response = {
+        throttleTimeMs: reader.readInt32(),
+        errorCode: reader.readInt16(),
+        clientMetricsResources: reader.readArray(r => {
+            return {
+                name: r.readString()
+            };
+        })
+    };
+    if (response.errorCode !== 0) {
+        throw new ResponseError(apiKey, apiVersion, { '': response.errorCode }, response);
+    }
+    return response;
+}
+export const api = createAPI(74, 0, createRequest, parseResponse);

package/dist/apis/telemetry/push-telemetry.d.ts

@@ -0,0 +1,10 @@
+import { type Reader } from '../../protocol/reader.ts';
+import { Writer } from '../../protocol/writer.ts';
+export type PushTelemetryRequest = Parameters<typeof createRequest>;
+export interface PushTelemetryResponse {
+    throttleTimeMs: number;
+    errorCode: number;
+}
+export declare function createRequest(clientInstanceId: string, subscriptionId: number, terminating: boolean, compressionType: number, metrics: Buffer): Writer;
+export declare function parseResponse(_correlationId: number, apiKey: number, apiVersion: number, reader: Reader): PushTelemetryResponse;
+export declare const api: import("../definitions.ts").API<[clientInstanceId: string, subscriptionId: number, terminating: boolean, compressionType: number, metrics: Buffer<ArrayBufferLike>], PushTelemetryResponse>;

package/dist/apis/telemetry/push-telemetry.js

@@ -0,0 +1,36 @@
+import { ResponseError } from "../../errors.js";
+import { Writer } from "../../protocol/writer.js";
+import { createAPI } from "../definitions.js";
+/*
+  PushTelemetry Request (Version: 0) => client_instance_id subscription_id terminating compression_type metrics TAG_BUFFER
+    client_instance_id => UUID
+    subscription_id => INT32
+    terminating => BOOLEAN
+    compression_type => INT8
+    metrics => COMPACT_BYTES
+*/
+export function createRequest(clientInstanceId, subscriptionId, terminating, compressionType, metrics) {
+    return Writer.create()
+        .appendUUID(clientInstanceId)
+        .appendInt32(subscriptionId)
+        .appendBoolean(terminating)
+        .appendInt8(compressionType)
+        .appendBytes(metrics)
+        .appendTaggedFields();
+}
+/*
+  PushTelemetry Response (Version: 0) => throttle_time_ms error_code TAG_BUFFER
+    throttle_time_ms => INT32
+    error_code => INT16
+*/
+export function parseResponse(_correlationId, apiKey, apiVersion, reader) {
+    const response = {
+        throttleTimeMs: reader.readInt32(),
+        errorCode: reader.readInt16()
+    };
+    if (response.errorCode !== 0) {
+        throw new ResponseError(apiKey, apiVersion, { '': response.errorCode }, response);
+    }
+    return response;
+}
+export const api = createAPI(72, 0, createRequest, parseResponse);

package/dist/clients/admin/admin.d.ts

@@ -0,0 +1,18 @@
+import { type Callback } from '../../apis/definitions.ts';
+import { Base } from '../base/base.ts';
+import { type CallbackWithPromise } from '../callbacks.ts';
+import { type AdminOptions, type CreatedTopic, type CreateTopicsOptions, type DeleteGroupsOptions, type DeleteTopicsOptions, type DescribeGroupsOptions, type Group, type GroupBase, type ListGroupsOptions } from './types.ts';
+export declare class Admin extends Base<AdminOptions> {
+    #private;
+    constructor(options: AdminOptions);
+    createTopics(options: CreateTopicsOptions, callback: Callback<CreatedTopic[]>): void;
+    createTopics(options: CreateTopicsOptions): Promise<CreatedTopic[]>;
+    deleteTopics(options: DeleteTopicsOptions, callback: CallbackWithPromise<void>): void;
+    deleteTopics(options: DeleteTopicsOptions): Promise<void>;
+    listGroups(options: ListGroupsOptions, callback: CallbackWithPromise<Map<string, GroupBase>>): void;
+    listGroups(options?: ListGroupsOptions): Promise<Map<string, GroupBase>>;
+    describeGroups(options: DescribeGroupsOptions, callback: CallbackWithPromise<Map<string, Group>>): void;
+    describeGroups(options: DescribeGroupsOptions): Promise<Map<string, Group>>;
+    deleteGroups(options: DeleteGroupsOptions, callback: CallbackWithPromise<void>): void;
+    deleteGroups(options: DeleteGroupsOptions): Promise<void>;
+}

package/dist/clients/admin/admin.js

@@ -0,0 +1,322 @@
+import { api as createTopicsV7 } from "../../apis/admin/create-topics.js";
+import { api as deleteGroupsV2 } from "../../apis/admin/delete-groups.js";
+import { api as deleteTopicsV6 } from "../../apis/admin/delete-topics.js";
+import { api as describeGroupsV5 } from "../../apis/admin/describe-groups.js";
+import { api as listGroupsV5 } from "../../apis/admin/list-groups.js";
+import { FindCoordinatorKeyTypes } from "../../apis/enumerations.js";
+import { api as findCoordinatorV6 } from "../../apis/metadata/find-coordinator.js";
+import { Reader } from "../../protocol/reader.js";
+import { Base, kBootstrapBrokers, kCheckNotClosed, kConnections, kMetadata, kOptions, kPerformDeduplicated, kPerformWithRetry, kValidateOptions } from "../base/base.js";
+import { createPromisifiedCallback, kCallbackPromise, runConcurrentCallbacks } from "../callbacks.js";
+import { createTopicsOptionsValidator, deleteGroupsOptionsValidator, deleteTopicsOptionsValidator, describeGroupsOptionsValidator, listGroupsOptionsValidator } from "./options.js";
+export class Admin extends Base {
+    constructor(options) {
+        super(options);
+    }
+    createTopics(options, callback) {
+        if (!callback) {
+            callback = createPromisifiedCallback();
+        }
+        if (this[kCheckNotClosed](callback)) {
+            return callback[kCallbackPromise];
+        }
+        const validationError = this[kValidateOptions](options, createTopicsOptionsValidator, '/options', false);
+        if (validationError) {
+            callback(validationError, undefined);
+            return callback[kCallbackPromise];
+        }
+        this.#createTopics(options, callback);
+        return callback[kCallbackPromise];
+    }
+    deleteTopics(options, callback) {
+        if (!callback) {
+            callback = createPromisifiedCallback();
+        }
+        if (this[kCheckNotClosed](callback)) {
+            return callback[kCallbackPromise];
+        }
+        const validationError = this[kValidateOptions](options, deleteTopicsOptionsValidator, '/options', false);
+        if (validationError) {
+            callback(validationError, undefined);
+            return callback[kCallbackPromise];
+        }
+        this.#deleteTopics(options, callback);
+        return callback[kCallbackPromise];
+    }
+    listGroups(options, callback) {
+        if (!callback) {
+            callback = createPromisifiedCallback();
+        }
+        if (this[kCheckNotClosed](callback)) {
+            return callback[kCallbackPromise];
+        }
+        if (!options) {
+            options = {};
+        }
+        const validationError = this[kValidateOptions](options, listGroupsOptionsValidator, '/options', false);
+        if (validationError) {
+            callback(validationError, undefined);
+            return callback[kCallbackPromise];
+        }
+        options.types ??= ['classic'];
+        this.#listGroups(options, callback);
+        return callback[kCallbackPromise];
+    }
+    describeGroups(options, callback) {
+        if (!callback) {
+            callback = createPromisifiedCallback();
+        }
+        if (this[kCheckNotClosed](callback)) {
+            return callback[kCallbackPromise];
+        }
+        const validationError = this[kValidateOptions](options, describeGroupsOptionsValidator, '/options', false);
+        if (validationError) {
+            callback(validationError, undefined);
+            return callback[kCallbackPromise];
+        }
+        this.#describeGroups(options, callback);
+        return callback[kCallbackPromise];
+    }
+    deleteGroups(options, callback) {
+        if (!callback) {
+            callback = createPromisifiedCallback();
+        }
+        if (this[kCheckNotClosed](callback)) {
+            return callback[kCallbackPromise];
+        }
+        const validationError = this[kValidateOptions](options, deleteGroupsOptionsValidator, '/options', false);
+        if (validationError) {
+            callback(validationError, undefined);
+            return callback[kCallbackPromise];
+        }
+        this.#deleteGroups(options, callback);
+        return callback[kCallbackPromise];
+    }
+    #createTopics(options, callback) {
+        const numPartitions = options.partitions ?? 1;
+        const replicationFactor = options.replicas ?? 1;
+        const assignments = [];
+        for (const { partition, brokers } of options.assignments ?? []) {
+            assignments.push({ partitionIndex: partition, brokerIds: brokers });
+        }
+        const requests = [];
+        for (const topic of options.topics) {
+            requests.push({
+                name: topic,
+                numPartitions,
+                replicationFactor,
+                assignments,
+                configs: []
+            });
+        }
+        this[kPerformDeduplicated]('createTopics', deduplicateCallback => {
+            this[kPerformWithRetry]('createTopics', retryCallback => {
+                this[kConnections].getFirstAvailable(this[kBootstrapBrokers], (error, connection) => {
+                    if (error) {
+                        retryCallback(error, undefined);
+                        return;
+                    }
+                    createTopicsV7(connection, requests, this[kOptions].timeout, false, retryCallback);
+                });
+            }, (error, response) => {
+                if (error) {
+                    deduplicateCallback(error, undefined);
+                    return;
+                }
+                const created = [];
+                for (const { name, topicId: id, numPartitions: partitions, replicationFactor: replicas, configs } of response.topics) {
+                    const configuration = {};
+                    for (const { name, value } of configs) {
+                        configuration[name] = value;
+                    }
+                    created.push({ id, name, partitions, replicas, configuration });
+                }
+                deduplicateCallback(null, created);
+            }, 0);
+        }, callback);
+    }
+    #deleteTopics(options, callback) {
+        this[kPerformDeduplicated]('deleteTopics', deduplicateCallback => {
+            this[kPerformWithRetry]('deleteTopics', retryCallback => {
+                this[kConnections].getFirstAvailable(this[kBootstrapBrokers], (error, connection) => {
+                    if (error) {
+                        retryCallback(error, undefined);
+                        return;
+                    }
+                    const requests = [];
+                    for (const topic of options.topics) {
+                        requests.push({ name: topic });
+                    }
+                    deleteTopicsV6(connection, requests, this[kOptions].timeout, retryCallback);
+                });
+            }, deduplicateCallback, 0);
+        }, callback);
+    }
+    #listGroups(options, callback) {
+        // Find all the brokers in the cluster
+        this[kMetadata]({ topics: [] }, (error, metadata) => {
+            if (error) {
+                callback(error, undefined);
+                return;
+            }
+            runConcurrentCallbacks('Listing groups failed.', metadata.brokers, ([, broker], concurrentCallback) => {
+                this[kConnections].get(broker, (error, connection) => {
+                    if (error) {
+                        concurrentCallback(error, undefined);
+                        return;
+                    }
+                    this[kPerformWithRetry]('listGroups', retryCallback => {
+                        listGroupsV5(connection, options.states ?? [], options.types, retryCallback);
+                    }, concurrentCallback, 0);
+                });
+            }, (error, results) => {
+                if (error) {
+                    callback(error, undefined);
+                    return;
+                }
+                const groups = new Map();
+                for (const result of results) {
+                    for (const raw of result.groups) {
+                        groups.set(raw.groupId, {
+                            id: raw.groupId,
+                            state: raw.groupState.toUpperCase(),
+                            groupType: raw.groupType,
+                            protocolType: raw.protocolType
+                        });
+                    }
+                }
+                callback(null, groups);
+            });
+        });
+    }
+    #describeGroups(options, callback) {
+        this[kMetadata]({ topics: [] }, (error, metadata) => {
+            if (error) {
+                callback(error, undefined);
+                return;
+            }
+            this.#findGroupCoordinator(options.groups, (error, response) => {
+                if (error) {
+                    callback(error, undefined);
+                    return;
+                }
+                // Group the groups by coordinator
+                const coordinators = new Map();
+                for (const { key: group, nodeId: node } of response.coordinators) {
+                    let coordinator = coordinators.get(node);
+                    if (!coordinator) {
+                        coordinator = [];
+                        coordinators.set(node, coordinator);
+                    }
+                    coordinator.push(group);
+                }
+                runConcurrentCallbacks('Describing groups failed.', coordinators, ([node, groups], concurrentCallback) => {
+                    this[kConnections].get(metadata.brokers.get(node), (error, connection) => {
+                        if (error) {
+                            concurrentCallback(error, undefined);
+                            return;
+                        }
+                        this[kPerformWithRetry]('describeGroups', retryCallback => {
+                            describeGroupsV5(connection, groups, options.includeAuthorizedOperations ?? false, retryCallback);
+                        }, concurrentCallback, 0);
+                    });
+                }, (error, results) => {
+                    if (error) {
+                        callback(error, undefined);
+                        return;
+                    }
+                    const groups = new Map();
+                    for (const result of results) {
+                        for (const raw of result.groups) {
+                            const group = {
+                                id: raw.groupId,
+                                state: raw.groupState.toUpperCase(),
+                                protocolType: raw.protocolType,
+                                protocol: raw.protocolData,
+                                members: new Map(),
+                                authorizedOperations: raw.authorizedOperations
+                            };
+                            for (const member of raw.members) {
+                                const reader = Reader.from(member.memberMetadata);
+                                const memberMetadata = {
+                                    version: reader.readInt16(),
+                                    topics: reader.readArray(r => r.readString(false), false, false),
+                                    metadata: reader.readBytes(false)
+                                };
+                                reader.reset(member.memberAssignment);
+                                const memberAssignments = reader.readMap(r => {
+                                    const topic = r.readString();
+                                    return [topic, { topic, partitions: reader.readArray(r => r.readInt32(), true, false) }];
+                                }, true, false);
+                                group.members.set(member.memberId, {
+                                    id: member.memberId,
+                                    groupInstanceId: member.groupInstanceId,
+                                    clientId: member.clientId,
+                                    clientHost: member.clientHost,
+                                    metadata: memberMetadata,
+                                    assignments: memberAssignments
+                                });
+                            }
+                            groups.set(group.id, group);
+                        }
+                    }
+                    callback(null, groups);
+                });
+            });
+        });
+    }
+    #deleteGroups(options, callback) {
+        this[kMetadata]({ topics: [] }, (error, metadata) => {
+            if (error) {
+                callback(error);
+                return;
+            }
+            this.#findGroupCoordinator(options.groups, (error, response) => {
+                if (error) {
+                    callback(error);
+                    return;
+                }
+                // Group the groups by coordinator
+                const coordinators = new Map();
+                for (const { key: group, nodeId: node } of response.coordinators) {
+                    let coordinator = coordinators.get(node);
+                    if (!coordinator) {
+                        coordinator = [];
+                        coordinators.set(node, coordinator);
+                    }
+                    coordinator.push(group);
+                }
+                runConcurrentCallbacks('Deleting groups failed.', coordinators, ([node, groups], concurrentCallback) => {
+                    this[kConnections].get(metadata.brokers.get(node), (error, connection) => {
+                        if (error) {
+                            concurrentCallback(error, undefined);
+                            return;
+                        }
+                        this[kPerformWithRetry]('deleteGroups', retryCallback => {
+                            deleteGroupsV2(connection, groups, retryCallback);
+                        }, concurrentCallback, 0);
+                    });
+                }, error => {
+                    callback(error);
+                });
+            });
+        });
+    }
+    #findGroupCoordinator(groups, callback) {
+        this[kPerformWithRetry]('findGroupCoordinator', retryCallback => {
+            this[kConnections].getFirstAvailable(this[kBootstrapBrokers], (error, connection) => {
+                if (error) {
+                    retryCallback(error, undefined);
+                    return;
+                }
+                findCoordinatorV6(connection, FindCoordinatorKeyTypes.GROUP, groups, retryCallback);
+            });
+        }, (error, response) => {
+            if (error) {
+                callback(error, undefined);
+                return;
+            }
+            callback(null, response);
+        }, 0);
+    }
+}

package/dist/clients/admin/index.d.ts

@@ -0,0 +1,3 @@
+export * from './admin.ts';
+export * from './options.ts';
+export * from './types.ts';

package/dist/clients/admin/index.js

@@ -0,0 +1,3 @@
+export * from "./admin.js";
+export * from "./options.js";
+export * from "./types.js";

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

@@ -0,0 +1,135 @@
+export declare const groupsProperties: {
+    groups: {
+        type: string;
+        items: {
+            type: string;
+            pattern: string;
+        };
+        minItems: number;
+    };
+};
+export declare const createTopicOptionsSchema: {
+    type: string;
+    properties: {
+        topics: {
+            type: string;
+            items: {
+                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;
+};
+export declare const deleteTopicOptionsSchema: {
+    type: string;
+    properties: {
+        topics: {
+            type: string;
+            items: {
+                type: string;
+                pattern: string;
+            };
+        };
+    };
+    required: string[];
+    additionalProperties: boolean;
+};
+export declare const listGroupsOptionsSchema: {
+    type: string;
+    properties: {
+        states: {
+            type: string;
+            items: {
+                type: string;
+                enum: readonly ["PREPARING_REBALANCE", "COMPLETING_REBALANCE", "STABLE", "DEAD", "EMPTY"];
+                errorMessage: string;
+            };
+            minItems: number;
+        };
+        types: {
+            type: string;
+            items: {
+                type: string;
+                pattern: string;
+            };
+            minItems: number;
+        };
+    };
+    additionalProperties: boolean;
+};
+export declare const describeGroupsOptionsSchema: {
+    type: string;
+    properties: {
+        includeAuthorizedOperations: {
+            type: string;
+        };
+        groups: {
+            type: string;
+            items: {
+                type: string;
+                pattern: string;
+            };
+            minItems: number;
+        };
+    };
+    required: string[];
+    additionalProperties: boolean;
+};
+export declare const deleteGroupsOptionsSchema: {
+    type: string;
+    properties: {
+        groups: {
+            type: string;
+            items: {
+                type: string;
+                pattern: string;
+            };
+            minItems: number;
+        };
+    };
+    required: string[];
+    additionalProperties: boolean;
+};
+export declare const createTopicsOptionsValidator: import("ajv").ValidateFunction<{
+    [x: string]: {};
+}>;
+export declare const deleteTopicsOptionsValidator: import("ajv").ValidateFunction<{
+    [x: string]: {};
+}>;
+export declare const listGroupsOptionsValidator: import("ajv").ValidateFunction<unknown>;
+export declare const describeGroupsOptionsValidator: import("ajv").ValidateFunction<{
+    [x: string]: {};
+}>;
+export declare const deleteGroupsOptionsValidator: import("ajv").ValidateFunction<{
+    [x: string]: {};
+}>;