kafka-ts 0.0.3 → 0.0.4

package/src/api/api-versions.ts

@@ -1,21 +0,0 @@
-import { createApi } from '../utils/api.js';
-import { KafkaTSApiError } from '../utils/error.js';
-
-export const API_VERSIONS = createApi({
-    apiKey: 18,
-    apiVersion: 2,
-    request: (encoder) => encoder,
-    response: (decoder) => {
-        const result = {
-            errorCode: decoder.readInt16(),
-            versions: decoder.readArray((version) => ({
-                apiKey: version.readInt16(),
-                minVersion: version.readInt16(),
-                maxVersion: version.readInt16(),
-            })),
-            throttleTimeMs: decoder.readInt32(),
-        };
-        if (result.errorCode) throw new KafkaTSApiError(result.errorCode, null, result);
-        return result;
-    },
-});

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,198 +0,0 @@
-import { findCodec } from '../codecs';
-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 type FetchResponse = Awaited<ReturnType<(typeof FETCH)['response']>>;
-
-export const FETCH = createApi({
-    apiKey: 1,
-    apiVersion: 15,
-    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: async (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: decodeRecordBatch(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);
-            });
-        });
-
-        const decompressedResponses = await Promise.all(
-            result.responses.map(async (response) => ({
-                ...response,
-                partitions: await Promise.all(
-                    response.partitions.map(async (partition) => ({
-                        ...partition,
-                        records: await Promise.all(
-                            partition.records.map(async ({ recordsLength, compressedRecords, ...record }) => {
-                                const { decompress } = findCodec(record.compression);
-                                const decompressedRecords = await decompress(compressedRecords);
-                                const decompressedDecoder = new Decoder(
-                                    Buffer.concat([recordsLength, decompressedRecords]),
-                                );
-                                return { ...record, records: decodeRecord(decompressedDecoder) };
-                            }),
-                        ),
-                    })),
-                ),
-            })),
-        );
-
-        return { ...result, responses: decompressedResponses };
-    },
-});
-
-const decodeRecordBatch = (decoder: Decoder) => {
-    const size = decoder.readUVarInt() - 1;
-    if (size <= 0) {
-        return [];
-    }
-
-    const recordBatchDecoder = new Decoder(decoder.read(size));
-
-    const results = [];
-    while (recordBatchDecoder.getBufferLength() > recordBatchDecoder.getOffset() + 12) {
-        const baseOffset = recordBatchDecoder.readInt64();
-        const batchLength = recordBatchDecoder.readInt32();
-        if (!batchLength) {
-            continue;
-        }
-
-        const batchDecoder = new Decoder(recordBatchDecoder.read(batchLength));
-
-        const result = {
-            baseOffset,
-            batchLength,
-            partitionLeaderEpoch: batchDecoder.readInt32(),
-            magic: batchDecoder.readInt8(),
-            crc: batchDecoder.readUInt32(),
-            attributes: batchDecoder.readInt16(),
-            lastOffsetDelta: batchDecoder.readInt32(),
-            baseTimestamp: batchDecoder.readInt64(),
-            maxTimestamp: batchDecoder.readInt64(),
-            producerId: batchDecoder.readInt64(),
-            producerEpoch: batchDecoder.readInt16(),
-            baseSequence: batchDecoder.readInt32(),
-            recordsLength: batchDecoder.read(4),
-            compressedRecords: batchDecoder.read(),
-        };
-
-        const compression = result.attributes & 0x07;
-        const timestampType = (result.attributes & 0x08) >> 3 ? 'LogAppendTime' : 'CreateTime';
-        const isTransactional = !!((result.attributes & 0x10) >> 4);
-        const isControlBatch = !!((result.attributes & 0x20) >> 5);
-        const hasDeleteHorizonMs = !!((result.attributes & 0x40) >> 6);
-
-        results.push({
-            ...result,
-            compression,
-            timestampType,
-            isTransactional,
-            isControlBatch,
-            hasDeleteHorizonMs,
-        });
-    }
-    return results;
-};
-
-const decodeRecord = (decoder: Decoder) =>
-    decoder.readRecords((record) => ({
-        attributes: record.readInt8(),
-        timestampDelta: record.readVarLong(),
-        offsetDelta: record.readVarInt(),
-        key: record.readVarIntBuffer(),
-        value: record.readVarIntBuffer(),
-        headers: record.readVarIntArray((header) => ({
-            key: header.readVarIntBuffer(),
-            value: header.readVarIntBuffer(),
-        })),
-    }));

