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

package/dist/api/offset-fetch.js

@@ -3,23 +3,108 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.OFFSET_FETCH = void 0;
 const api_1 = require("../utils/api");
 const error_1 = require("../utils/error");
+/*
+OffsetFetch Request (Version: 1) => group_id [topics]
+  group_id => STRING
+  topics => name [partition_indexes]
+    name => STRING
+    partition_indexes => INT32
+
+OffsetFetch Response (Version: 1) => [topics]
+  topics => name [partitions]
+    name => STRING
+    partitions => partition_index committed_offset metadata error_code
+      partition_index => INT32
+      committed_offset => INT64
+      metadata => NULLABLE_STRING
+      error_code => INT16
+*/
+const OFFSET_FETCH_V1 = (0, api_1.createApi)({
+    apiKey: 9,
+    apiVersion: 1,
+    requestHeaderVersion: 1,
+    responseHeaderVersion: 0,
+    request: (encoder, data) => encoder
+        .writeString(data.groups[0].groupId)
+        .writeArray(data.groups[0].topics, (encoder, topic) => encoder
+        .writeString(topic.name)
+        .writeArray(topic.partitionIndexes, (encoder, partitionIndex) => encoder.writeInt32(partitionIndex))),
+    response: (decoder) => {
+        const result = {
+            throttleTimeMs: 0,
+            groups: [
+                {
+                    groupId: '', // Not provided in v1 response
+                    topics: decoder.readArray((decoder) => ({
+                        name: decoder.readString(),
+                        partitions: decoder.readArray((decoder) => ({
+                            partitionIndex: decoder.readInt32(),
+                            committedOffset: decoder.readInt64(),
+                            committedLeaderEpoch: -1,
+                            committedMetadata: decoder.readString(),
+                            errorCode: decoder.readInt16(),
+                            tags: {},
+                        })),
+                        tags: {},
+                    })),
+                    errorCode: 0,
+                    tags: {},
+                },
+            ],
+            tags: {},
+        };
+        result.groups.forEach((group) => {
+            group.topics.forEach((topic) => {
+                topic.partitions.forEach((partition) => {
+                    if (partition.errorCode)
+                        throw new error_1.KafkaTSApiError(partition.errorCode, null, result);
+                });
+            });
+        });
+        return result;
+    },
+});
+/*
+OffsetFetch Request (Version: 8) => [groups] require_stable _tagged_fields
+  groups => group_id [topics] _tagged_fields
+    group_id => COMPACT_STRING
+    topics => name [partition_indexes] _tagged_fields
+      name => COMPACT_STRING
+      partition_indexes => INT32
+  require_stable => BOOLEAN
+
+OffsetFetch Response (Version: 8) => throttle_time_ms [groups] _tagged_fields
+  throttle_time_ms => INT32
+  groups => group_id [topics] error_code _tagged_fields
+    group_id => COMPACT_STRING
+    topics => name [partitions] _tagged_fields
+      name => COMPACT_STRING
+      partitions => partition_index committed_offset committed_leader_epoch metadata error_code _tagged_fields
+        partition_index => INT32
+        committed_offset => INT64
+        committed_leader_epoch => INT32
+        metadata => COMPACT_NULLABLE_STRING
+        error_code => INT16
+    error_code => INT16
+*/
 exports.OFFSET_FETCH = (0, api_1.createApi)({
     apiKey: 9,
     apiVersion: 8,
+    fallback: OFFSET_FETCH_V1,
+    requestHeaderVersion: 2,
+    responseHeaderVersion: 1,
     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))
+        .writeTagBuffer())
+        .writeTagBuffer())
         .writeBoolean(data.requireStable)
-        .writeUVarInt(0),
+        .writeTagBuffer(),
     response: (decoder) => {
         const result = {
-            _tag: decoder.readTagBuffer(),
             throttleTimeMs: decoder.readInt32(),
             groups: decoder.readCompactArray((decoder) => ({
                 groupId: decoder.readCompactString(),
@@ -31,14 +116,14 @@ exports.OFFSET_FETCH = (0, api_1.createApi)({
                         committedLeaderEpoch: decoder.readInt32(),
                         committedMetadata: decoder.readCompactString(),
                         errorCode: decoder.readInt16(),
-                        _tag: decoder.readTagBuffer(),
+                        tags: decoder.readTagBuffer(),
                     })),
-                    _tag: decoder.readTagBuffer(),
+                    tags: decoder.readTagBuffer(),
                 })),
                 errorCode: decoder.readInt16(),
-                _tag: decoder.readTagBuffer(),
+                tags: decoder.readTagBuffer(),
             })),
