kafka-ts 1.3.1-beta.4 → 1.3.1-beta.6

package/dist/api/find-coordinator.js

@@ -8,44 +8,45 @@ exports.KEY_TYPE = {
     TRANSACTION: 1,
 };
 /*
-FindCoordinator Request (Version: 1) => key key_type
-  key => STRING
+FindCoordinator Request (Version: 3) => key key_type _tagged_fields
+  key => COMPACT_STRING
   key_type => INT8
 
-FindCoordinator Response (Version: 1) => throttle_time_ms error_code error_message node_id host port
+FindCoordinator Response (Version: 3) => throttle_time_ms error_code error_message node_id host port _tagged_fields
   throttle_time_ms => INT32
   error_code => INT16
-  error_message => NULLABLE_STRING
+  error_message => COMPACT_NULLABLE_STRING
   node_id => INT32
-  host => STRING
+  host => COMPACT_STRING
   port => INT32
 */
-const FIND_COORDINATOR_V1 = (0, api_1.createApi)({
+const FIND_COORDINATOR_V3 = (0, api_1.createApi)({
     apiKey: 10,
-    apiVersion: 1,
-    requestHeaderVersion: 1,
-    responseHeaderVersion: 0,
-    request: (encoder, data) => encoder.writeString(data.keys[0]).writeInt8(data.keyType),
+    apiVersion: 3,
+    requestHeaderVersion: 2,
+    responseHeaderVersion: 1,
+    request: (encoder, data) => encoder
+        .writeCompactString(data.keys[0])
+        .writeInt8(data.keyType)
+        .writeTagBuffer(),
     response: (decoder) => {
         const result = {
             throttleTimeMs: decoder.readInt32(),
-            errorCode: decoder.readInt16(),
-            errorMessage: decoder.readString(),
             coordinators: [
                 {
-                    key: '', // Key not present in v1 response
+                    key: '',
+                    errorCode: decoder.readInt16(),
+                    errorMessage: decoder.readCompactString(),
                     nodeId: decoder.readInt32(),
-                    host: decoder.readString(),
+                    host: decoder.readCompactString(),
                     port: decoder.readInt32(),
-                    errorCode: 0,
-                    errorMessage: null,
                     tags: {},
                 },
             ],
-            tags: {},
+            tags: decoder.readTagBuffer(),
         };
-        if (result.errorCode)
-            throw new error_1.KafkaTSApiError(result.errorCode, result.errorMessage, result);
+        if (result.coordinators[0].errorCode)
+            throw new error_1.KafkaTSApiError(result.coordinators[0].errorCode, result.coordinators[0].errorMessage, result);
         return result;
     },
 });
@@ -67,7 +68,7 @@ FindCoordinator Response (Version: 4) => throttle_time_ms [coordinators] _tagged
 exports.FIND_COORDINATOR = (0, api_1.createApi)({
     apiKey: 10,
     apiVersion: 4,
-    fallback: FIND_COORDINATOR_V1,
+    fallback: FIND_COORDINATOR_V3,
     requestHeaderVersion: 2,
     responseHeaderVersion: 1,
     request: (encoder, data) => encoder

package/dist/api/join-group.js

@@ -5,60 +5,67 @@ const api_1 = require("../utils/api");
 const encoder_1 = require("../utils/encoder");
 const error_1 = require("../utils/error");
 /*
-JoinGroup Request (Version: 0) => group_id session_timeout_ms member_id protocol_type [protocols]
-  group_id => STRING
+JoinGroup Request (Version: 6) => group_id session_timeout_ms rebalance_timeout_ms member_id group_instance_id protocol_type [protocols] _tagged_fields
+  group_id => COMPACT_STRING
   session_timeout_ms => INT32
-  member_id => STRING
-  protocol_type => STRING
-  protocols => name metadata
-    name => STRING
-    metadata => BYTES
+  rebalance_timeout_ms => INT32
+  member_id => COMPACT_STRING
+  group_instance_id => COMPACT_NULLABLE_STRING
+  protocol_type => COMPACT_STRING
+  protocols => name metadata _tagged_fields
+    name => COMPACT_STRING
+    metadata => COMPACT_BYTES
 
-JoinGroup Response (Version: 0) => error_code generation_id protocol_name leader member_id [members]
+JoinGroup Response (Version: 6) => throttle_time_ms error_code generation_id protocol_name leader member_id [members] _tagged_fields
+  throttle_time_ms => INT32
   error_code => INT16
   generation_id => INT32
-  protocol_name => STRING
-  leader => STRING
-  member_id => STRING
-  members => member_id metadata
-    member_id => STRING
-    metadata => BYTES
+  protocol_name => COMPACT_STRING
+  leader => COMPACT_STRING
+  member_id => COMPACT_STRING
+  members => member_id group_instance_id metadata _tagged_fields
+    member_id => COMPACT_STRING
+    group_instance_id => COMPACT_NULLABLE_STRING
+    metadata => COMPACT_BYTES
 */
-const JOIN_GROUP_V0 = (0, api_1.createApi)({
+const JOIN_GROUP_V6 = (0, api_1.createApi)({
     apiKey: 11,
-    apiVersion: 0,
-    requestHeaderVersion: 1,
-    responseHeaderVersion: 0,
+    apiVersion: 6,
+    requestHeaderVersion: 2,
+    responseHeaderVersion: 1,
     request: (encoder, data) => encoder
-        .writeString(data.groupId)
+        .writeCompactString(data.groupId)
         .writeInt32(data.sessionTimeoutMs)
-        .writeString(data.memberId)
-        .writeString(data.protocolType)
-        .writeArray(data.protocols, (encoder, protocol) => {
+        .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.writeString(protocol.name).writeBytes(metadata);
-    }),
+        return encoder.writeCompactString(protocol.name).writeCompactBytes(metadata).writeTagBuffer();
+    })
+        .writeTagBuffer(),
     response: (decoder) => {
         const result = {
-            throttleTimeMs: 0,
+            throttleTimeMs: decoder.readInt32(),
             errorCode: decoder.readInt16(),
             generationId: decoder.readInt32(),
             protocolType: null,
-            protocolName: decoder.readString(),
-            leader: decoder.readString(),
+            protocolName: decoder.readCompactString(),
+            leader: decoder.readCompactString(),
             skipAssignment: false,
-            memberId: decoder.readString(),
-            members: decoder.readArray((decoder) => ({
-                memberId: decoder.readString(),
-                groupInstanceId: null,
-                metadata: decoder.readBytes(),
-                tags: {},
+            memberId: decoder.readCompactString(),
+            members: decoder.readCompactArray((decoder) => ({
+                memberId: decoder.readCompactString(),
+                groupInstanceId: decoder.readCompactString(),
+                metadata: decoder.readCompactBytes(),
+                tags: decoder.readTagBuffer(),
             })),
-            tags: {},
+            tags: decoder.readTagBuffer(),
         };
         if (result.errorCode)
             throw new error_1.KafkaTSApiError(result.errorCode, null, result);
@@ -95,7 +102,7 @@ JoinGroup Response (Version: 9) => throttle_time_ms error_code generation_id pro
 exports.JOIN_GROUP = (0, api_1.createApi)({
     apiKey: 11,
     apiVersion: 9,
-    fallback: JOIN_GROUP_V0,
+    fallback: JOIN_GROUP_V6,
     requestHeaderVersion: 2,
     responseHeaderVersion: 1,
     request: (encoder, data) => encoder

package/dist/api/leave-group.js

@@ -4,28 +4,50 @@ exports.LEAVE_GROUP = void 0;
 const api_1 = require("../utils/api");
 const error_1 = require("../utils/error");
 /*
-LeaveGroup Request (Version: 0) => group_id member_id
-  group_id => STRING
-  member_id => STRING
+LeaveGroup Request (Version: 4) => group_id [members] _tagged_fields
+  group_id => COMPACT_STRING
+  members => member_id group_instance_id _tagged_fields
+    member_id => COMPACT_STRING
+    group_instance_id => COMPACT_NULLABLE_STRING
 
-LeaveGroup Response (Version: 0) => error_code
+LeaveGroup Response (Version: 4) => throttle_time_ms error_code [members] _tagged_fields
+  throttle_time_ms => INT32
   error_code => INT16
+  members => member_id group_instance_id error_code _tagged_fields
+    member_id => COMPACT_STRING
+    group_instance_id => COMPACT_NULLABLE_STRING
+    error_code => INT16
 */
-const LEAVE_GROUP_V0 = (0, api_1.createApi)({
+const LEAVE_GROUP_V4 = (0, api_1.createApi)({
     apiKey: 13,
-    apiVersion: 0,
-    requestHeaderVersion: 1,
-    responseHeaderVersion: 0,
-    request: (encoder, body) => encoder.writeString(body.groupId).writeString(body.members[0].memberId),
+    apiVersion: 4,
+    requestHeaderVersion: 2,
+    responseHeaderVersion: 1,
+    request: (encoder, body) => encoder
+        .writeCompactString(body.groupId)
+        .writeCompactArray(body.members, (encoder, member) => encoder
+        .writeCompactString(member.memberId)
+        .writeCompactString(member.groupInstanceId)
+        .writeTagBuffer())
+        .writeTagBuffer(),
     response: (decoder) => {
         const result = {
-            throttleTimeMs: 0,
+            throttleTimeMs: decoder.readInt32(),
             errorCode: decoder.readInt16(),
-            members: [],
-            tags: {},
+            members: decoder.readCompactArray((decoder) => ({
+                memberId: decoder.readCompactString(),
+                groupInstanceId: decoder.readCompactString(),
+                errorCode: decoder.readInt16(),
+                tags: decoder.readTagBuffer(),
+            })),
+            tags: 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;
     },
 });
@@ -48,7 +70,7 @@ LeaveGroup Response (Version: 5) => throttle_time_ms error_code [members] _tagge
 exports.LEAVE_GROUP = (0, api_1.createApi)({
     apiKey: 13,
     apiVersion: 5,
-    fallback: LEAVE_GROUP_V0,
+    fallback: LEAVE_GROUP_V4,
     requestHeaderVersion: 2,
     responseHeaderVersion: 1,
     request: (encoder, body) => encoder

package/dist/api/offset-fetch.js

@@ -4,61 +4,71 @@ 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
+OffsetFetch Request (Version: 6) => group_id [topics] _tagged_fields
+  group_id => COMPACT_STRING
+  topics => name [partition_indexes] _tagged_fields
+    name => COMPACT_STRING
     partition_indexes => INT32
 
-OffsetFetch Response (Version: 1) => [topics]
-  topics => name [partitions]
-    name => STRING
-    partitions => partition_index committed_offset metadata error_code
+OffsetFetch Response (Version: 6) => throttle_time_ms [topics] error_code _tagged_fields
+  throttle_time_ms => INT32
+  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
-      metadata => NULLABLE_STRING
+      committed_leader_epoch => INT32
+      metadata => COMPACT_NULLABLE_STRING
       error_code => INT16
+  error_code => INT16
 */
-const OFFSET_FETCH_V1 = (0, api_1.createApi)({
+const OFFSET_FETCH_V6 = (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))),
+    apiVersion: 6,
+    requestHeaderVersion: 2,
+    responseHeaderVersion: 1,
+    request: (encoder, data) => {
+        if (data.groups.length !== 1)
+            throw new Error('OffsetFetch v6 requires exactly 1 group');
+        const [group] = data.groups;
+        return encoder
+            .writeCompactString(group.groupId)
+            .writeCompactArray(group.topics, (encoder, topic) => encoder
+            .writeCompactString(topic.name)
+            .writeCompactArray(topic.partitionIndexes, (encoder, partitionIndex) => encoder.writeInt32(partitionIndex))
+            .writeTagBuffer())
+            .writeTagBuffer();
+    },
     response: (decoder) => {
         const result = {
-            throttleTimeMs: 0,
+            throttleTimeMs: decoder.readInt32(),
             groups: [
                 {
-                    groupId: '', // Not provided in v1 response
-                    topics: decoder.readArray((decoder) => ({
-                        name: decoder.readString(),
-                        partitions: decoder.readArray((decoder) => ({
+                    groupId: '',
+                    topics: decoder.readCompactArray((decoder) => ({
+                        name: decoder.readCompactString(),
+                        partitions: decoder.readCompactArray((decoder) => ({
                             partitionIndex: decoder.readInt32(),
                             committedOffset: decoder.readInt64(),
-                            committedLeaderEpoch: -1,
-                            committedMetadata: decoder.readString(),
+                            committedLeaderEpoch: decoder.readInt32(),
+                            committedMetadata: decoder.readCompactString(),
                             errorCode: decoder.readInt16(),
-                            tags: {},
+                            tags: decoder.readTagBuffer(),
                         })),
-                        tags: {},
+                        tags: decoder.readTagBuffer(),
                     })),
-                    errorCode: 0,
+                    errorCode: decoder.readInt16(),
                     tags: {},
                 },
             ],
-            tags: {},
+            tags: decoder.readTagBuffer(),
         };
-        result.groups.forEach((group) => {
-            group.topics.forEach((topic) => {
-                topic.partitions.forEach((partition) => {
-                    if (partition.errorCode)
-                        throw new error_1.KafkaTSApiError(partition.errorCode, null, result);
-                });
+        if (result.groups[0].errorCode)
+            throw new error_1.KafkaTSApiError(result.groups[0].errorCode, null, result);
+        result.groups[0].topics.forEach((topic) => {
+            topic.partitions.forEach((partition) => {
+                if (partition.errorCode)
+                    throw new error_1.KafkaTSApiError(partition.errorCode, null, result);
             });
         });
         return result;
@@ -90,7 +100,7 @@ OffsetFetch Response (Version: 8) => throttle_time_ms [groups] _tagged_fields
 exports.OFFSET_FETCH = (0, api_1.createApi)({
     apiKey: 9,
     apiVersion: 8,
-    fallback: OFFSET_FETCH_V1,
+    fallback: OFFSET_FETCH_V6,
     requestHeaderVersion: 2,
     responseHeaderVersion: 1,
     request: (encoder, data) => encoder

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "kafka-ts",
-    "version": "1.3.1-beta.4",
+    "version": "1.3.1-beta.6",
     "main": "dist/index.js",
     "author": "Priit Käärd",
     "license": "MIT",