kafka-ts 0.0.3-beta → 0.0.4

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

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.INIT_PRODUCER_ID = void 0;
+const api_1 = require("../utils/api");
+const error_1 = require("../utils/error");
+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),
+    response: (decoder) => {
+        const result = {
+            _tag: decoder.readTagBuffer(),
+            throttleTimeMs: decoder.readInt32(),
+            errorCode: decoder.readInt16(),
+            producerId: decoder.readInt64(),
+            producerEpoch: decoder.readInt16(),
+            _tag2: decoder.readTagBuffer(),
+        };
+        if (result.errorCode)
+            throw new error_1.KafkaTSApiError(result.errorCode, null, result);
+        return result;
+    },
+});

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

@@ -0,0 +1,34 @@
+/// <reference types="node" />
+export declare const JOIN_GROUP: import("../utils/api").Api<{
+    groupId: string;
+    sessionTimeoutMs: number;
+    rebalanceTimeoutMs: number;
+    memberId: string;
+    groupInstanceId: string | null;
+    protocolType: string;
+    protocols: {
+        name: string;
+        metadata: {
+            version: number;
+            topics: string[];
+        };
+    }[];
+    reason: string | null;
+}, {
+    _tag: void;
+    throttleTimeMs: number;
+    errorCode: number;
+    generationId: number;
+    protocolType: string | null;
+    protocolName: string | null;
+    leader: string;
+    skipAssignment: boolean;
+    memberId: string;
+    members: {
+        memberId: string;
+        groupInstanceId: string | null;
+        metadata: Buffer;
+        _tag: void;
+    }[];
+    _tag2: void;
+}>;

package/dist/api/join-group.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JOIN_GROUP = void 0;
+const api_1 = require("../utils/api");
+const encoder_1 = require("../utils/encoder");
+const error_1 = require("../utils/error");
+exports.JOIN_GROUP = (0, api_1.createApi)({
+    apiKey: 11,
+    apiVersion: 9,
+    request: (encoder, data) => encoder
+        .writeUVarInt(0)
+        .writeCompactString(data.groupId)
+        .writeInt32(data.sessionTimeoutMs)
+        .writeInt32(data.rebalanceTimeoutMs)
+        .writeCompactString(data.memberId)
+        .writeCompactString(data.groupInstanceId)
+        .writeCompactString(data.protocolType)
+        .writeCompactArray(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.writeCompactString(protocol.name).writeCompactBytes(metadata).writeUVarInt(0);
+    })
+        .writeCompactString(data.reason)
+        .writeUVarInt(0),
+    response: (decoder) => {
+        const result = {
+            _tag: decoder.readTagBuffer(),
+            throttleTimeMs: decoder.readInt32(),
+            errorCode: decoder.readInt16(),
+            generationId: decoder.readInt32(),
+            protocolType: decoder.readCompactString(),
+            protocolName: decoder.readCompactString(),
+            leader: decoder.readCompactString(),
+            skipAssignment: decoder.readBoolean(),
+            memberId: decoder.readCompactString(),
+            members: decoder.readCompactArray((decoder) => ({
+                memberId: decoder.readCompactString(),
+                groupInstanceId: decoder.readCompactString(),
+                metadata: decoder.readCompactBytes(),
+                _tag: decoder.readTagBuffer(),
+            })),
+            _tag2: decoder.readTagBuffer(),
+        };
+        if (result.errorCode)
+            throw new error_1.KafkaTSApiError(result.errorCode, null, result);
+        return result;
+    },
+});

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

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

package/dist/api/leave-group.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LEAVE_GROUP = void 0;
+const api_1 = require("../utils/api");
+const error_1 = require("../utils/error");
+exports.LEAVE_GROUP = (0, api_1.createApi)({
+    apiKey: 13,
+    apiVersion: 5,
+    request: (encoder, body) => encoder
+        .writeUVarInt(0)
+        .writeCompactString(body.groupId)
+        .writeCompactArray(body.members, (encoder, member) => encoder
+        .writeCompactString(member.memberId)
+        .writeCompactString(member.groupInstanceId)
+        .writeCompactString(member.reason)
+        .writeUVarInt(0))
+        .writeUVarInt(0),
+    response: (decoder) => {
+        const result = {
+            _tag: decoder.readTagBuffer(),
+            throttleTimeMs: decoder.readInt32(),
+            errorCode: decoder.readInt16(),
+            members: decoder.readCompactArray((decoder) => ({
+                memberId: decoder.readCompactString(),
+                groupInstanceId: decoder.readCompactString(),
+                errorCode: decoder.readInt16(),
+                _tag: decoder.readTagBuffer(),
+            })),
+            _tag2: decoder.readTagBuffer(),
+        };
+        if (result.errorCode)
+            throw new error_1.KafkaTSApiError(result.errorCode, null, result);
+        result.members.forEach((member) => {
+            if (member.errorCode)
+                throw new error_1.KafkaTSApiError(member.errorCode, null, result);
+        });
+        return result;
+    },
+});

