kafka-ts 1.2.0 → 1.3.0

package/dist/consumer/consumer-group.js

@@ -48,6 +48,9 @@ class ConsumerGroup {
             }
             catch (error) {
                 this.heartbeatError = error;
+                if (error instanceof error_1.KafkaTSApiError && error.errorCode === api_1.API_ERROR.REBALANCE_IN_PROGRESS) {
+                    this.options.consumer.emit('rebalanceInProgress');
+                }
             }
         }, 5000);
     }

package/dist/consumer/consumer.d.ts

@@ -21,11 +21,13 @@ export type ConsumerOptions = {
     retrier?: Retrier;
     onBatch: (messages: Required<Message>[], context: {
         resolveOffset: (message: Pick<Required<Message>, 'topic' | 'partition' | 'offset'>) => void;
+        abortSignal: AbortSignal;
     }) => unknown;
 };
 export declare class Consumer extends EventEmitter<{
     offsetCommit: [];
     heartbeat: [];
+    rebalanceInProgress: [];
 }> {
     private cluster;
     private options;

package/dist/consumer/consumer.js

@@ -75,6 +75,7 @@ class Consumer extends events_1.default {
                 consumer: this,
             })
             : undefined;
+        this.setMaxListeners(Infinity);
     }
     async start() {
         this.stopHook = undefined;
@@ -191,26 +192,34 @@ class Consumer extends events_1.default {
         if (!messages.length) {
             return;
         }
+        const commitOffset = () => this.consumerGroup?.offsetCommit(topicPartitions).then(() => this.offsetManager.flush(topicPartitions));
         const resolveOffset = (message) => this.offsetManager.resolve(message.topic, message.partition, message.offset + 1n);
+        const abortController = new AbortController();
+        const onRebalance = () => {
+            abortController.abort();
+            commitOffset()?.catch();
+        };
+        this.once('rebalanceInProgress', onRebalance);
         try {
-            await retrier(() => options.onBatch(messages.filter((message) => !this.offsetManager.isResolved(message)), { resolveOffset }));
+            await retrier(() => options.onBatch(messages.filter((message) => !this.offsetManager.isResolved(message)), { resolveOffset, abortSignal: abortController.signal }));
         }
         catch (error) {
-            await this.consumerGroup
-                ?.offsetCommit(topicPartitions)
-                .then(() => this.offsetManager.flush(topicPartitions))
-                .catch();
+            await commitOffset()?.catch();
             throw error;
         }
-        response.responses.forEach(({ topicId, partitions }) => {
-            partitions.forEach(({ partitionIndex, records }) => {
-                records.forEach(({ baseOffset, lastOffsetDelta }) => {
-                    this.offsetManager.resolve(this.metadata.getTopicNameById(topicId), partitionIndex, baseOffset + BigInt(lastOffsetDelta) + 1n);
+        finally {
+            this.off('rebalanceInProgress', onRebalance);
+        }
+        if (!abortController.signal.aborted) {
+            response.responses.forEach(({ topicId, partitions }) => {
+                partitions.forEach(({ partitionIndex, records }) => {
+                    records.forEach(({ baseOffset, lastOffsetDelta }) => {
+                        this.offsetManager.resolve(this.metadata.getTopicNameById(topicId), partitionIndex, baseOffset + BigInt(lastOffsetDelta) + 1n);
+                    });
                 });
             });
-        });
-        await this.consumerGroup?.offsetCommit(topicPartitions);
-        this.offsetManager.flush(topicPartitions);
+        }
+        await commitOffset();
     }
     async fetch(nodeId, assignment) {
         return (0, retry_1.withRetry)(this.handleError.bind(this))(async () => {

package/dist/utils/decoder.js

@@ -110,21 +110,23 @@ class Decoder {
     }
     readArray(callback) {
         const length = this.readInt32();
-        const results = new Array(length);
+        const results = new Array(Math.max(length, 0));
         for (let i = 0; i < length; i++)
             results[i] = callback(this);
         return results;
     }
     readCompactArray(callback) {
         const length = this.readUVarInt() - 1;
-        const results = new Array(length);
+        const results = new Array(Math.max(length, 0));
         for (let i = 0; i < length; i++)
             results[i] = callback(this);
         return results;
     }
     readVarIntArray(callback) {
         const length = this.readVarInt();
-        const results = Array.from({ length }).map(() => callback(this));
+        const results = new Array(Math.max(length, 0));
+        for (let i = 0; i < length; i++)
+            results[i] = callback(this);
         return results;
     }
     readRecords(callback) {

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "kafka-ts",
-    "version": "1.2.0",
+    "version": "1.3.0",
     "main": "dist/index.js",
     "author": "Priit Käärd",
     "license": "MIT",
@@ -13,6 +13,7 @@
         "down": "KAFKA_VERSION=4.0.0 docker-compose down",
         "version:prerelease": "npm version prerelease --preid=beta",
         "version:patch": "npm version patch",
+        "version:minor": "npm version minor",
         "version:major": "npm version major",
         "format": "prettier --write .",
         "build": "tsc",