kafka-ts 0.0.3-beta → 0.0.4

package/src/api/create-topics.ts

@@ -1,78 +0,0 @@
-import { createApi } from '../utils/api';
-import { KafkaTSApiError } from '../utils/error';
-
-export const CREATE_TOPICS = createApi({
-    apiKey: 19,
-    apiVersion: 7,
-    request: (
-        encoder,
-        data: {
-            topics: {
-                name: string;
-                numPartitions: number;
-                replicationFactor: number;
-                assignments: {
-                    partitionIndex: number;
-                    brokerIds: number[];
-                }[];
-                configs: {
-                    name: string;
-                    value: string | null;
-                }[];
-            }[];
-            timeoutMs: number;
-            validateOnly: boolean;
-        },
-    ) =>
-        encoder
-            .writeUVarInt(0)
-            .writeCompactArray(data.topics, (encoder, topic) =>
-                encoder
-                    .writeCompactString(topic.name)
-                    .writeInt32(topic.numPartitions)
-                    .writeInt16(topic.replicationFactor)
-                    .writeCompactArray(topic.assignments, (encoder, assignment) =>
-                        encoder
-                            .writeInt32(assignment.partitionIndex)
-                            .writeCompactArray(assignment.brokerIds, (encoder, brokerId) =>
-                                encoder.writeInt32(brokerId),
-                            )
-                            .writeUVarInt(0),
-                    )
-                    .writeCompactArray(topic.configs, (encoder, config) =>
-                        encoder.writeCompactString(config.name).writeCompactString(config.value).writeUVarInt(0),
-                    )
-                    .writeUVarInt(0),
-            )
-            .writeInt32(data.timeoutMs)
-            .writeBoolean(data.validateOnly)
-            .writeUVarInt(0),
-    response: (decoder) => {
-        const result = {
-            _tag: decoder.readTagBuffer(),
-            throttleTimeMs: decoder.readInt32(),
-            topics: decoder.readCompactArray((topic) => ({
-                name: topic.readCompactString(),
-                topicId: topic.readUUID(),
-                errorCode: topic.readInt16(),
-                errorMessage: topic.readCompactString(),
-                numPartitions: topic.readInt32(),
-                replicationFactor: topic.readInt16(),
-                configs: topic.readCompactArray((config) => ({
-                    name: config.readCompactString(),
-                    value: config.readCompactString(),
-                    readOnly: config.readBoolean(),
-                    configSource: config.readInt8(),
-                    isSensitive: config.readBoolean(),
-                    _tag: config.readTagBuffer(),
-                })),
-                _tag: topic.readTagBuffer(),
-            })),
-            _tag2: decoder.readTagBuffer(),
-        };
-        result.topics.forEach((topic) => {
-            if (topic.errorCode) throw new KafkaTSApiError(topic.errorCode, topic.errorMessage, result);
-        });
-        return result;
-    },
-});

package/src/api/delete-topics.ts

@@ -1,42 +0,0 @@
-import { createApi } from '../utils/api';
-import { KafkaTSApiError } from '../utils/error';
-
-export const DELETE_TOPICS = createApi({
-    apiKey: 20,
-    apiVersion: 6,
-    request: (
-        encoder,
-        data: {
-            topics: {
-                name: string | null;
-                topicId: string | null;
-            }[];
-            timeoutMs: number;
-        },
-    ) =>
-        encoder
-            .writeUVarInt(0)
-            .writeCompactArray(data.topics, (encoder, topic) =>
-                encoder.writeCompactString(topic.name).writeUUID(topic.topicId).writeUVarInt(0),
-            )
-            .writeInt32(data.timeoutMs)
-            .writeUVarInt(0),
-    response: (decoder) => {
-        const result = {
-            _tag: decoder.readTagBuffer(),
-            throttleTimeMs: decoder.readInt32(),
-            responses: decoder.readCompactArray((decoder) => ({
-                name: decoder.readCompactString(),
-                topicId: decoder.readUUID(),
-                errorCode: decoder.readInt16(),
-                errorMessage: decoder.readCompactString(),
-                _tag: decoder.readTagBuffer(),
-            })),
-            _tag2: decoder.readTagBuffer(),
-        };
-        result.responses.forEach((response) => {
-            if (response.errorCode) throw new KafkaTSApiError(response.errorCode, response.errorMessage, result);
-        });
-        return result;
-    },
-});