package/src/api/find-coordinator.ts

@@ -1,39 +0,0 @@
-import { createApi } from '../utils/api';
-import { KafkaTSApiError } from '../utils/error';
-
-export const KEY_TYPE = {
-    GROUP: 0,
-    TRANSACTION: 1,
-};
-
-export const FIND_COORDINATOR = createApi({
-    apiKey: 10,
-    apiVersion: 4,
-    request: (encoder, data: { keyType: number; keys: string[] }) =>
-        encoder
-            .writeUVarInt(0)
-            .writeInt8(data.keyType)
-            .writeCompactArray(data.keys, (encoder, key) => encoder.writeCompactString(key))
-            .writeUVarInt(0),
-    response: (decoder) => {
-        const result = {
-            _tag: decoder.readTagBuffer(),
-            throttleTimeMs: decoder.readInt32(),
-            coordinators: decoder.readCompactArray((decoder) => ({
-                key: decoder.readCompactString(),
-                nodeId: decoder.readInt32(),
-                host: decoder.readCompactString()!,
-                port: decoder.readInt32(),
-                errorCode: decoder.readInt16(),
-                errorMessage: decoder.readCompactString(),
-                _tag: decoder.readTagBuffer(),
-            })),
-            _tag2: decoder.readTagBuffer(),
-        };
-        result.coordinators.forEach((coordinator) => {
-            if (coordinator.errorCode)
-                throw new KafkaTSApiError(coordinator.errorCode, coordinator.errorMessage, result);
-        });
-        return result;
-    },
-});

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/index.ts

