kafka-ts 1.3.1-beta.1 → 1.3.1-beta.2

package/dist/api/index.d.ts

@@ -1,6 +1,6 @@
 import { Api } from '../utils/api';
 export declare const API: {
-    API_VERSIONS: Api<unknown, {
+    API_VERSIONS: Api<{}, {
         errorCode: number;
         versions: {
             apiKey: number;
@@ -26,44 +26,42 @@ export declare const API: {
         timeoutMs?: number;
         validateOnly?: boolean;
     }, {
-        _tag: void;
         throttleTimeMs: number;
         topics: {
-            name: string | null;
-            topicId: string;
+            name: string;
+            _topicId: string;
             errorCode: number;
             errorMessage: string | null;
-            numPartitions: number;
-            replicationFactor: number;
+            _numPartitions: number;
+            _replicationFactor: number;
             configs: {
-                name: string | null;
+                name: string;
                 value: string | null;
                 readOnly: boolean;
                 configSource: number;
                 isSensitive: boolean;
-                _tag: void;
+                tags: Record<number, Buffer>;
             }[];
-            _tag: void;
+            tags: Record<number, Buffer>;
         }[];
-        _tag2: void;
+        tags: Record<number, Buffer>;
     }>;
     DELETE_TOPICS: Api<{
         topics: {
-            name: string | null;
+            name: string;
             topicId: string | null;
         }[];
         timeoutMs?: number;
     }, {
-        _tag: void;
         throttleTimeMs: number;
         responses: {
             name: string | null;
-            topicId: string;
+            _topicId: string;
             errorCode: number;
             errorMessage: string | null;
-            _tag: void;
+            tags: Record<number, Buffer>;
         }[];
-        _tag2: void;
+        tags: Record<number, Buffer>;
     }>;
     FETCH: Api<{
         maxWaitMs: number;
@@ -74,6 +72,7 @@ export declare const API: {
         sessionEpoch: number;
         topics: {
             topicId: string;
+            topicName: string;
             partitions: {
                 partition: number;
                 currentLeaderEpoch: number;
@@ -85,80 +84,26 @@ export declare const API: {
         }[];
         forgottenTopicsData: {
             topicId: string;
+            topicName: string;
             partitions: number[];
         }[];
         rackId: string;
-    }, {
-        _tag: void;
-        throttleTimeMs: number;
-        errorCode: number;
-        sessionId: number;
-        responses: {
-            topicId: string;
-            partitions: {
-                partitionIndex: number;
-                errorCode: number;
-                highWatermark: bigint;
-                lastStableOffset: bigint;
-                logStartOffset: bigint;
-                abortedTransactions: {
-                    producerId: bigint;
-                    firstOffset: bigint;
-                    _tag: void;
-                }[];
-                preferredReadReplica: number;
-                records: {
-                    baseOffset: bigint;
-                    batchLength: number;
-                    partitionLeaderEpoch: number;
-                    magic: number;
-                    crc: number;
-                    attributes: number;
-                    compression: number;
-                    timestampType: string;
-                    isTransactional: boolean;
-                    isControlBatch: boolean;
-                    hasDeleteHorizonMs: boolean;
-                    lastOffsetDelta: number;
-                    baseTimestamp: bigint;
-                    maxTimestamp: bigint;
-                    producerId: bigint;
-                    producerEpoch: number;
-                    baseSequence: number;
-                    records: {
-                        attributes: number;
-                        timestampDelta: bigint;
-                        offsetDelta: number;
-                        key: string | null;
-                        value: string | null;
-                        headers: {
-                            key: string;
-                            value: string;
-                        }[];
-                    }[];
-                }[];
-                _tag: void;
-            }[];
-            _tag: void;
-        }[];
-        _tag2: void;
-    }>;
+    }, import("./fetch").FetchResponse>;
     FIND_COORDINATOR: Api<{
         keyType: number;
         keys: string[];
     }, {
-        _tag: void;
         throttleTimeMs: number;
         coordinators: {
-            key: string | null;
+            key: string;
             nodeId: number;
             host: string;
             port: number;
             errorCode: number;
             errorMessage: string | null;
-            _tag: void;
+            tags: Record<number, Buffer>;
         }[];
-        _tag2: void;
+        tags: Record<number, Buffer>;
     }>;
     HEARTBEAT: Api<{
         groupId: string;
@@ -166,10 +111,9 @@ export declare const API: {
         memberId: string;
         groupInstanceId: string | null;
     }, {
-        _tag: void;
         throttleTimeMs: number;
         errorCode: number;
-        _tag2: void;
+        tags: Record<number, Buffer>;
     }>;
     INIT_PRODUCER_ID: Api<{
         transactionalId: string | null;
@@ -177,12 +121,11 @@ export declare const API: {
         producerId: bigint;
         producerEpoch: number;
     }, {
-        _tag: void;
         throttleTimeMs: number;
         errorCode: number;
         producerId: bigint;
         producerEpoch: number;
-        _tag2: void;
+        tags: Record<number, Buffer>;
     }>;
     JOIN_GROUP: Api<{
         groupId: string;
@@ -200,7 +143,6 @@ export declare const API: {
         }[];
         reason: string | null;
     }, {
-        _tag: void;
         throttleTimeMs: number;
         errorCode: number;
         generationId: number;
@@ -212,10 +154,10 @@ export declare const API: {
         members: {
             memberId: string;
             groupInstanceId: string | null;
-            metadata: Buffer<ArrayBufferLike>;
-            _tag: void;
+            metadata: Buffer;
+            tags: Record<number, Buffer>;
         }[];
-        _tag2: void;
+        tags: Record<number, Buffer>;
     }>;
     LEAVE_GROUP: Api<{
         groupId: string;
@@ -225,16 +167,15 @@ export declare const API: {
             reason: string | null;
         }[];
     }, {
-        _tag: void;
         throttleTimeMs: number;
         errorCode: number;
         members: {
             memberId: string;
             groupInstanceId: string | null;
             errorCode: number;
-            _tag: void;
+            tags: Record<number, Buffer>;
         }[];
-        _tag2: void;
+        tags: Record<number, Buffer>;
     }>;
     LIST_OFFSETS: Api<{
         replicaId: number;
@@ -248,7 +189,6 @@ export declare const API: {
             }[];
         }[];
     }, {
-        _tag: void;
         throttleTimeMs: number;
         topics: {
             name: string;
@@ -258,11 +198,11 @@ export declare const API: {
                 timestamp: bigint;
                 offset: bigint;
                 leaderEpoch: number;
-                _tag: void;
+                tags: Record<number, Buffer>;
             }[];
-            _tag: void;
+            tags: Record<number, Buffer>;
         }[];
-        _tag2: void;
+        tags: Record<number, Buffer>;
     }>;
     METADATA: Api<{
         topics?: {
@@ -272,14 +212,12 @@ export declare const API: {
         allowTopicAutoCreation?: boolean;
         includeTopicAuthorizedOperations?: boolean;
     }, {
-        _tag: void;
         throttleTimeMs: number;
         brokers: {
             nodeId: number;
             host: string;
             port: number;
             rack: string | null;
-            _tag: void;
         }[];
         clusterId: string | null;
         controllerId: number;
@@ -296,12 +234,12 @@ export declare const API: {
                 replicaNodes: number[];
                 isrNodes: number[];
                 offlineReplicas: number[];
-                _tag: void;
+                tags: Record<number, Buffer>;
             }[];
             topicAuthorizedOperations: number;
-            _tag: void;
+            tags: Record<number, Buffer>;
         }[];
-        _tag2: void;
+        tags: Record<number, Buffer>;
     }>;
     OFFSET_COMMIT: Api<{
         groupId: string;
@@ -318,18 +256,17 @@ export declare const API: {
             }[];
         }[];
     }, {
-        _tag: void;
         throttleTimeMs: number;
         topics: {
-            name: string | null;
+            name: string;
             partitions: {
                 partitionIndex: number;
                 errorCode: number;
-                _tag: void;
+                tags: Record<number, Buffer>;
             }[];
-            _tag: void;
+            tags: Record<number, Buffer>;
         }[];
-        _tag2: void;
+        tags: Record<number, Buffer>;
     }>;
     OFFSET_FETCH: Api<{
         groups: {
@@ -341,10 +278,9 @@ export declare const API: {
         }[];
         requireStable: boolean;
     }, {
-        _tag: void;
         throttleTimeMs: number;
         groups: {
-            groupId: string | null;
+            groupId: string;
             topics: {
                 name: string;
                 partitions: {
@@ -353,14 +289,14 @@ export declare const API: {
                     committedLeaderEpoch: number;
                     committedMetadata: string | null;
                     errorCode: number;
-                    _tag: void;
+                    tags: Record<number, Buffer>;
                 }[];
-                _tag: void;
+                tags: Record<number, Buffer>;
             }[];
             errorCode: number;
-            _tag: void;
+            tags: Record<number, Buffer>;
         }[];
-        _tag2: void;
+        tags: Record<number, Buffer>;
     }>;
     PRODUCE: Api<{
         transactionalId: string | null;
@@ -393,9 +329,8 @@ export declare const API: {
             }[];
         }[];
     }, {
-        _tag: void;
         responses: {
-            name: string | null;
+            name: string;
             partitionResponses: {
                 index: number;
                 errorCode: number;
@@ -404,32 +339,27 @@ export declare const API: {
                 logStartOffset: bigint;
                 recordErrors: {
                     batchIndex: number;
-                    batchIndexError: number;
-                    _tag: void;
+                    batchIndexErrorMessage: string | null;
                 }[];
                 errorMessage: string | null;
-                _tag: void;
             }[];
-            _tag: void;
         }[];
         throttleTimeMs: number;
-        _tag2: void;
     }>;
     SASL_AUTHENTICATE: Api<{
         authBytes: Buffer;
     }, {
-        _tag: void;
         errorCode: number;
         errorMessage: string | null;
-        authBytes: Buffer<ArrayBufferLike> | null;
+        authBytes: Buffer;
         sessionLifetimeMs: bigint;
-        _tag2: void;
+        tags: Record<number, Buffer>;
     }>;
     SASL_HANDSHAKE: Api<{
         mechanism: string;
     }, {
         errorCode: number;
-        mechanisms: (string | null)[];
+        mechanisms: string[];
     }>;
     SYNC_GROUP: Api<{
         groupId: string;
@@ -440,13 +370,12 @@ export declare const API: {
         protocolName: string | null;
         assignments: import("./sync-group").MemberAssignment[];
     }, {
-        _tag: void;
         throttleTimeMs: number;
         errorCode: number;
         protocolType: string | null;
         protocolName: string | null;
         assignments: import("./sync-group").Assignment;
-        _tag2: void;
+        tags: Record<number, Buffer>;
     }>;
 };
 export declare const getApiName: <Request, Response>(api: Api<Request, Response>) => string;

package/dist/api/init-producer-id.d.ts

@@ -1,13 +1,15 @@
-export declare const INIT_PRODUCER_ID: import("../utils/api").Api<{
+type InitProducerIdRequest = {
     transactionalId: string | null;
     transactionTimeoutMs: number;
     producerId: bigint;
     producerEpoch: number;
-}, {
-    _tag: void;
+};
+type InitProducerIdResponse = {
     throttleTimeMs: number;
     errorCode: number;
     producerId: bigint;
     producerEpoch: number;
-    _tag2: void;
-}>;
+    tags: Record<number, Buffer>;
+};
+export declare const INIT_PRODUCER_ID: import("../utils/api").Api<InitProducerIdRequest, InitProducerIdResponse>;
+export {};

package/dist/api/init-producer-id.js

@@ -3,24 +3,68 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.INIT_PRODUCER_ID = void 0;
 const api_1 = require("../utils/api");
 const error_1 = require("../utils/error");
+/*
+InitProducerId Request (Version: 0) => transactional_id transaction_timeout_ms
+  transactional_id => NULLABLE_STRING
+  transaction_timeout_ms => INT32
+
+InitProducerId Response (Version: 0) => throttle_time_ms error_code producer_id producer_epoch
+  throttle_time_ms => INT32
+  error_code => INT16
+  producer_id => INT64
+  producer_epoch => INT16
+*/
+const INIT_PRODUCER_ID_V0 = (0, api_1.createApi)({
+    apiKey: 22,
+    apiVersion: 0,
+    requestHeaderVersion: 1,
+    responseHeaderVersion: 0,
+    request: (encoder, data) => encoder.writeString(data.transactionalId).writeInt32(data.transactionTimeoutMs),
+    response: (decoder) => {
+        const result = {
+            throttleTimeMs: decoder.readInt32(),
+            errorCode: decoder.readInt16(),
+            producerId: decoder.readInt64(),
+            producerEpoch: decoder.readInt16(),
+            tags: {},
+        };
+        if (result.errorCode)
+            throw new error_1.KafkaTSApiError(result.errorCode, null, result);
+        return result;
+    },
+});
+/*
+InitProducerId Request (Version: 4) => transactional_id transaction_timeout_ms producer_id producer_epoch _tagged_fields
+  transactional_id => COMPACT_NULLABLE_STRING
+  transaction_timeout_ms => INT32
+  producer_id => INT64
+  producer_epoch => INT16
+
+InitProducerId Response (Version: 4) => throttle_time_ms error_code producer_id producer_epoch _tagged_fields
+  throttle_time_ms => INT32
+  error_code => INT16
+  producer_id => INT64
+  producer_epoch => INT16
+*/
 exports.INIT_PRODUCER_ID = (0, api_1.createApi)({
     apiKey: 22,
     apiVersion: 4,
-    request: (encoder, body) => encoder
-        .writeUVarInt(0)
-        .writeCompactString(body.transactionalId)
-        .writeInt32(body.transactionTimeoutMs)
-        .writeInt64(body.producerId)
-        .writeInt16(body.producerEpoch)
-        .writeUVarInt(0),
+    fallback: INIT_PRODUCER_ID_V0,
+    requestHeaderVersion: 2,
+    responseHeaderVersion: 1,
+    request: (encoder, data) => encoder
+        .writeCompactString(data.transactionalId)
+        .writeInt32(data.transactionTimeoutMs)
+        .writeInt64(data.producerId)
+        .writeInt16(data.producerEpoch)
+        .writeTagBuffer(),
     response: (decoder) => {
         const result = {
-            _tag: decoder.readTagBuffer(),
             throttleTimeMs: decoder.readInt32(),
             errorCode: decoder.readInt16(),
             producerId: decoder.readInt64(),
             producerEpoch: decoder.readInt16(),
-            _tag2: decoder.readTagBuffer(),
+            tags: decoder.readTagBuffer(),
         };
         if (result.errorCode)
             throw new error_1.KafkaTSApiError(result.errorCode, null, result);

package/dist/api/join-group.d.ts

@@ -1,4 +1,4 @@
-export declare const JOIN_GROUP: import("../utils/api").Api<{
+type JoinGroupRequest = {
     groupId: string;
     sessionTimeoutMs: number;
     rebalanceTimeoutMs: number;
@@ -13,8 +13,8 @@ export declare const JOIN_GROUP: import("../utils/api").Api<{
         };
     }[];
     reason: string | null;
-}, {
-    _tag: void;
+};
+type JoinGroupResponse = {
     throttleTimeMs: number;
     errorCode: number;
     generationId: number;
@@ -26,8 +26,10 @@ export declare const JOIN_GROUP: import("../utils/api").Api<{
     members: {
         memberId: string;
         groupInstanceId: string | null;
-        metadata: Buffer<ArrayBufferLike>;
-        _tag: void;
+        metadata: Buffer;
+        tags: Record<number, Buffer>;
     }[];
-    _tag2: void;
-}>;
+    tags: Record<number, Buffer>;
+};
+export declare const JOIN_GROUP: import("../utils/api").Api<JoinGroupRequest, JoinGroupResponse>;
+export {};

package/dist/api/join-group.js

@@ -4,11 +4,101 @@ exports.JOIN_GROUP = void 0;
 const api_1 = require("../utils/api");
 const encoder_1 = require("../utils/encoder");
 const error_1 = require("../utils/error");
+/*
+JoinGroup Request (Version: 0) => group_id session_timeout_ms member_id protocol_type [protocols]
+  group_id => STRING
+  session_timeout_ms => INT32
+  member_id => STRING
+  protocol_type => STRING
+  protocols => name metadata
+    name => STRING
+    metadata => BYTES
+
+JoinGroup Response (Version: 0) => error_code generation_id protocol_name leader member_id [members]
+  error_code => INT16
+  generation_id => INT32
+  protocol_name => STRING
+  leader => STRING
+  member_id => STRING
+  members => member_id metadata
+    member_id => STRING
+    metadata => BYTES
+*/
+const JOIN_GROUP_V0 = (0, api_1.createApi)({
+    apiKey: 11,
+    apiVersion: 0,
+    requestHeaderVersion: 1,
+    responseHeaderVersion: 0,
+    request: (encoder, data) => encoder
+        .writeString(data.groupId)
+        .writeInt32(data.sessionTimeoutMs)
+        .writeString(data.memberId)
+        .writeString(data.protocolType)
+        .writeArray(data.protocols, (encoder, protocol) => {
+        const metadata = new encoder_1.Encoder()
+            .writeInt16(protocol.metadata.version)
+            .writeArray(protocol.metadata.topics, (encoder, topic) => encoder.writeString(topic))
+            .writeBytes(Buffer.alloc(0))
+            .value();
+        return encoder.writeString(protocol.name).writeBytes(metadata);
+    }),
+    response: (decoder) => {
+        const result = {
+            throttleTimeMs: 0,
+            errorCode: decoder.readInt16(),
+            generationId: decoder.readInt32(),
+            protocolType: null,
+            protocolName: decoder.readString(),
+            leader: decoder.readString(),
+            skipAssignment: false,
+            memberId: decoder.readString(),
+            members: decoder.readArray((decoder) => ({
+                memberId: decoder.readString(),
+                groupInstanceId: null,
+                metadata: decoder.readBytes(),
+                tags: {},
+            })),
+            tags: {},
+        };
+        if (result.errorCode)
+            throw new error_1.KafkaTSApiError(result.errorCode, null, result);
+        return result;
+    },
+});
+/*
+JoinGroup Request (Version: 9) => group_id session_timeout_ms rebalance_timeout_ms member_id group_instance_id protocol_type [protocols] reason _tagged_fields
+  group_id => COMPACT_STRING
+  session_timeout_ms => INT32
+  rebalance_timeout_ms => INT32
+  member_id => COMPACT_STRING
+  group_instance_id => COMPACT_NULLABLE_STRING
+  protocol_type => COMPACT_STRING
+  protocols => name metadata _tagged_fields
+    name => COMPACT_STRING
+    metadata => COMPACT_BYTES
+  reason => COMPACT_NULLABLE_STRING
+
+JoinGroup Response (Version: 9) => throttle_time_ms error_code generation_id protocol_type protocol_name leader skip_assignment member_id [members] _tagged_fields
+  throttle_time_ms => INT32
+  error_code => INT16
+  generation_id => INT32
+  protocol_type => COMPACT_NULLABLE_STRING
+  protocol_name => COMPACT_NULLABLE_STRING
+  leader => COMPACT_STRING
+  skip_assignment => BOOLEAN
+  member_id => COMPACT_STRING
+  members => member_id group_instance_id metadata _tagged_fields
+    member_id => COMPACT_STRING
+    group_instance_id => COMPACT_NULLABLE_STRING
+    metadata => COMPACT_BYTES
+*/
 exports.JOIN_GROUP = (0, api_1.createApi)({
     apiKey: 11,
     apiVersion: 9,
+    fallback: JOIN_GROUP_V0,
+    requestHeaderVersion: 2,
+    responseHeaderVersion: 1,
     request: (encoder, data) => encoder
-        .writeUVarInt(0)
         .writeCompactString(data.groupId)
         .writeInt32(data.sessionTimeoutMs)
         .writeInt32(data.rebalanceTimeoutMs)
@@ -21,13 +111,12 @@ exports.JOIN_GROUP = (0, api_1.createApi)({
             .writeArray(protocol.metadata.topics, (encoder, topic) => encoder.writeString(topic))
             .writeBytes(Buffer.alloc(0))
             .value();
-        return encoder.writeCompactString(protocol.name).writeCompactBytes(metadata).writeUVarInt(0);
+        return encoder.writeCompactString(protocol.name).writeCompactBytes(metadata).writeTagBuffer();
     })
         .writeCompactString(data.reason)
-        .writeUVarInt(0),
+        .writeTagBuffer(),
     response: (decoder) => {
         const result = {
-            _tag: decoder.readTagBuffer(),
             throttleTimeMs: decoder.readInt32(),
             errorCode: decoder.readInt16(),
             generationId: decoder.readInt32(),
@@ -40,9 +129,9 @@ exports.JOIN_GROUP = (0, api_1.createApi)({
                 memberId: decoder.readCompactString(),
                 groupInstanceId: decoder.readCompactString(),
                 metadata: decoder.readCompactBytes(),
-                _tag: decoder.readTagBuffer(),
+                tags: decoder.readTagBuffer(),
             })),
-            _tag2: decoder.readTagBuffer(),
+            tags: decoder.readTagBuffer(),
         };
         if (result.errorCode)
             throw new error_1.KafkaTSApiError(result.errorCode, null, result);

package/dist/api/leave-group.d.ts

@@ -1,19 +1,21 @@
-export declare const LEAVE_GROUP: import("../utils/api").Api<{
+type LeaveGroupRequest = {
     groupId: string;
     members: {
         memberId: string;
         groupInstanceId: string | null;
         reason: string | null;
     }[];
-}, {
-    _tag: void;
+};
+type LeaveGroupResponse = {
     throttleTimeMs: number;
     errorCode: number;
     members: {
         memberId: string;
         groupInstanceId: string | null;
         errorCode: number;
-        _tag: void;
+        tags: Record<number, Buffer>;
     }[];
-    _tag2: void;
-}>;
+    tags: Record<number, Buffer>;
+};
+export declare const LEAVE_GROUP: import("../utils/api").Api<LeaveGroupRequest, LeaveGroupResponse>;
+export {};