-            _tag2: decoder.readTagBuffer(),
+            tags: decoder.readTagBuffer(),
         };
         result.groups.forEach((group) => {
             if (group.errorCode)

package/dist/api/produce.d.ts

@@ -1,4 +1,4 @@
-export declare const PRODUCE: import("../utils/api.js").Api<{
+type ProduceRequest = {
     transactionalId: string | null;
     acks: number;
     timeoutMs: number;
@@ -28,10 +28,10 @@ export declare const PRODUCE: import("../utils/api.js").Api<{
             }[];
         }[];
     }[];
-}, {
-    _tag: void;
+};
+type ProduceResponse = {
     responses: {
-        name: string | null;
+        name: string;
         partitionResponses: {
             index: number;
             errorCode: number;
@@ -40,14 +40,12 @@ export declare const PRODUCE: import("../utils/api.js").Api<{
             logStartOffset: bigint;
             recordErrors: {
                 batchIndex: number;
-                batchIndexError: number;
-                _tag: void;
+                batchIndexErrorMessage: string | null;
             }[];
             errorMessage: string | null;
-            _tag: void;
         }[];
-        _tag: void;
     }[];
     throttleTimeMs: number;
-    _tag2: void;
-}>;
+};
+export declare const PRODUCE: import("../utils/api.js").Api<ProduceRequest, ProduceResponse>;
+export {};

package/dist/api/produce.js

@@ -4,56 +4,150 @@ exports.PRODUCE = void 0;
 const api_js_1 = require("../utils/api.js");
 const encoder_js_1 = require("../utils/encoder.js");
 const error_js_1 = require("../utils/error.js");
+const createBatch = (partition) => {
+    const batchBody = new encoder_js_1.Encoder()
+        .writeInt16(partition.attributes)
+        .writeInt32(partition.lastOffsetDelta)
+        .writeInt64(partition.baseTimestamp)
+        .writeInt64(partition.maxTimestamp)
+        .writeInt64(partition.producerId)
+        .writeInt16(partition.producerEpoch)
+        .writeInt32(partition.baseSequence)
+        .writeArray(partition.records, (encoder, record) => {
+        const recordBody = new encoder_js_1.Encoder()
+            .writeInt8(record.attributes)
+            .writeVarLong(record.timestampDelta)
+            .writeVarInt(record.offsetDelta)
+            .writeVarIntString(record.key)
+            .writeVarIntString(record.value)
+            .writeVarIntArray(record.headers, (encoder, header) => encoder.writeVarIntString(header.key).writeVarIntString(header.value));
+        return encoder.writeVarInt(recordBody.getBufferLength()).writeEncoder(recordBody);
+    })
+        .value();
+    const batchHeader = new encoder_js_1.Encoder()
+        .writeInt32(partition.partitionLeaderEpoch)
+        .writeInt8(2) // magic byte
+        .writeUInt32(unsigned(crc32C(batchBody)))
+        .write(batchBody);
+    const batch = new encoder_js_1.Encoder()
+        .writeInt64(partition.baseOffset)
+        .writeInt32(batchHeader.getBufferLength())
+        .writeEncoder(batchHeader);
+    return batch;
+};
+/*
+Produce Request (Version: 3) => transactional_id acks timeout_ms [topic_data]
+  transactional_id => NULLABLE_STRING
+  acks => INT16
+  timeout_ms => INT32
+  topic_data => name [partition_data]
+    name => STRING
+    partition_data => index records
+      index => INT32
+      records => RECORDS
+
+Produce Response (Version: 3) => [responses] throttle_time_ms
+  responses => name [partition_responses]
+    name => STRING
+    partition_responses => index error_code base_offset log_append_time_ms
+      index => INT32
+      error_code => INT16
+      base_offset => INT64
+      log_append_time_ms => INT64
+  throttle_time_ms => INT32
+*/
+const PRODUCE_V3 = (0, api_js_1.createApi)({
+    apiKey: 0,
+    apiVersion: 3,
+    requestHeaderVersion: 1,
+    responseHeaderVersion: 0,
+    request: (encoder, data) => encoder
+        .writeString(data.transactionalId)
+        .writeInt16(data.acks)
+        .writeInt32(data.timeoutMs)
+        .writeArray(data.topicData, (encoder, topic) => encoder.writeString(topic.name).writeArray(topic.partitionData, (encoder, partition) => {
+        const batch = createBatch(partition);
+        return encoder.writeInt32(partition.index).writeInt32(batch.getBufferLength()).writeEncoder(batch);
+    })),
+    response: (decoder) => {
+        const result = {
+            responses: decoder.readArray((response) => ({
+                name: response.readString(),
+                partitionResponses: response.readArray((partitionResponse) => ({
+                    index: partitionResponse.readInt32(),
+                    errorCode: partitionResponse.readInt16(),
+                    baseOffset: partitionResponse.readInt64(),
+                    logAppendTime: partitionResponse.readInt64(),
+                    logStartOffset: BigInt(0), // Not present in v3 response
+                    recordErrors: [],
+                    errorMessage: null,
+                    tags: {},
+                })),
+                tags: {},
+            })),
+            throttleTimeMs: decoder.readInt32(),
+            tags: {},
+        };
+        result.responses.forEach((topic) => {
+            topic.partitionResponses.forEach((partition) => {
+                if (partition.errorCode !== 0) {
+                    throw new error_js_1.KafkaTSApiError(partition.errorCode, partition.errorMessage, result);
+                }
+            });
+        });
+        return result;
+    },
+});
+/*
+Produce Request (Version: 9) => transactional_id acks timeout_ms [topic_data] _tagged_fields
+  transactional_id => COMPACT_NULLABLE_STRING
+  acks => INT16
+  timeout_ms => INT32
+  topic_data => name [partition_data] _tagged_fields
+    name => COMPACT_STRING
+    partition_data => index records _tagged_fields
+      index => INT32
+      records => COMPACT_RECORDS
+
+Produce Response (Version: 9) => [responses] throttle_time_ms _tagged_fields
+  responses => name [partition_responses] _tagged_fields
+    name => COMPACT_STRING
+    partition_responses => index error_code base_offset log_append_time_ms log_start_offset [record_errors] error_message _tagged_fields
+      index => INT32
+      error_code => INT16
+      base_offset => INT64
+      log_append_time_ms => INT64
+      log_start_offset => INT64
+      record_errors => batch_index batch_index_error_message _tagged_fields
+        batch_index => INT32
+        batch_index_error_message => COMPACT_NULLABLE_STRING
+      error_message => COMPACT_NULLABLE_STRING
+  throttle_time_ms => INT32
+*/
 exports.PRODUCE = (0, api_js_1.createApi)({
     apiKey: 0,
     apiVersion: 9,
+    requestHeaderVersion: 2,
+    responseHeaderVersion: 1,
+    fallback: PRODUCE_V3,
     request: (encoder, data) => encoder
-        .writeUVarInt(0)
         .writeCompactString(data.transactionalId)
         .writeInt16(data.acks)
         .writeInt32(data.timeoutMs)
         .writeCompactArray(data.topicData, (encoder, topic) => encoder
         .writeCompactString(topic.name)
         .writeCompactArray(topic.partitionData, (encoder, partition) => {
-        const batchBody = new encoder_js_1.Encoder()
-            .writeInt16(partition.attributes)
-            .writeInt32(partition.lastOffsetDelta)
-            .writeInt64(partition.baseTimestamp)
-            .writeInt64(partition.maxTimestamp)
-            .writeInt64(partition.producerId)
-            .writeInt16(partition.producerEpoch)
-            .writeInt32(partition.baseSequence)
-            .writeArray(partition.records, (encoder, record) => {
-            const recordBody = new encoder_js_1.Encoder()
-                .writeInt8(record.attributes)
-                .writeVarLong(record.timestampDelta)
-                .writeVarInt(record.offsetDelta)
-                .writeVarIntString(record.key)
-                .writeVarIntString(record.value)
-                .writeVarIntArray(record.headers, (encoder, header) => encoder.writeVarIntString(header.key).writeVarIntString(header.value));
-            return encoder.writeVarInt(recordBody.getBufferLength()).writeEncoder(recordBody);
-        })
-            .value();
-        const batchHeader = new encoder_js_1.Encoder()
-            .writeInt32(partition.partitionLeaderEpoch)
-            .writeInt8(2) // magic byte
-            .writeUInt32(unsigned(crc32C(batchBody)))
-            .write(batchBody);
-        const batch = new encoder_js_1.Encoder()
-            .writeInt64(partition.baseOffset)
-            .writeInt32(batchHeader.getBufferLength())
-            .writeEncoder(batchHeader);
+        const batch = createBatch(partition);
         return encoder
             .writeInt32(partition.index)
             .writeUVarInt(batch.getBufferLength() + 1)
             .writeEncoder(batch)
-            .writeUVarInt(0);
+            .writeTagBuffer();
     })
-        .writeUVarInt(0))
-        .writeUVarInt(0),
+        .writeTagBuffer())
+        .writeTagBuffer(),
     response: (decoder) => {
         const result = {
-            _tag: decoder.readTagBuffer(),
             responses: decoder.readCompactArray((response) => ({
                 name: response.readCompactString(),
                 partitionResponses: response.readCompactArray((partitionResponse) => ({
@@ -64,16 +158,16 @@ exports.PRODUCE = (0, api_js_1.createApi)({
                     logStartOffset: partitionResponse.readInt64(),
                     recordErrors: partitionResponse.readCompactArray((recordError) => ({
                         batchIndex: recordError.readInt32(),
-                        batchIndexError: recordError.readInt16(),
-                        _tag: recordError.readTagBuffer(),
+                        batchIndexErrorMessage: recordError.readCompactString(),
+                        tags: recordError.readTagBuffer(),
                     })),
                     errorMessage: partitionResponse.readCompactString(),
-                    _tag: partitionResponse.readTagBuffer(),
+                    tags: partitionResponse.readTagBuffer(),
                 })),
-                _tag: response.readTagBuffer(),
+                tags: response.readTagBuffer(),
             })),
             throttleTimeMs: decoder.readInt32(),
-            _tag2: decoder.readTagBuffer(),
+            tags: decoder.readTagBuffer(),
         };
         result.responses.forEach((topic) => {
             topic.partitionResponses.forEach((partition) => {

package/dist/api/sasl-authenticate.d.ts

@@ -1,10 +1,12 @@
-export declare const SASL_AUTHENTICATE: import("../utils/api").Api<{
+type SaslAuthenticateRequest = {
     authBytes: Buffer;
-}, {
-    _tag: void;
+};
+type SaslAuthenticateResponse = {
     errorCode: number;
     errorMessage: string | null;
-    authBytes: Buffer<ArrayBufferLike> | null;
+    authBytes: Buffer;
     sessionLifetimeMs: bigint;
-    _tag2: void;
-}>;
+    tags: Record<number, Buffer>;
+};
+export declare const SASL_AUTHENTICATE: import("../utils/api").Api<SaslAuthenticateRequest, SaslAuthenticateResponse>;
+export {};

package/dist/api/sasl-authenticate.js

@@ -3,18 +3,58 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.SASL_AUTHENTICATE = void 0;
 const api_1 = require("../utils/api");
 const error_1 = require("../utils/error");
+/*
+SaslAuthenticate Request (Version: 0) => auth_bytes
+  auth_bytes => BYTES
+
+SaslAuthenticate Response (Version: 0) => error_code error_message auth_bytes
+  error_code => INT16
+  error_message => NULLABLE_STRING
+  auth_bytes => BYTES
+*/
+const SASL_AUTHENTICATE_V0 = (0, api_1.createApi)({
+    apiKey: 36,
+    apiVersion: 0,
+    requestHeaderVersion: 1,
+    responseHeaderVersion: 0,
+    request: (encoder, data) => encoder.writeBytes(data.authBytes),
+    response: (decoder) => {
+        const result = {
+            errorCode: decoder.readInt16(),
+            errorMessage: decoder.readString(),
+            authBytes: decoder.readBytes(),
+            sessionLifetimeMs: BigInt(0),
+            tags: {},
+        };
+        if (result.errorCode)
+            throw new error_1.KafkaTSApiError(result.errorCode, result.errorMessage, result);
+        return result;
+    },
+});
+/*
+SaslAuthenticate Request (Version: 2) => auth_bytes _tagged_fields
+  auth_bytes => COMPACT_BYTES
+
+SaslAuthenticate Response (Version: 2) => error_code error_message auth_bytes session_lifetime_ms _tagged_fields
+  error_code => INT16
+  error_message => COMPACT_NULLABLE_STRING
+  auth_bytes => COMPACT_BYTES
+  session_lifetime_ms => INT64
+*/
 exports.SASL_AUTHENTICATE = (0, api_1.createApi)({
     apiKey: 36,
     apiVersion: 2,
-    request: (encoder, data) => encoder.writeUVarInt(0).writeCompactBytes(data.authBytes).writeUVarInt(0),
+    fallback: SASL_AUTHENTICATE_V0,
+    requestHeaderVersion: 2,
+    responseHeaderVersion: 1,
+    request: (encoder, data) => encoder.writeCompactBytes(data.authBytes).writeTagBuffer(),
     response: (decoder) => {
         const result = {
-            _tag: decoder.readTagBuffer(),
             errorCode: decoder.readInt16(),
             errorMessage: decoder.readCompactString(),
             authBytes: decoder.readCompactBytes(),
             sessionLifetimeMs: decoder.readInt64(),
-            _tag2: decoder.readTagBuffer(),
+            tags: decoder.readTagBuffer(),
         };
         if (result.errorCode)
             throw new error_1.KafkaTSApiError(result.errorCode, result.errorMessage, result);

package/dist/api/sasl-handshake.d.ts

@@ -1,6 +1,9 @@
-export declare const SASL_HANDSHAKE: import("../utils/api").Api<{
+type SaslHandshakeRequest = {
     mechanism: string;
-}, {
+};
+type SaslHandshakeResponse = {
     errorCode: number;
-    mechanisms: (string | null)[];
-}>;
+    mechanisms: string[];
+};
+export declare const SASL_HANDSHAKE: import("../utils/api").Api<SaslHandshakeRequest, SaslHandshakeResponse>;
+export {};

package/dist/api/sasl-handshake.js

@@ -3,9 +3,19 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.SASL_HANDSHAKE = void 0;
 const api_1 = require("../utils/api");
 const error_1 = require("../utils/error");
+/*
+SaslHandshake Request (Version: 1) => mechanism
+  mechanism => STRING
+
+SaslHandshake Response (Version: 1) => error_code [mechanisms]
+  error_code => INT16
+  mechanisms => STRING
+*/
 exports.SASL_HANDSHAKE = (0, api_1.createApi)({
     apiKey: 17,
     apiVersion: 1,
+    requestHeaderVersion: 1,
+    responseHeaderVersion: 0,
     request: (encoder, data) => encoder.writeString(data.mechanism),
     response: (decoder) => {
         const result = {

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

@@ -5,7 +5,7 @@ export type MemberAssignment = {
     memberId: string;
     assignment: Assignment;
 };
-export declare const SYNC_GROUP: import("../utils/api").Api<{
+type SyncGroupRequest = {
     groupId: string;
     generationId: number;
     memberId: string;
@@ -13,12 +13,14 @@ export declare const SYNC_GROUP: import("../utils/api").Api<{
     protocolType: string | null;
     protocolName: string | null;
     assignments: MemberAssignment[];
-}, {
-    _tag: void;
+};
+type SyncGroupResponse = {
     throttleTimeMs: number;
     errorCode: number;
     protocolType: string | null;
     protocolName: string | null;
     assignments: Assignment;
-    _tag2: void;
-}>;
+    tags: Record<number, Buffer>;
+};
+export declare const SYNC_GROUP: import("../utils/api").Api<SyncGroupRequest, SyncGroupResponse>;
+export {};

package/dist/api/sync-group.js

@@ -5,11 +5,69 @@ const api_1 = require("../utils/api");
 const decoder_1 = require("../utils/decoder");
 const encoder_1 = require("../utils/encoder");
 const error_1 = require("../utils/error");
+/*
+SyncGroup Request (Version: 0) => group_id generation_id member_id [assignments]
+  group_id => STRING
+  generation_id => INT32
+  member_id => STRING
+  assignments => member_id assignment
+    member_id => STRING
+    assignment => BYTES
+
+SyncGroup Response (Version: 0) => error_code assignment
+  error_code => INT16
+  assignment => BYTES
+*/
+const SYNC_GROUP_V0 = (0, api_1.createApi)({
+    apiKey: 14,
+    apiVersion: 0,
+    requestHeaderVersion: 1,
+    responseHeaderVersion: 0,
+    request: (encoder, data) => encoder
+        .writeString(data.groupId)
+        .writeInt32(data.generationId)
+        .writeString(data.memberId)
+        .writeArray(data.assignments, (encoder, assignment) => encoder.writeString(assignment.memberId).writeBytes(encodeAssignment(assignment.assignment))),
+    response: (decoder) => {
+        const result = {
+            throttleTimeMs: 0,
+            errorCode: decoder.readInt16(),
+            protocolType: null,
+            protocolName: null,
+            assignments: decodeAssignment(decoder.readBytes()),
+            tags: {},
+        };
+        if (result.errorCode)
+            throw new error_1.KafkaTSApiError(result.errorCode, null, result);
+        return result;
+    },
+});
+/*
+SyncGroup Request (Version: 5) => group_id generation_id member_id group_instance_id protocol_type protocol_name [assignments] _tagged_fields
+  group_id => COMPACT_STRING
+  generation_id => INT32
+  member_id => COMPACT_STRING
+  group_instance_id => COMPACT_NULLABLE_STRING
+  protocol_type => COMPACT_NULLABLE_STRING
+  protocol_name => COMPACT_NULLABLE_STRING
+  assignments => member_id assignment _tagged_fields
+    member_id => COMPACT_STRING
+    assignment => COMPACT_BYTES
+
+SyncGroup Response (Version: 5) => throttle_time_ms error_code protocol_type protocol_name assignment _tagged_fields
+  throttle_time_ms => INT32
+  error_code => INT16
+  protocol_type => COMPACT_NULLABLE_STRING
+  protocol_name => COMPACT_NULLABLE_STRING
+  assignment => COMPACT_BYTES
+*/
 exports.SYNC_GROUP = (0, api_1.createApi)({
     apiKey: 14,
     apiVersion: 5,
+    fallback: SYNC_GROUP_V0,
+    requestHeaderVersion: 2,
+    responseHeaderVersion: 1,
     request: (encoder, data) => encoder
-        .writeUVarInt(0)
         .writeCompactString(data.groupId)
         .writeInt32(data.generationId)
         .writeCompactString(data.memberId)
@@ -19,17 +77,16 @@ exports.SYNC_GROUP = (0, api_1.createApi)({
         .writeCompactArray(data.assignments, (encoder, assignment) => encoder
         .writeCompactString(assignment.memberId)
         .writeCompactBytes(encodeAssignment(assignment.assignment))
-        .writeUVarInt(0))
-        .writeUVarInt(0),
+        .writeTagBuffer())
+        .writeTagBuffer(),
     response: (decoder) => {
         const result = {
-            _tag: decoder.readTagBuffer(),
             throttleTimeMs: decoder.readInt32(),
             errorCode: decoder.readInt16(),
             protocolType: decoder.readCompactString(),
             protocolName: decoder.readCompactString(),
             assignments: decodeAssignment(decoder.readCompactBytes()),
-            _tag2: decoder.readTagBuffer(),
+            tags: decoder.readTagBuffer(),
         };
         if (result.errorCode)
             throw new error_1.KafkaTSApiError(result.errorCode, null, result);

package/dist/broker.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Broker = void 0;
 const api_1 = require("./api");
 const connection_1 = require("./connection");
-const error_1 = require("./utils/error");
+const logger_1 = require("./utils/logger");
 class Broker {
     options;
     connection;
@@ -34,14 +34,15 @@ class Broker {
         const { versions } = await this.sendRequest(api_1.API.API_VERSIONS, {});
         const apiByKey = Object.fromEntries(Object.values(api_1.API).map((api) => [api.apiKey, api]));
         versions.forEach(({ apiKey, minVersion, maxVersion }) => {
-            if (!apiByKey[apiKey]) {
+            const api = apiByKey[apiKey];
+            if (!api) {
                 return;
             }
-            const { apiVersion } = apiByKey[apiKey];
-            if (apiVersion < minVersion || apiVersion > maxVersion) {
-                throw new error_1.KafkaTSError(`API ${apiKey} version ${apiVersion} is not supported by the broker (minVersion=${minVersion}, maxVersion=${maxVersion})`);
+            if (api.apiVersion < minVersion || api.apiVersion > maxVersion) {
+                logger_1.log.warn(`Broker does not support API ${(0, api_1.getApiName)(api)} version ${api.apiVersion} (minVersion=${minVersion}, maxVersion=${maxVersion})`);
             }
         });
+        this.connection.setVersions(versions);
     }
     async saslHandshake() {
         if (!this.options.sasl) {