@platformatic/kafka 1.4.0 → 1.5.0

package/README.md

@@ -13,6 +13,10 @@ A modern, high-performance, pure TypeScript/JavaScript type safe client for Apac
 - **Connection Management**: Automatic connection pooling and recovery.
 - **Low Dependencies**: Minimal external dependencies.
 
+## Supported Kafka Version
+
+Supported Kafka version are from **3.5.0** to **4.0.0** and equivalent, edges included.
+
 ## Installation
 
 ```bash

package/dist/apis/consumer/fetch-v15.d.ts

@@ -0,0 +1,46 @@
+import { Reader } from '../../protocol/reader.ts';
+import { type RecordsBatch } from '../../protocol/records.ts';
+import { Writer } from '../../protocol/writer.ts';
+export interface FetchRequestPartition {
+    partition: number;
+    currentLeaderEpoch: number;
+    fetchOffset: bigint;
+    lastFetchedEpoch: number;
+    partitionMaxBytes: number;
+}
+export interface FetchRequestTopic {
+    topicId: string;
+    partitions: FetchRequestPartition[];
+}
+export interface FetchRequestForgottenTopicsData {
+    topic: string;
+    partitions: number[];
+}
+export type FetchRequest = Parameters<typeof createRequest>;
+export interface FetchResponsePartitionAbortedTransaction {
+    producerId: bigint;
+    firstOffset: bigint;
+}
+export interface FetchResponsePartition {
+    partitionIndex: number;
+    errorCode: number;
+    highWatermark: bigint;
+    lastStableOffset: bigint;
+    logStartOffset: bigint;
+    abortedTransactions: FetchResponsePartitionAbortedTransaction[];
+    preferredReadReplica: number;
+    records?: RecordsBatch;
+}
+export interface FetchResponseTopic {
+    topicId: string;
+    partitions: FetchResponsePartition[];
+}
+export type FetchResponse = {
+    throttleTimeMs: number;
+    errorCode: number;
+    sessionId: number;
+    responses: FetchResponseTopic[];
+};
+export declare function createRequest(maxWaitMs: number, minBytes: number, maxBytes: number, isolationLevel: number, sessionId: number, sessionEpoch: number, topics: FetchRequestTopic[], forgottenTopicsData: FetchRequestForgottenTopicsData[], rackId: string): Writer;
+export declare function parseResponse(_correlationId: number, apiKey: number, apiVersion: number, reader: Reader): FetchResponse;
+export declare const api: import("../definitions.ts").API<[maxWaitMs: number, minBytes: number, maxBytes: number, isolationLevel: number, sessionId: number, sessionEpoch: number, topics: FetchRequestTopic[], forgottenTopicsData: FetchRequestForgottenTopicsData[], rackId: string], FetchResponse>;

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

@@ -0,0 +1,121 @@
+import { ResponseError } from "../../errors.js";
+import { Reader } from "../../protocol/reader.js";
+import { readRecordsBatch } from "../../protocol/records.js";
+import { Writer } from "../../protocol/writer.js";
+import { createAPI } from "../definitions.js";
+/*
+  Fetch Request (Version: 15) => max_wait_ms min_bytes max_bytes isolation_level session_id session_epoch [topics] [forgotten_topics_data] rack_id TAG_BUFFER
+  max_wait_ms => INT32
+  min_bytes => INT32
+  max_bytes => INT32
+  isolation_level => INT8
+  session_id => INT32
+  session_epoch => INT32
+  topics => topic_id [partitions] TAG_BUFFER
+    topic_id => UUID
+    partitions => partition current_leader_epoch fetch_offset last_fetched_epoch log_start_offset partition_max_bytes TAG_BUFFER
+      partition => INT32
+      current_leader_epoch => INT32
+      fetch_offset => INT64
+      last_fetched_epoch => INT32
+      log_start_offset => INT64
+      partition_max_bytes => INT32
+  forgotten_topics_data => topic_id [partitions] TAG_BUFFER
+    topic_id => UUID
+    partitions => INT32
+  rack_id => COMPACT_STRING
+*/
+export function createRequest(maxWaitMs, minBytes, maxBytes, isolationLevel, sessionId, sessionEpoch, topics, forgottenTopicsData, rackId) {
+    return Writer.create()
+        .appendInt32(maxWaitMs)
+        .appendInt32(minBytes)
+        .appendInt32(maxBytes)
+        .appendInt8(isolationLevel)
+        .appendInt32(sessionId)
+        .appendInt32(sessionEpoch)
+        .appendArray(topics, (w, t) => {
+        w.appendUUID(t.topicId).appendArray(t.partitions, (w, p) => {
+            w.appendInt32(p.partition)
+                .appendInt32(p.currentLeaderEpoch)
+                .appendInt64(p.fetchOffset)
+                .appendInt32(p.lastFetchedEpoch)
+                .appendInt64(-1n)
+                .appendInt32(p.partitionMaxBytes);
+        });
+    })
+        .appendArray(forgottenTopicsData, (w, t) => {
+        w.appendUUID(t.topic).appendArray(t.partitions, (w, p) => {
+            w.appendInt32(p);
+        }, true, false);
+    })
+        .appendString(rackId)
+        .appendTaggedFields();
+}
+/*
+  Fetch Response (Version: 15) => throttle_time_ms error_code session_id [responses] TAG_BUFFER
+    throttle_time_ms => INT32
+    error_code => INT16
+    session_id => INT32
+    responses => topic_id [partitions] TAG_BUFFER
+      topic_id => UUID
+      partitions => partition_index error_code high_watermark last_stable_offset log_start_offset [aborted_transactions] preferred_read_replica records TAG_BUFFER
+        partition_index => INT32
+        error_code => INT16
+        high_watermark => INT64
+        last_stable_offset => INT64
+        log_start_offset => INT64
+        aborted_transactions => producer_id first_offset TAG_BUFFER
+          producer_id => INT64
+          first_offset => INT64
+        preferred_read_replica => INT32
+        records => COMPACT_RECORDS
+*/
+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,
+        sessionId: reader.readInt32(),
+        responses: reader.readArray((r, i) => {
+            return {
+                topicId: r.readUUID(),
+                partitions: r.readArray((r, j) => {
+                    const partition = {
+                        partitionIndex: r.readInt32(),
+                        errorCode: r.readInt16(),
+                        highWatermark: r.readInt64(),
+                        lastStableOffset: r.readInt64(),
+                        logStartOffset: r.readInt64(),
+                        abortedTransactions: r.readArray(r => {
+                            return {
+                                producerId: r.readInt64(),
+                                firstOffset: r.readInt64()
+                            };
+                        }),
+                        preferredReadReplica: r.readInt32()
+                    };
+                    let recordsSize = r.readUnsignedVarInt();
+                    if (partition.errorCode !== 0) {
+                        errors.push([`/responses/${i}/partitions/${j}`, partition.errorCode]);
+                    }
+                    if (recordsSize > 1) {
+                        recordsSize--;
+                        partition.records = readRecordsBatch(Reader.from(r.buffer.subarray(r.position, r.position + recordsSize)));
+                        r.skip(recordsSize);
+                    }
+                    return partition;
+                })
+            };
+        })
+    };
+    if (errors.length) {
+        throw new ResponseError(apiKey, apiVersion, Object.fromEntries(errors), response);
+    }
+    return response;
+}
+export const api = createAPI(1, 15, createRequest, parseResponse);

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

@@ -1,4 +1,5 @@
 export * as consumerGroupHeartbeatV0 from './consumer-group-heartbeat-v0.ts';
+export * as fetchV15 from './fetch-v15.ts';
 export * as fetchV16 from './fetch-v16.ts';
 export * as fetchV17 from './fetch-v17.ts';
 export * as heartbeatV4 from './heartbeat-v4.ts';
@@ -6,6 +7,8 @@ export * as joinGroupV9 from './join-group-v9.ts';
 export * as leaveGroupV5 from './leave-group-v5.ts';
 export * as listOffsetsV8 from './list-offsets-v8.ts';
 export * as listOffsetsV9 from './list-offsets-v9.ts';
+export * as offsetCommitV8 from './offset-commit-v8.ts';
 export * as offsetCommitV9 from './offset-commit-v9.ts';
+export * as offsetFetchV8 from './offset-fetch-v8.ts';
 export * as offsetFetchV9 from './offset-fetch-v9.ts';
 export * as syncGroupV5 from './sync-group-v5.ts';

package/dist/apis/consumer/index.js

@@ -1,4 +1,5 @@
 export * as consumerGroupHeartbeatV0 from "./consumer-group-heartbeat-v0.js";
+export * as fetchV15 from "./fetch-v15.js";
 export * as fetchV16 from "./fetch-v16.js";
 export * as fetchV17 from "./fetch-v17.js";
 export * as heartbeatV4 from "./heartbeat-v4.js";
@@ -6,6 +7,8 @@ export * as joinGroupV9 from "./join-group-v9.js";
 export * as leaveGroupV5 from "./leave-group-v5.js";
 export * as listOffsetsV8 from "./list-offsets-v8.js";
 export * as listOffsetsV9 from "./list-offsets-v9.js";
+export * as offsetCommitV8 from "./offset-commit-v8.js";
 export * as offsetCommitV9 from "./offset-commit-v9.js";
+export * as offsetFetchV8 from "./offset-fetch-v8.js";
 export * as offsetFetchV9 from "./offset-fetch-v9.js";
 export * as syncGroupV5 from "./sync-group-v5.js";

package/dist/apis/consumer/offset-commit-v8.d.ts

@@ -0,0 +1,29 @@
+import { type NullableString } from '../../protocol/definitions.ts';
+import { type Reader } from '../../protocol/reader.ts';
+import { Writer } from '../../protocol/writer.ts';
+export interface OffsetCommitRequestPartition {
+    partitionIndex: number;
+    committedOffset: bigint;
+    committedLeaderEpoch: number;
+    committedMetadata?: NullableString;
+}
+export interface OffsetCommitRequestTopic {
+    name: string;
+    partitions: OffsetCommitRequestPartition[];
+}
+export type OffsetCommitRequest = Parameters<typeof createRequest>;
+export interface OffsetCommitResponsePartition {
+    partitionIndex: number;
+    errorCode: number;
+}
+export interface OffsetCommitResponseTopic {
+    name: string;
+    partitions: OffsetCommitResponsePartition[];
+}
+export interface OffsetCommitResponse {
+    throttleTimeMs: number;
+    topics: OffsetCommitResponseTopic[];
+}
+export declare function createRequest(groupId: string, generationIdOrMemberEpoch: number, memberId: string, groupInstanceId: NullableString, topics: OffsetCommitRequestTopic[]): Writer;
+export declare function parseResponse(_correlationId: number, apiKey: number, apiVersion: number, reader: Reader): OffsetCommitResponse;
+export declare const api: import("../definitions.ts").API<[groupId: string, generationIdOrMemberEpoch: number, memberId: string, groupInstanceId: NullableString, topics: OffsetCommitRequestTopic[]], OffsetCommitResponse>;

package/dist/apis/consumer/offset-commit-v8.js

@@ -0,0 +1,68 @@
+import { ResponseError } from "../../errors.js";
+import { Writer } from "../../protocol/writer.js";
+import { createAPI } from "../definitions.js";
+/*
+  OffsetCommit Request (Version: 8) => group_id generation_id_or_member_epoch member_id group_instance_id [topics] TAG_BUFFER
+    group_id => COMPACT_STRING
+    generation_id_or_member_epoch => INT32
+    member_id => COMPACT_STRING
+    group_instance_id => COMPACT_NULLABLE_STRING
+    topics => name [partitions] TAG_BUFFER
+      name => COMPACT_STRING
+      partitions => partition_index committed_offset committed_leader_epoch committed_metadata TAG_BUFFER
+        partition_index => INT32
+        committed_offset => INT64
+        committed_leader_epoch => INT32
+        committed_metadata => COMPACT_NULLABLE_STRING
+*/
+export function createRequest(groupId, generationIdOrMemberEpoch, memberId, groupInstanceId, topics) {
+    return Writer.create()
+        .appendString(groupId)
+        .appendInt32(generationIdOrMemberEpoch)
+        .appendString(memberId)
+        .appendString(groupInstanceId)
+        .appendArray(topics, (w, t) => {
+        w.appendString(t.name).appendArray(t.partitions, (w, p) => {
+            w.appendInt32(p.partitionIndex)
+                .appendInt64(p.committedOffset)
+                .appendInt32(p.committedLeaderEpoch)
+                .appendString(p.committedMetadata);
+        });
+    })
+        .appendTaggedFields();
+}
+/*
+  OffsetCommit Response (Version: 8) => throttle_time_ms [topics] TAG_BUFFER
+    throttle_time_ms => INT32
+    topics => name [partitions] TAG_BUFFER
+      name => COMPACT_STRING
+      partitions => partition_index error_code TAG_BUFFER
+        partition_index => INT32
+        error_code => INT16
+*/
+export function parseResponse(_correlationId, apiKey, apiVersion, reader) {
+    const errors = [];
+    const response = {
+        throttleTimeMs: reader.readInt32(),
+        topics: reader.readArray((r, i) => {
+            return {
+                name: r.readString(),
+                partitions: r.readArray((r, j) => {
+                    const partition = {
+                        partitionIndex: r.readInt32(),
+                        errorCode: r.readInt16()
+                    };
+                    if (partition.errorCode !== 0) {
+                        errors.push([`/topics/${i}/partitions/${j}`, partition.errorCode]);
+                    }
+                    return partition;
+                })
+            };
+        })
+    };
+    if (errors.length) {
+        throw new ResponseError(apiKey, apiVersion, Object.fromEntries(errors), response);
+    }
+    return response;
+}
+export const api = createAPI(8, 8, createRequest, parseResponse);

package/dist/apis/consumer/offset-fetch-v8.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 interface OffsetFetchRequestTopic {
+    name: string;
+    partitionIndexes: number[];
+}
+export interface OffsetFetchRequestGroup {
+    groupId: string;
+    memberId?: NullableString;
+    memberEpoch: number;
+    topics: OffsetFetchRequestTopic[];
+}
+export type OffsetFetchRequest = Parameters<typeof createRequest>;
+export interface OffsetFetchResponsePartition {
+    partitionIndex: number;
+    committedOffset: bigint;
+    committedLeaderEpoch: number;
+    metadata: NullableString;
+    errorCode: number;
+}
+export interface OffsetFetchResponseTopic {
+    name: string;
+    partitions: OffsetFetchResponsePartition[];
+}
+export interface OffsetFetchResponseGroup {
+    groupId: string;
+    topics: OffsetFetchResponseTopic[];
+    errorCode: number;
+}
+export interface OffsetFetchResponse {
+    throttleTimeMs: number;
+    groups: OffsetFetchResponseGroup[];
+}
+export declare function createRequest(groups: OffsetFetchRequestGroup[], requireStable: boolean): Writer;
+export declare function parseResponse(_correlationId: number, apiKey: number, apiVersion: number, reader: Reader): OffsetFetchResponse;
+export declare const api: import("../definitions.ts").API<[groups: OffsetFetchRequestGroup[], requireStable: boolean], OffsetFetchResponse>;

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

@@ -0,0 +1,78 @@
+import { ResponseError } from "../../errors.js";
+import { Writer } from "../../protocol/writer.js";
+import { createAPI } from "../definitions.js";
+/*
+  OffsetFetch Request (Version: 8) => [groups] require_stable TAG_BUFFER
+    groups => group_id member_id member_epoch [topics] TAG_BUFFER
+      group_id => COMPACT_STRING
+      topics => name [partition_indexes] TAG_BUFFER
+        name => COMPACT_STRING
+        partition_indexes => INT32
+    require_stable => BOOLEAN
+
+  Note that OffsetFetchRequestGroup contains a memberId and memberEpoch fields, which is not used in version 8.
+*/
+export function createRequest(groups, requireStable) {
+    return Writer.create()
+        .appendArray(groups, (w, g) => {
+        w.appendString(g.groupId).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: 8) => 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, 8, createRequest, parseResponse);

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

@@ -5,4 +5,5 @@ export * as initProducerIdV4 from './init-producer-id-v4.ts';
 export * as initProducerIdV5 from './init-producer-id-v5.ts';
 export * as produceV10 from './produce-v10.ts';
 export * as produceV11 from './produce-v11.ts';
+export * as produceV9 from './produce-v9.ts';
 export * as txnOffsetCommitV4 from './txn-offset-commit-v4.ts';

package/dist/apis/producer/index.js

@@ -5,4 +5,5 @@ export * as initProducerIdV4 from "./init-producer-id-v4.js";
 export * as initProducerIdV5 from "./init-producer-id-v5.js";
 export * as produceV10 from "./produce-v10.js";
 export * as produceV11 from "./produce-v11.js";
+export * as produceV9 from "./produce-v9.js";
 export * as txnOffsetCommitV4 from "./txn-offset-commit-v4.js";

package/dist/apis/producer/produce-v9.d.ts

@@ -0,0 +1,29 @@
+import { type NullableString } from '../../protocol/definitions.ts';
+import { type Reader } from '../../protocol/reader.ts';
+import { type CreateRecordsBatchOptions, type MessageRecord } from '../../protocol/records.ts';
+import { Writer } from '../../protocol/writer.ts';
+export type ProduceRequest = Parameters<typeof createRequest>;
+export interface ProduceResponsePartitionRecordError {
+    batchIndex: number;
+    batchIndexErrorMessage: NullableString;
+}
+export interface ProduceResponsePartition {
+    index: number;
+    errorCode: number;
+    baseOffset: bigint;
+    logAppendTimeMs: bigint;
+    logStartOffset: bigint;
+    recordErrors: ProduceResponsePartitionRecordError[];
+    errorMessage: NullableString;
+}
+export interface ProduceResponseTopic {
+    name: string;
+    partitionResponses: ProduceResponsePartition[];
+}
+export interface ProduceResponse {
+    responses: ProduceResponseTopic[];
+    throttleTimeMs: number;
+}
+export declare function createRequest(acks: number | undefined, timeout: number | undefined, topicData: MessageRecord[], options?: Partial<CreateRecordsBatchOptions>): Writer;
+export declare function parseResponse(_correlationId: number, apiKey: number, apiVersion: number, reader: Reader): ProduceResponse;
+export declare const api: import("../definitions.ts").API<[acks: number | undefined, timeout: number | undefined, topicData: MessageRecord[], options?: Partial<CreateRecordsBatchOptions> | undefined], boolean | ProduceResponse>;

package/dist/apis/producer/produce-v9.js

@@ -0,0 +1,104 @@
+import { ResponseError } from "../../errors.js";
+import { createRecordsBatch } from "../../protocol/records.js";
+import { Writer } from "../../protocol/writer.js";
+import { groupByProperty } from "../../utils.js";
+import { createAPI } from "../definitions.js";
+import { ProduceAcks } from "../enumerations.js";
+/*
+  Produce Request (Version: 9) => transactional_id acks timeout_ms [topic_data] TAG_BUFFER
+    transactional_id => COMPACT_NULLABLE_STRING
+    acks => INT16
+    timeout_ms => INT32
+    topic_data => name [partition_data] TAG_BUFFER
+      name => COMPACT_STRING
+      partition_data => index records TAG_BUFFER
+        index => INT32
+        records => COMPACT_RECORDS
+*/
+export function createRequest(acks = 1, timeout = 0, topicData, options = {}) {
+    // Normalize the messages
+    const now = BigInt(Date.now());
+    for (const message of topicData) {
+        if (typeof message.partition === 'undefined') {
+            message.partition = 0;
+        }
+        if (typeof message.timestamp === 'undefined') {
+            message.timestamp = now;
+        }
+    }
+    const writer = Writer.create()
+        .appendString(options.transactionalId)
+        .appendInt16(acks)
+        .appendInt32(timeout)
+        .appendArray(groupByProperty(topicData, 'topic'), (w, [topic, messages]) => {
+        w.appendString(topic).appendArray(groupByProperty(messages, 'partition'), (w, [partition, messages]) => {
+            const records = createRecordsBatch(messages, options);
+            w.appendInt32(partition)
+                .appendUnsignedVarInt(records.length + 1)
+                .appendFrom(records);
+        });
+    })
+        .appendTaggedFields();
+    if (acks === ProduceAcks.NO_RESPONSE) {
+        writer.context.noResponse = true;
+    }
+    return writer;
+}
+/*
+  Produce Response (Version: 9) => [responses] throttle_time_ms TAG_BUFFER
+    responses => name [partition_responses] TAG_BUFFER
+      name => COMPACT_STRING
+      partition_responses => index error_code base_offset log_append_time_ms log_start_offset [record_errors] error_message TAG_BUFFER
+        index => INT32
+        error_code => INT16
+        base_offset => INT64
+        log_append_time_ms => INT64
+        log_start_offset => INT64
+        record_errors => batch_index batch_index_error_message TAG_BUFFER
+          batch_index => INT32
+          batch_index_error_message => COMPACT_NULLABLE_STRING
+        error_message => COMPACT_NULLABLE_STRING
+    throttle_time_ms => INT32
+*/
+export function parseResponse(_correlationId, apiKey, apiVersion, reader) {
+    const errors = [];
+    const response = {
+        responses: reader.readArray((r, i) => {
+            const topicResponse = {
+                name: r.readString(),
+                partitionResponses: r.readArray((r, j) => {
+                    const index = r.readInt32();
+                    const errorCode = r.readInt16();
+                    if (errorCode !== 0) {
+                        errors.push([`/responses/${i}/partition_responses/${j}`, errorCode]);
+                    }
+                    return {
+                        index,
+                        errorCode,
+                        baseOffset: r.readInt64(),
+                        logAppendTimeMs: r.readInt64(),
+                        logStartOffset: r.readInt64(),
+                        recordErrors: r.readArray((r, k) => {
+                            const recordError = {
+                                batchIndex: r.readInt32(),
+                                batchIndexErrorMessage: r.readNullableString()
+                            };
+                            if (recordError.batchIndexErrorMessage) {
+                                errors.push([`/responses/${i}/partition_responses/${j}/record_errors/${k}`, -1]);
+                            }
+                            return recordError;
+                        }),
+                        errorMessage: r.readNullableString()
+                    };
+                })
+            };
+            return topicResponse;
+        }),
+        throttleTimeMs: reader.readInt32()
+    };
+    if (errors.length) {
+        throw new ResponseError(apiKey, apiVersion, Object.fromEntries(errors), response);
+    }
+    return response;
+}
+export const api = createAPI(0, 9, createRequest, parseResponse);

package/dist/utils.d.ts

@@ -22,4 +22,3 @@ export declare function groupByProperty<Key, Value>(entries: Value[], property:
 export declare function humanize(label: string, buffer: Buffer | DynamicBuffer): string;
 export declare function setDebugDumpLogger(logger: DebugDumpLogger): void;
 export declare function debugDump(...values: unknown[]): void;
-export declare function executeWithTimeout<T = unknown>(promise: Promise<T>, timeout: number, timeoutValue?: string): Promise<T | string>;

package/dist/utils.js

@@ -1,8 +1,6 @@
-import { Unpromise } from '@watchable/unpromise';
 import ajvErrors from 'ajv-errors';
 import { Ajv2020 } from 'ajv/dist/2020.js';
 import debug from 'debug';
-import { setTimeout as sleep } from 'node:timers/promises';
 import { inspect } from 'node:util';
 export { setTimeout as sleep } from 'node:timers/promises';
 export const ajv = new Ajv2020({ allErrors: true, coerceTypes: false, strict: true });
@@ -142,10 +140,3 @@ export function setDebugDumpLogger(logger) {
 export function debugDump(...values) {
     debugDumpLogger(new Date().toISOString(), ...values.map(v => (typeof v === 'string' ? v : inspect(v, false, 10))));
 }
-export async function executeWithTimeout(promise, timeout, timeoutValue = 'timeout') {
-    const ac = new AbortController();
-    return Unpromise.race([promise, sleep(timeout, timeoutValue, { signal: ac.signal, ref: false })]).then((value) => {
-        ac.abort();
-        return value;
-    });
-}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@platformatic/kafka",
-  "version": "1.4.0",
+  "version": "1.5.0",
   "description": "Modern and performant client for Apache Kafka",
   "homepage": "https://github.com/platformatic/kafka",
   "author": "Platformatic Inc. <oss@platformatic.dev> (https://platformatic.dev)",
@@ -25,7 +25,6 @@
   "exports": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "dependencies": {
-    "@watchable/unpromise": "^1.0.2",
     "ajv": "^8.17.1",
     "ajv-errors": "^3.0.0",
     "debug": "^4.4.0",
@@ -42,6 +41,7 @@
     "@types/debug": "^4.1.12",
     "@types/node": "^22.13.5",
     "@types/semver": "^7.7.0",
+    "@watchable/unpromise": "^1.0.2",
     "c8": "^10.1.3",
     "cleaner-spec-reporter": "^0.5.0",
     "cronometro": "^5.3.0",
@@ -55,6 +55,7 @@
     "prettier": "^3.5.3",
     "prom-client": "^15.1.3",
     "semver": "^7.7.1",
+    "table": "^6.9.0",
     "typescript": "^5.7.3"
   },
   "engines": {