package/dist/api/list-offsets.d.ts

@@ -0,0 +1,29 @@
+import { IsolationLevel } from './fetch';
+export declare const LIST_OFFSETS: import("../utils/api").Api<{
+    replicaId: number;
+    isolationLevel: IsolationLevel;
+    topics: {
+        name: string;
+        partitions: {
+            partitionIndex: number;
+            currentLeaderEpoch: number;
+            timestamp: bigint;
+        }[];
+    }[];
+}, {
+    _tag: void;
+    throttleTimeMs: number;
+    topics: {
+        name: string;
+        partitions: {
+            partitionIndex: number;
+            errorCode: number;
+            timestamp: bigint;
+            offset: bigint;
+            leaderEpoch: number;
+            _tag: void;
+        }[];
+        _tag: void;
+    }[];
+    _tag2: void;
+}>;

package/dist/api/list-offsets.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LIST_OFFSETS = void 0;
+const api_1 = require("../utils/api");
+const error_1 = require("../utils/error");
+exports.LIST_OFFSETS = (0, api_1.createApi)({
+    apiKey: 2,
+    apiVersion: 8,
+    request: (encoder, data) => encoder
+        .writeUVarInt(0)
+        .writeInt32(data.replicaId)
+        .writeInt8(data.isolationLevel)
+        .writeCompactArray(data.topics, (encoder, topic) => encoder
+        .writeCompactString(topic.name)
+        .writeCompactArray(topic.partitions, (encoder, partition) => encoder
+        .writeInt32(partition.partitionIndex)
+        .writeInt32(partition.currentLeaderEpoch)
+        .writeInt64(partition.timestamp)
+        .writeUVarInt(0))
+        .writeUVarInt(0))
+        .writeUVarInt(0),
+    response: (decoder) => {
+        const result = {
+            _tag: decoder.readTagBuffer(),
+            throttleTimeMs: decoder.readInt32(),
+            topics: decoder.readCompactArray((decoder) => ({
+                name: decoder.readCompactString(),
+                partitions: decoder.readCompactArray((decoder) => ({
+                    partitionIndex: decoder.readInt32(),
+                    errorCode: decoder.readInt16(),
+                    timestamp: decoder.readInt64(),
+                    offset: decoder.readInt64(),
+                    leaderEpoch: decoder.readInt32(),
+                    _tag: decoder.readTagBuffer(),
+                })),
+                _tag: decoder.readTagBuffer(),
+            })),
+            _tag2: decoder.readTagBuffer(),
+        };
+        result.topics.forEach((topic) => {
+            topic.partitions.forEach((partition) => {
+                if (partition.errorCode)
+                    throw new error_1.KafkaTSApiError(partition.errorCode, null, result);
+            });
+        });
+        return result;
+    },
+});

package/dist/api/metadata.d.ts

@@ -0,0 +1,40 @@
+export type Metadata = Awaited<ReturnType<(typeof METADATA)['response']>>;
+export declare const METADATA: import("../utils/api").Api<{
+    topics: {
+        id: string | null;
+        name: string;
+    }[] | null;
+    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;
+    topics: {
+        errorCode: number;
+        name: string;
+        topicId: string;
+        isInternal: boolean;
+        partitions: {
+            errorCode: number;
+            partitionIndex: number;
+            leaderId: number;
+            leaderEpoch: number;
+            replicaNodes: number[];
+            isrNodes: number[];
+            offlineReplicas: number[];
+            _tag: void;
+        }[];
+        topicAuthorizedOperations: number;
+        _tag: void;
+    }[];
+    _tag2: void;
+}>;

package/{src/api/metadata.ts → dist/api/metadata.js}