package/src/api/fetch.ts

@@ -1,143 +0,0 @@
-import { createApi } from '../utils/api';
-import { Decoder } from '../utils/decoder';
-import { KafkaTSApiError } from '../utils/error';
-
-export const enum IsolationLevel {
-    READ_UNCOMMITTED = 0,
-    READ_COMMITTED = 1,
-}
-
-export const FETCH = createApi({
-    apiKey: 1,
-    apiVersion: 16,
-    request: (
-        encoder,
-        data: {
-            maxWaitMs: number;
-            minBytes: number;
-            maxBytes: number;
-            isolationLevel: IsolationLevel;
-            sessionId: number;
-            sessionEpoch: number;
-            topics: {
-                topicId: string;
-                partitions: {
-                    partition: number;
-                    currentLeaderEpoch: number;
-                    fetchOffset: bigint;
-                    lastFetchedEpoch: number;
-                    logStartOffset: bigint;
-                    partitionMaxBytes: number;
-                }[];
-            }[];
-            forgottenTopicsData: {
-                topicId: string;
-                partitions: number[];
-            }[];
-            rackId: string;
-        },
-    ) =>
-        encoder
-            .writeUVarInt(0)
-            .writeInt32(data.maxWaitMs)
-            .writeInt32(data.minBytes)
-            .writeInt32(data.maxBytes)
-            .writeInt8(data.isolationLevel)
-            .writeInt32(data.sessionId)
-            .writeInt32(data.sessionEpoch)
-            .writeCompactArray(data.topics, (encoder, topic) =>
-                encoder
-                    .writeUUID(topic.topicId)
-                    .writeCompactArray(topic.partitions, (encoder, partition) =>
-                        encoder
-                            .writeInt32(partition.partition)
-                            .writeInt32(partition.currentLeaderEpoch)
-                            .writeInt64(partition.fetchOffset)
-                            .writeInt32(partition.lastFetchedEpoch)
-                            .writeInt64(partition.logStartOffset)
-                            .writeInt32(partition.partitionMaxBytes)
-                            .writeUVarInt(0),
-                    )
-                    .writeUVarInt(0),
-            )
-            .writeCompactArray(data.forgottenTopicsData, (encoder, forgottenTopic) =>
-                encoder
-                    .writeUUID(forgottenTopic.topicId)
-                    .writeCompactArray(forgottenTopic.partitions, (encoder, partition) => encoder.writeInt32(partition))
-                    .writeUVarInt(0),
-            )
-            .writeCompactString(data.rackId)
-            .writeUVarInt(0),
-    response: (decoder) => {
-        const result = {
-            _tag: decoder.readTagBuffer(),
-            throttleTimeMs: decoder.readInt32(),
-            errorCode: decoder.readInt16(),
-            sessionId: decoder.readInt32(),
-            responses: decoder.readCompactArray((response) => ({
-                topicId: response.readUUID(),
-                partitions: response.readCompactArray((partition) => ({
-                    partitionIndex: partition.readInt32(),
-                    errorCode: partition.readInt16(),
-                    highWatermark: partition.readInt64(),
-                    lastStableOffset: partition.readInt64(),
-                    logStartOffset: partition.readInt64(),
-                    abortedTransactions: partition.readCompactArray((abortedTransaction) => ({
-                        producerId: abortedTransaction.readInt64(),
-                        firstOffset: abortedTransaction.readInt64(),
-                        _tag: abortedTransaction.readTagBuffer(),
-                    })),
-                    preferredReadReplica: partition.readInt32(),
-                    records: decodeRecords(partition),
-                    _tag: partition.readTagBuffer(),
-                })),
-                _tag: response.readTagBuffer(),
-            })),
-            _tag2: decoder.readTagBuffer(),
-        };
-        if (result.errorCode) throw new KafkaTSApiError(result.errorCode, null, result);
-        result.responses.forEach((response) => {
-            response.partitions.forEach((partition) => {
-                if (partition.errorCode) throw new KafkaTSApiError(partition.errorCode, null, result);
-            });
-        });
-        return result;
-    },
-});
-
-const decodeRecords = (decoder: Decoder) => {
-    const size = decoder.readUVarInt() - 1;
-    if (size <= 0) {
-        return [];
-    }
-
-    const results = [];
-    while (decoder.getBufferLength() > decoder.getOffset() + 49) {
-        results.push({
-            baseOffset: decoder.readInt64(),
-            batchLength: decoder.readInt32(),
-            partitionLeaderEpoch: decoder.readInt32(),
-            magic: decoder.readInt8(),
-            crc: decoder.readUInt32(),
-            attributes: decoder.readInt16(),
-            lastOffsetDelta: decoder.readInt32(),
-            baseTimestamp: decoder.readInt64(),
-            maxTimestamp: decoder.readInt64(),
-            producerId: decoder.readInt64(),
-            producerEpoch: decoder.readInt16(),
-            baseSequence: decoder.readInt32(),
-            records: decoder.readRecords((record) => ({
-                attributes: record.readInt8(),
-                timestampDelta: record.readVarLong(),
-                offsetDelta: record.readVarInt(),
-                key: record.readVarIntString(),
-                value: record.readVarIntString(),
-                headers: record.readCompactArray((header) => ({
-                    key: header.readVarIntString(),
-                    value: header.readVarIntString(),
-                })),
-            })),
-        });
-    }
-    return results;
-};