@@ -1,166 +0,0 @@
-import { Api } from '../utils/api';
-import { API_VERSIONS } from './api-versions';
-import { CREATE_TOPICS } from './create-topics';
-import { DELETE_TOPICS } from './delete-topics';
-import { FETCH } from './fetch';
-import { FIND_COORDINATOR } from './find-coordinator';
-import { HEARTBEAT } from './heartbeat';
-import { INIT_PRODUCER_ID } from './init-producer-id';
-import { JOIN_GROUP } from './join-group';
-import { LEAVE_GROUP } from './leave-group';
-import { LIST_OFFSETS } from './list-offsets';
-import { METADATA } from './metadata';
-import { OFFSET_COMMIT } from './offset-commit';
-import { OFFSET_FETCH } from './offset-fetch';
-import { PRODUCE } from './produce';
-import { SASL_AUTHENTICATE } from './sasl-authenticate';
-import { SASL_HANDSHAKE } from './sasl-handshake';
-import { SYNC_GROUP } from './sync-group';
-
-export const API = {
-    API_VERSIONS,
-    CREATE_TOPICS,
-    DELETE_TOPICS,
-    FETCH,
-    FIND_COORDINATOR,
-    HEARTBEAT,
-    INIT_PRODUCER_ID,
-    JOIN_GROUP,
-    LEAVE_GROUP,
-    LIST_OFFSETS,
-    METADATA,
-    OFFSET_COMMIT,
-    OFFSET_FETCH,
-    PRODUCE,
-    SASL_AUTHENTICATE,
-    SASL_HANDSHAKE,
-    SYNC_GROUP,
-};
-
-const apiNameByKey = Object.fromEntries(Object.entries(API).map(([k, v]) => [v.apiKey, k]));
-
-export const getApiName = <Request, Response>(api: Api<Request, Response>) => apiNameByKey[api.apiKey];
-
-export const API_ERROR = {
-    UNKNOWN_SERVER_ERROR: -1,
-    OFFSET_OUT_OF_RANGE: 1,
-    CORRUPT_MESSAGE: 2,
-    UNKNOWN_TOPIC_OR_PARTITION: 3,
-    INVALID_FETCH_SIZE: 4,
-    LEADER_NOT_AVAILABLE: 5,
-    NOT_LEADER_OR_FOLLOWER: 6,
-    REQUEST_TIMED_OUT: 7,
-    BROKER_NOT_AVAILABLE: 8,
-    REPLICA_NOT_AVAILABLE: 9,
-    MESSAGE_TOO_LARGE: 10,
-    STALE_CONTROLLER_EPOCH: 11,
-    OFFSET_METADATA_TOO_LARGE: 12,
-    NETWORK_EXCEPTION: 13,
-    COORDINATOR_LOAD_IN_PROGRESS: 14,
-    COORDINATOR_NOT_AVAILABLE: 15,
-    NOT_COORDINATOR: 16,
-    INVALID_TOPIC_EXCEPTION: 17,
-    RECORD_LIST_TOO_LARGE: 18,
-    NOT_ENOUGH_REPLICAS: 19,
-    NOT_ENOUGH_REPLICAS_AFTER_APPEND: 20,
-    INVALID_REQUIRED_ACKS: 21,
-    ILLEGAL_GENERATION: 22,
-    INCONSISTENT_GROUP_PROTOCOL: 23,
-    INVALID_GROUP_ID: 24,
-    UNKNOWN_MEMBER_ID: 25,
-    INVALID_SESSION_TIMEOUT: 26,
-    REBALANCE_IN_PROGRESS: 27,
-    INVALID_COMMIT_OFFSET_SIZE: 28,
-    TOPIC_AUTHORIZATION_FAILED: 29,
-    GROUP_AUTHORIZATION_FAILED: 30,
-    CLUSTER_AUTHORIZATION_FAILED: 31,
-    INVALID_TIMESTAMP: 32,
-    UNSUPPORTED_SASL_MECHANISM: 33,
-    ILLEGAL_SASL_STATE: 34,
-    UNSUPPORTED_VERSION: 35,
-    TOPIC_ALREADY_EXISTS: 36,
-    INVALID_PARTITIONS: 37,
-    INVALID_REPLICATION_FACTOR: 38,
-    INVALID_REPLICA_ASSIGNMENT: 39,
-    INVALID_CONFIG: 40,
-    NOT_CONTROLLER: 41,
-    INVALID_REQUEST: 42,
-    UNSUPPORTED_FOR_MESSAGE_FORMAT: 43,
-    POLICY_VIOLATION: 44,
-    OUT_OF_ORDER_SEQUENCE_NUMBER: 45,
-    DUPLICATE_SEQUENCE_NUMBER: 46,
-    INVALID_PRODUCER_EPOCH: 47,
-    INVALID_TXN_STATE: 48,
-    INVALID_PRODUCER_ID_MAPPING: 49,
-    INVALID_TRANSACTION_TIMEOUT: 50,
-    CONCURRENT_TRANSACTIONS: 51,
-    TRANSACTION_COORDINATOR_FENCED: 52,
-    TRANSACTIONAL_ID_AUTHORIZATION_FAILED: 53,
-    SECURITY_DISABLED: 54,
-    OPERATION_NOT_ATTEMPTED: 55,
-    KAFKA_STORAGE_ERROR: 56,
-    LOG_DIR_NOT_FOUND: 57,
-    SASL_AUTHENTICATION_FAILED: 58,
-    UNKNOWN_PRODUCER_ID: 59,
-    REASSIGNMENT_IN_PROGRESS: 60,
-    DELEGATION_TOKEN_AUTH_DISABLED: 61,
-    DELEGATION_TOKEN_NOT_FOUND: 62,
-    DELEGATION_TOKEN_OWNER_MISMATCH: 63,
-    DELEGATION_TOKEN_REQUEST_NOT_ALLOWED: 64,
-    DELEGATION_TOKEN_AUTHORIZATION_FAILED: 65,
-    DELEGATION_TOKEN_EXPIRED: 66,
-    INVALID_PRINCIPAL_TYPE: 67,
-    NON_EMPTY_GROUP: 68,
-    GROUP_ID_NOT_FOUND: 69,
-    FETCH_SESSION_ID_NOT_FOUND: 70,
-    INVALID_FETCH_SESSION_EPOCH: 71,
-    LISTENER_NOT_FOUND: 72,
-    TOPIC_DELETION_DISABLED: 73,
-    FENCED_LEADER_EPOCH: 74,
-    UNKNOWN_LEADER_EPOCH: 75,
-    UNSUPPORTED_COMPRESSION_TYPE: 76,
-    STALE_BROKER_EPOCH: 77,
-    OFFSET_NOT_AVAILABLE: 78,
-    MEMBER_ID_REQUIRED: 79,
-    PREFERRED_LEADER_NOT_AVAILABLE: 80,
-    GROUP_MAX_SIZE_REACHED: 81,
-    FENCED_INSTANCE_ID: 82,
-    ELIGIBLE_LEADERS_NOT_AVAILABLE: 83,
-    ELECTION_NOT_NEEDED: 84,
-    NO_REASSIGNMENT_IN_PROGRESS: 85,
-    GROUP_SUBSCRIBED_TO_TOPIC: 86,
-    INVALID_RECORD: 87,
-    UNSTABLE_OFFSET_COMMIT: 88,
-    THROTTLING_QUOTA_EXCEEDED: 89,
-    PRODUCER_FENCED: 90,
-    RESOURCE_NOT_FOUND: 91,
-    DUPLICATE_RESOURCE: 92,
-    UNACCEPTABLE_CREDENTIAL: 93,
-    INCONSISTENT_VOTER_SET: 94,
-    INVALID_UPDATE_VERSION: 95,
-    FEATURE_UPDATE_FAILED: 96,
-    PRINCIPAL_DESERIALIZATION_FAILURE: 97,
-    SNAPSHOT_NOT_FOUND: 98,
-    POSITION_OUT_OF_RANGE: 99,
-    UNKNOWN_TOPIC_ID: 100,
-    DUPLICATE_BROKER_REGISTRATION: 101,
-    BROKER_ID_NOT_REGISTERED: 102,
-    INCONSISTENT_TOPIC_ID: 103,
-    INCONSISTENT_CLUSTER_ID: 104,
-    TRANSACTIONAL_ID_NOT_FOUND: 105,
-    FETCH_SESSION_TOPIC_ID_ERROR: 106,
-    INELIGIBLE_REPLICA: 107,
-    NEW_LEADER_ELECTED: 108,
-    OFFSET_MOVED_TO_TIERED_STORAGE: 109,
-    FENCED_MEMBER_EPOCH: 110,
-    UNRELEASED_INSTANCE_ID: 111,
-    UNSUPPORTED_ASSIGNOR: 112,
-    STALE_MEMBER_EPOCH: 113,
-    MISMATCHED_ENDPOINT_TYPE: 114,
-    UNSUPPORTED_ENDPOINT_TYPE: 115,
-    UNKNOWN_CONTROLLER_ID: 116,
-    UNKNOWN_SUBSCRIPTION_ID: 117,
-    TELEMETRY_TOO_LARGE: 118,
-    INVALID_REGISTRATION: 119,
-    TRANSACTION_ABORTABLE: 120,
-};

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;
-    },
-});