@@ -1,34 +1,24 @@
-import { createApi } from '../utils/api';
-import { KafkaTSApiError } from '../utils/error';
-
-export type Metadata = ReturnType<(typeof METADATA)['response']>;
-
-export const METADATA = createApi({
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.METADATA = void 0;
+const api_1 = require("../utils/api");
+const error_1 = require("../utils/error");
+exports.METADATA = (0, api_1.createApi)({
     apiKey: 3,
     apiVersion: 12,
-    request: (
-        encoder,
-        data: {
-            topics: { id: string | null; name: string }[] | null;
-            allowTopicAutoCreation: boolean;
-            includeTopicAuthorizedOperations: boolean;
-        },
-    ) =>
-        encoder
-            .writeUVarInt(0)
-            .writeCompactArray(data.topics, (encoder, topic) =>
-                encoder.writeUUID(topic.id).writeCompactString(topic.name).writeUVarInt(0),
-            )
-            .writeBoolean(data.allowTopicAutoCreation)
-            .writeBoolean(data.includeTopicAuthorizedOperations)
-            .writeUVarInt(0),
+    request: (encoder, data) => encoder
+        .writeUVarInt(0)
+        .writeCompactArray(data.topics, (encoder, topic) => encoder.writeUUID(topic.id).writeCompactString(topic.name).writeUVarInt(0))
+        .writeBoolean(data.allowTopicAutoCreation)
+        .writeBoolean(data.includeTopicAuthorizedOperations)
+        .writeUVarInt(0),
     response: (decoder) => {
         const result = {
             _tag: decoder.readTagBuffer(),
             throttleTimeMs: decoder.readInt32(),
             brokers: decoder.readCompactArray((broker) => ({
                 nodeId: broker.readInt32(),
-                host: broker.readCompactString()!,
+                host: broker.readCompactString(),
                 port: broker.readInt32(),
                 rack: broker.readCompactString(),
                 _tag: broker.readTagBuffer(),
@@ -37,7 +27,7 @@ export const METADATA = createApi({
             controllerId: decoder.readInt32(),
             topics: decoder.readCompactArray((topic) => ({
                 errorCode: topic.readInt16(),
-                name: topic.readCompactString()!,
+                name: topic.readCompactString(),
                 topicId: topic.readUUID(),
                 isInternal: topic.readBoolean(),
                 partitions: topic.readCompactArray((partition) => ({
@@ -56,9 +46,11 @@ export const METADATA = createApi({
             _tag2: decoder.readTagBuffer(),
         };
         result.topics.forEach((topic) => {
-            if (topic.errorCode) throw new KafkaTSApiError(topic.errorCode, null, result);
+            if (topic.errorCode)
+                throw new error_1.KafkaTSApiError(topic.errorCode, null, result);
             topic.partitions.forEach((partition) => {
-                if (partition.errorCode) throw new KafkaTSApiError(partition.errorCode, null, result);
+                if (partition.errorCode)
+                    throw new error_1.KafkaTSApiError(partition.errorCode, null, result);
             });
         });
         return result;

package/dist/api/offset-commit.d.ts

@@ -0,0 +1,28 @@
+export declare const OFFSET_COMMIT: import("../utils/api").Api<{
+    groupId: string;
+    generationIdOrMemberEpoch: number;
+    memberId: string;
+    groupInstanceId: string | null;
+    topics: {
+        name: string;
+        partitions: {
+            partitionIndex: number;
+            committedOffset: bigint;
+            committedLeaderEpoch: number;
+            committedMetadata: string | null;
+        }[];
+    }[];
+}, {
+    _tag: void;
+    throttleTimeMs: number;
+    topics: {
+        name: string | null;
+        partitions: {
+            partitionIndex: number;
+            errorCode: number;
+            _tag: void;
+        }[];
+        _tag: void;
+    }[];
+    _tag2: void;
+}>;

package/dist/api/offset-commit.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OFFSET_COMMIT = void 0;
+const api_1 = require("../utils/api");
+const error_1 = require("../utils/error");
+exports.OFFSET_COMMIT = (0, api_1.createApi)({
+    apiKey: 8,
+    apiVersion: 8,
+    request: (encoder, data) => encoder
+        .writeUVarInt(0)
+        .writeCompactString(data.groupId)
+        .writeInt32(data.generationIdOrMemberEpoch)
+        .writeCompactString(data.memberId)
+        .writeCompactString(data.groupInstanceId)
+        .writeCompactArray(data.topics, (encoder, topic) => encoder
+        .writeCompactString(topic.name)
+        .writeCompactArray(topic.partitions, (encoder, partition) => encoder
+        .writeInt32(partition.partitionIndex)
+        .writeInt64(partition.committedOffset)
+        .writeInt32(partition.committedLeaderEpoch)
+        .writeCompactString(partition.committedMetadata)
+        .writeUVarInt(0))
+        .writeUVarInt(0))
+        .writeUVarInt(0),
+    response: (decoder) => {
+        const result = {
+            _tag: decoder.readTagBuffer(),
+            throttleTimeMs: decoder.readInt32(),
+            topics: decoder.readCompactArray((decoder) => ({
+                name: decoder.readCompactString(),
+                partitions: decoder.readCompactArray((decoder) => ({
+                    partitionIndex: decoder.readInt32(),
+                    errorCode: decoder.readInt16(),
+                    _tag: decoder.readTagBuffer(),
+                })),
+                _tag: decoder.readTagBuffer(),
+            })),
+            _tag2: decoder.readTagBuffer(),
+        };
+        result.topics.forEach((topic) => {
+            topic.partitions.forEach((partition) => {
+                if (partition.errorCode)
+                    throw new error_1.KafkaTSApiError(partition.errorCode, null, result);
+            });
+        });
+        return result;
+    },
+});

package/dist/api/offset-fetch.d.ts

@@ -0,0 +1,31 @@
+export declare const OFFSET_FETCH: import("../utils/api").Api<{
+    groups: {
+        groupId: string;
+        topics: {
+            name: string;
+            partitionIndexes: number[];
+        }[];
+    }[];
+    requireStable: boolean;
+}, {
+    _tag: void;
+    throttleTimeMs: number;
+    groups: {
+        groupId: string | null;
+        topics: {
+            name: string;
+            partitions: {
+                partitionIndex: number;
+                committedOffset: bigint;
+                committedLeaderEpoch: number;
+                committedMetadata: string | null;
+                errorCode: number;
+                _tag: void;
+            }[];
+            _tag: void;
+        }[];
+        errorCode: number;
+        _tag: void;
+    }[];
+    _tag2: void;
+}>;

package/dist/api/offset-fetch.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OFFSET_FETCH = void 0;
+const api_1 = require("../utils/api");
+const error_1 = require("../utils/error");
+exports.OFFSET_FETCH = (0, api_1.createApi)({
+    apiKey: 9,
+    apiVersion: 8,
+    request: (encoder, data) => encoder
+        .writeUVarInt(0)
+        .writeCompactArray(data.groups, (encoder, group) => encoder
+        .writeCompactString(group.groupId)
+        .writeCompactArray(group.topics, (encoder, topic) => encoder
+        .writeCompactString(topic.name)
+        .writeCompactArray(topic.partitionIndexes, (encoder, partitionIndex) => encoder.writeInt32(partitionIndex))
+        .writeUVarInt(0))
+        .writeUVarInt(0))
+        .writeBoolean(data.requireStable)
+        .writeUVarInt(0),
+    response: (decoder) => {
+        const result = {
+            _tag: decoder.readTagBuffer(),
+            throttleTimeMs: decoder.readInt32(),
+            groups: decoder.readCompactArray((decoder) => ({
+                groupId: decoder.readCompactString(),
+                topics: decoder.readCompactArray((decoder) => ({
+                    name: decoder.readCompactString(),
+                    partitions: decoder.readCompactArray((decoder) => ({
+                        partitionIndex: decoder.readInt32(),
+                        committedOffset: decoder.readInt64(),
+                        committedLeaderEpoch: decoder.readInt32(),
+                        committedMetadata: decoder.readCompactString(),
+                        errorCode: decoder.readInt16(),
+                        _tag: decoder.readTagBuffer(),
+                    })),
+                    _tag: decoder.readTagBuffer(),
+                })),
+                errorCode: decoder.readInt16(),
+                _tag: decoder.readTagBuffer(),
+            })),
+            _tag2: decoder.readTagBuffer(),
+        };
+        result.groups.forEach((group) => {
+            if (group.errorCode)
+                throw new error_1.KafkaTSApiError(group.errorCode, null, result);
+            group.topics.forEach((topic) => {
+                topic.partitions.forEach((partition) => {
+                    if (partition.errorCode)
+                        throw new error_1.KafkaTSApiError(partition.errorCode, null, result);
+                });
+            });
+        });
+        return result;
+    },
+});

package/dist/api/produce.d.ts

@@ -0,0 +1,54 @@
+/// <reference types="node" />
+export declare const PRODUCE: import("../utils/api.js").Api<{
+    transactionalId: string | null;
+    acks: number;
+    timeoutMs: number;
+    topicData: {
+        name: string;
+        partitionData: {
+            index: number;
+            baseOffset: bigint;
+            partitionLeaderEpoch: number;
+            attributes: number;
+            lastOffsetDelta: number;
+            baseTimestamp: bigint;
+            maxTimestamp: bigint;
+            producerId: bigint;
+            producerEpoch: number;
+            baseSequence: number;
+            records: {
+                attributes: number;
+                timestampDelta: bigint;
+                offsetDelta: number;
+                key: Buffer | null;
+                value: Buffer | null;
+                headers: {
+                    key: Buffer;
+                    value: Buffer;
+                }[];
+            }[];
+        }[];
+    }[];
+}, {
+    _tag: void;
+    responses: {
+        name: string | null;
+        partitionResponses: {
+            index: number;
+            errorCode: number;
+            baseOffset: bigint;
+            logAppendTime: bigint;
+            logStartOffset: bigint;
+            recordErrors: {
+                batchIndex: number;
+                batchIndexError: number;
+                _tag: void;
+            }[];
+            errorMessage: string | null;
+            _tag: void;
+        }[];
+        _tag: void;
+    }[];
+    throttleTimeMs: number;
+    _tag2: void;
+}>;