package/src/api/heartbeat.ts

@@ -1,33 +0,0 @@
-import { createApi } from '../utils/api';
-import { KafkaTSApiError } from '../utils/error';
-
-export const HEARTBEAT = createApi({
-    apiKey: 12,
-    apiVersion: 4,
-    request: (
-        encoder,
-        data: {
-            groupId: string;
-            generationId: number;
-            memberId: string;
-            groupInstanceId: string | null;
-        },
-    ) =>
-        encoder
-            .writeUVarInt(0)
-            .writeCompactString(data.groupId)
-            .writeInt32(data.generationId)
-            .writeCompactString(data.memberId)
-            .writeCompactString(data.groupInstanceId)
-            .writeUVarInt(0),
-    response: (decoder) => {
-        const result = {
-            _tag: decoder.readTagBuffer(),
-            throttleTimeMs: decoder.readInt32(),
-            errorCode: decoder.readInt16(),
-            _tag2: decoder.readTagBuffer(),
-        };
-        if (result.errorCode) throw new KafkaTSApiError(result.errorCode, null, result);
-        return result;
-    },
-});

package/src/api/init-producer-id.ts

@@ -1,35 +0,0 @@
-import { createApi } from '../utils/api';
-import { KafkaTSApiError } from '../utils/error';
-
-export const INIT_PRODUCER_ID = createApi({
-    apiKey: 22,
-    apiVersion: 4,
-    request: (
-        encoder,
-        body: {
-            transactionalId: string | null;
-            transactionTimeoutMs: number;
-            producerId: bigint;
-            producerEpoch: number;
-        },
-    ) =>
-        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 KafkaTSApiError(result.errorCode, null, result);
-        return result;
-    },
-});

package/src/api/join-group.ts

@@ -1,67 +0,0 @@
-import { createApi } from '../utils/api';
-import { Encoder } from '../utils/encoder';
-import { KafkaTSApiError } from '../utils/error';
-
-export const JOIN_GROUP = createApi({
-    apiKey: 11,
-    apiVersion: 9,
-    request: (
-        encoder,
-        data: {
-            groupId: string;
-            sessionTimeoutMs: number;
-            rebalanceTimeoutMs: number;
-            memberId: string;
-            groupInstanceId: string | null;
-            protocolType: string;
-            protocols: {
-                name: string;
-                metadata: {
-                    version: number;
-                    topics: string[];
-                };
-            }[];
-            reason: string | null;
-        },
-    ) =>
-        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()
-                    .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 KafkaTSApiError(result.errorCode, null, result);
-        return result;
-    },
-});

package/src/api/leave-group.ts

@@ -1,48 +0,0 @@
-import { createApi } from '../utils/api';
-import { KafkaTSApiError } from '../utils/error';
-
-export const LEAVE_GROUP = createApi({
-    apiKey: 13,
-    apiVersion: 5,
-    request: (
-        encoder,
-        body: {
-            groupId: string;
-            members: {
-                memberId: string;
-                groupInstanceId: string | null;
-                reason: string | null;
-            }[];
-        },
-    ) =>
-        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 KafkaTSApiError(result.errorCode, null, result);
-        result.members.forEach((member) => {
-            if (member.errorCode) throw new KafkaTSApiError(member.errorCode, null, result);
-        });
-        return result;
-    },
-});

package/src/api/list-offsets.ts

@@ -1,65 +0,0 @@
-import { createApi } from '../utils/api';
-import { KafkaTSApiError } from '../utils/error';
-import { IsolationLevel } from './fetch';
-
-export const LIST_OFFSETS = createApi({
-    apiKey: 2,
-    apiVersion: 8,
-    request: (
-        encoder,
-        data: {
-            replicaId: number;
-            isolationLevel: IsolationLevel;
-            topics: {
-                name: string;
-                partitions: {
-                    partitionIndex: number;
-                    currentLeaderEpoch: number;
-                    timestamp: bigint;
-                }[];
-            }[];
-        },
-    ) =>
-        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 KafkaTSApiError(partition.errorCode, null, result);
-            });
-        });
-        return result;
-    },
-});

package/src/api/offset-commit.ts

@@ -1,67 +0,0 @@
-import { createApi } from '../utils/api';
-import { KafkaTSApiError } from '../utils/error';
-
-export const OFFSET_COMMIT = createApi({
-    apiKey: 8,
-    apiVersion: 9,
-    request: (
-        encoder,
-        data: {
-            groupId: string;
-            generationIdOrMemberEpoch: number;
-            memberId: string;
-            groupInstanceId: string | null;
-            topics: {
-                name: string;
-                partitions: {
-                    partitionIndex: number;
-                    committedOffset: bigint;
-                    committedLeaderEpoch: number;
-                    committedMetadata: string | null;
-                }[];
-            }[];
-        },
-    ) =>
-        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 KafkaTSApiError(partition.errorCode, null, result);
-            });
-        });
-        return result;
-    },
-});

package/src/api/offset-fetch.ts

@@ -1,74 +0,0 @@
-import { createApi } from '../utils/api';
-import { KafkaTSApiError } from '../utils/error';
-
-export const OFFSET_FETCH = createApi({
-    apiKey: 9,
-    apiVersion: 9,
-    request: (
-        encoder,
-        data: {
-            groups: {
-                groupId: string;
-                memberId: string | null;
-                memberEpoch: number;
-                topics: {
-                    name: string;
-                    partitionIndexes: number[];
-                }[];
-            }[];
-            requireStable: boolean;
-        },
-    ) =>
-        encoder
-            .writeUVarInt(0)
-            .writeCompactArray(data.groups, (encoder, group) =>
-                encoder
-                    .writeCompactString(group.groupId)
-                    .writeCompactString(group.memberId)
-                    .writeInt32(group.memberEpoch)
-                    .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 KafkaTSApiError(group.errorCode, null, result);
-            group.topics.forEach((topic) => {
-                topic.partitions.forEach((partition) => {
-                    if (partition.errorCode) throw new KafkaTSApiError(partition.errorCode, null, result);
-                });
-            });
-        });
-        return result;
-    },
-});

package/src/api/sasl-authenticate.ts

@@ -1,21 +0,0 @@
-import { createApi } from '../utils/api';
-import { KafkaTSApiError } from '../utils/error';
-
-export const SASL_AUTHENTICATE = createApi({
-    apiKey: 36,
-    apiVersion: 2,
-    request: (encoder, data: { authBytes: Buffer }) =>
-        encoder.writeUVarInt(0).writeCompactBytes(data.authBytes).writeUVarInt(0),
-    response: (decoder) => {
-        const result = {
-            _tag: decoder.readTagBuffer(),
-            errorCode: decoder.readInt16(),
-            errorMessage: decoder.readCompactString(),
-            authBytes: decoder.readCompactBytes(),
-            sessionLifetimeMs: decoder.readInt64(),
-            _tag2: decoder.readTagBuffer(),
-        };
-        if (result.errorCode) throw new KafkaTSApiError(result.errorCode, result.errorMessage, result);
-        return result;
-    },
-});