kafka-ts 1.1.5 → 1.1.6

package/README.md

@@ -2,7 +2,7 @@
 
 **KafkaTS** is a Apache Kafka client library for Node.js. It provides both a low-level API for communicating directly with the Apache Kafka cluster and high-level APIs for publishing and subscribing to Kafka topics.
 
-**Supported Kafka versions:** 3.6 and later
+**Supported Kafka versions:** ^3.6.x, ^4.0.0
 
 ## Installation
 

package/dist/api/create-topics.d.ts

@@ -12,8 +12,8 @@ export declare const CREATE_TOPICS: import("../utils/api").Api<{
             value: string | null;
         }[];
     }[];
-    timeoutMs?: number | undefined;
-    validateOnly?: boolean | undefined;
+    timeoutMs?: number;
+    validateOnly?: boolean;
 }, {
     _tag: void;
     throttleTimeMs: number;

package/dist/api/delete-topics.d.ts

@@ -3,7 +3,7 @@ export declare const DELETE_TOPICS: import("../utils/api").Api<{
         name: string | null;
         topicId: string | null;
     }[];
-    timeoutMs?: number | undefined;
+    timeoutMs?: number;
 }, {
     _tag: void;
     throttleTimeMs: number;

package/dist/api/index.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="node" />
 import { Api } from '../utils/api';
 export declare const API: {
     API_VERSIONS: Api<unknown, {
@@ -13,19 +12,19 @@ export declare const API: {
     CREATE_TOPICS: Api<{
         topics: {
             name: string;
-            numPartitions?: number | undefined;
-            replicationFactor?: number | undefined;
+            numPartitions?: number;
+            replicationFactor?: number;
             assignments?: {
                 partitionIndex: number;
                 brokerIds: number[];
-            }[] | undefined;
+            }[];
             configs?: {
                 name: string;
                 value: string | null;
-            }[] | undefined;
+            }[];
         }[];
-        timeoutMs?: number | undefined;
-        validateOnly?: boolean | undefined;
+        timeoutMs?: number;
+        validateOnly?: boolean;
     }, {
         _tag: void;
         throttleTimeMs: number;
@@ -53,7 +52,7 @@ export declare const API: {
             name: string | null;
             topicId: string | null;
         }[];
-        timeoutMs?: number | undefined;
+        timeoutMs?: number;
     }, {
         _tag: void;
         throttleTimeMs: number;
@@ -213,7 +212,7 @@ export declare const API: {
         members: {
             memberId: string;
             groupInstanceId: string | null;
-            metadata: Buffer;
+            metadata: Buffer<ArrayBufferLike>;
             _tag: void;
         }[];
         _tag2: void;
@@ -269,9 +268,9 @@ export declare const API: {
         topics?: {
             id: string | null;
             name: string;
-        }[] | null | undefined;
-        allowTopicAutoCreation?: boolean | undefined;
-        includeTopicAuthorizedOperations?: boolean | undefined;
+        }[] | null;
+        allowTopicAutoCreation?: boolean;
+        includeTopicAuthorizedOperations?: boolean;
     }, {
         _tag: void;
         throttleTimeMs: number;
@@ -422,7 +421,7 @@ export declare const API: {
         _tag: void;
         errorCode: number;
         errorMessage: string | null;
-        authBytes: Buffer | null;
+        authBytes: Buffer<ArrayBufferLike> | null;
         sessionLifetimeMs: bigint;
         _tag2: void;
     }>;

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

@@ -1,4 +1,3 @@
-/// <reference types="node" />
 export declare const JOIN_GROUP: import("../utils/api").Api<{
     groupId: string;
     sessionTimeoutMs: number;
@@ -27,7 +26,7 @@ export declare const JOIN_GROUP: import("../utils/api").Api<{
     members: {
         memberId: string;
         groupInstanceId: string | null;
-        metadata: Buffer;
+        metadata: Buffer<ArrayBufferLike>;
         _tag: void;
     }[];
     _tag2: void;

package/dist/api/metadata.d.ts

@@ -3,9 +3,9 @@ export declare const METADATA: import("../utils/api").Api<{
     topics?: {
         id: string | null;
         name: string;
-    }[] | null | undefined;
-    allowTopicAutoCreation?: boolean | undefined;
-    includeTopicAuthorizedOperations?: boolean | undefined;
+    }[] | null;
+    allowTopicAutoCreation?: boolean;
+    includeTopicAuthorizedOperations?: boolean;
 }, {
     _tag: void;
     throttleTimeMs: number;

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

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

package/dist/auth/scram.js

@@ -28,7 +28,7 @@ const saslScram = ({ mechanism, keyLength, digest }) => ({ username, password })
         const saltedPassword = await (0, crypto_1.saltPassword)(password, salt, iterations, keyLength, digest);
         const clientKey = (0, crypto_1.hmac)(saltedPassword, 'Client Key', digest);
         const clientKeyHash = (0, crypto_1.hash)(clientKey, digest);
-        let finalMessage = `c=${(0, crypto_1.base64Encode)('n,,')},r=${rnonce}`;
+        let finalMessage = `c=${(0, crypto_1.base64Encode)(Buffer.from('n,,'))},r=${rnonce}`;
         const fullMessage = `${firstMessage},${authBytes.toString()},${finalMessage}`;
         const clientSignature = (0, crypto_1.hmac)(clientKeyHash, fullMessage, digest);
         const clientProof = (0, crypto_1.base64Encode)((0, crypto_1.xor)(clientKey, clientSignature));

package/dist/broker.d.ts

@@ -1,5 +1,3 @@
-/// <reference types="node" />
-/// <reference types="node" />
 import { TcpSocketConnectOpts } from 'net';
 import { TLSSocketOptions } from 'tls';
 import { SendRequest } from './connection';

package/dist/client.d.ts

@@ -1,5 +1,3 @@
-/// <reference types="node" />
-/// <reference types="node" />
 import { TcpSocketConnectOpts } from 'net';
 import { TLSSocketOptions } from 'tls';
 import { SASLProvider } from './broker';

package/dist/cluster.d.ts

@@ -1,5 +1,3 @@
-/// <reference types="node" />
-/// <reference types="node" />
 import { TcpSocketConnectOpts } from 'net';
 import { TLSSocketOptions } from 'tls';
 import { Broker, SASLProvider } from './broker';
@@ -18,6 +16,7 @@ export declare class Cluster {
     private brokerMetadata;
     constructor(options: ClusterOptions);
     connect(): Promise<void>;
+    refreshBrokerMetadata(): Promise<void>;
     ensureConnected(): Promise<void>;
     disconnect(): Promise<void>;
     setSeedBroker: (nodeId: number) => Promise<void>;

package/dist/cluster.js

@@ -1,10 +1,21 @@
 "use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Cluster = void 0;
 const api_1 = require("./api");
 const broker_1 = require("./broker");
 const error_1 = require("./utils/error");
 const logger_1 = require("./utils/logger");
+const tracer_1 = require("./utils/tracer");
+const trace = (0, tracer_1.createTracer)('Cluster');
 class Cluster {
     options;
     seedBroker;
@@ -16,6 +27,9 @@ class Cluster {
     async connect() {
         this.seedBroker = await this.findSeedBroker();
         this.brokerById = {};
+        await this.refreshBrokerMetadata();
+    }
+    async refreshBrokerMetadata() {
         const metadata = await this.sendRequest(api_1.API.METADATA, { topics: [] });
         this.brokerMetadata = Object.fromEntries(metadata.brokers.map((options) => [options.nodeId, options]));
     }
@@ -51,7 +65,7 @@ class Cluster {
     };
     async acquireBroker(nodeId) {
         if (!(nodeId in this.brokerMetadata)) {
-            throw new error_1.KafkaTSError(`Broker ${nodeId} is not available`);
+            throw new error_1.BrokerNotAvailableError(nodeId);
         }
         const broker = new broker_1.Broker({
             clientId: this.options.clientId,
@@ -85,3 +99,9 @@ class Cluster {
     }
 }
 exports.Cluster = Cluster;
+__decorate([
+    trace((nodeId) => ({ nodeId, result: `<Broker ${nodeId}>` })),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Number]),
+    __metadata("design:returntype", Promise)
+], Cluster.prototype, "acquireBroker", null);

package/dist/cluster.test.js

@@ -9,7 +9,7 @@ const auth_1 = require("./auth");
 const client_1 = require("./client");
 const kafka = (0, client_1.createKafkaClient)({
     clientId: 'kafka-ts',
-    bootstrapServers: [{ host: 'localhost', port: 9092 }],
+    bootstrapServers: [{ host: 'localhost', port: 39092 }],
     sasl: (0, auth_1.saslPlain)({ username: 'admin', password: 'admin' }),
     ssl: { ca: (0, fs_1.readFileSync)('./certs/ca.crt').toString() },
 });

package/dist/codecs/types.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="node" />
 export type Codec = {
     compress: (data: Buffer) => Promise<Buffer>;
     decompress: (data: Buffer) => Promise<Buffer>;

package/dist/connection.d.ts

@@ -1,5 +1,3 @@
-/// <reference types="node" />
-/// <reference types="node" />
 import { TcpSocketConnectOpts } from 'net';
 import { TLSSocketOptions } from 'tls';
 import { Api } from './utils/api';

package/dist/connection.js

@@ -21,13 +21,23 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 var __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };

package/dist/consumer/consumer.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="node" />
 import EventEmitter from 'events';
 import { IsolationLevel } from '../api/fetch';
 import { Cluster } from '../cluster';

package/dist/consumer/consumer.js

@@ -206,30 +206,40 @@ class Consumer extends events_1.default {
         await this.consumerGroup?.offsetCommit(topicPartitions);
         this.offsetManager.flush(topicPartitions);
     }
-    fetch(nodeId, assignment) {
+    async fetch(nodeId, assignment) {
         const { rackId, maxWaitMs, minBytes, maxBytes, partitionMaxBytes, isolationLevel } = this.options;
         this.consumerGroup?.handleLastHeartbeat();
-        return this.cluster.sendRequestToNode(nodeId)(api_1.API.FETCH, {
-            maxWaitMs,
-            minBytes,
-            maxBytes,
-            isolationLevel,
-            sessionId: 0,
-            sessionEpoch: -1,
-            topics: Object.entries(assignment).map(([topic, partitions]) => ({
-                topicId: this.metadata.getTopicIdByName(topic),
-                partitions: partitions.map((partition) => ({
-                    partition,
-                    currentLeaderEpoch: -1,
-                    fetchOffset: this.offsetManager.getCurrentOffset(topic, partition),
-                    lastFetchedEpoch: -1,
-                    logStartOffset: -1n,
-                    partitionMaxBytes,
+        try {
+            return await this.cluster.sendRequestToNode(nodeId)(api_1.API.FETCH, {
+                maxWaitMs,
+                minBytes,
+                maxBytes,
+                isolationLevel,
+                sessionId: 0,
+                sessionEpoch: -1,
+                topics: Object.entries(assignment).map(([topic, partitions]) => ({
+                    topicId: this.metadata.getTopicIdByName(topic),
+                    partitions: partitions.map((partition) => ({
+                        partition,
+                        currentLeaderEpoch: -1,
+                        fetchOffset: this.offsetManager.getCurrentOffset(topic, partition),
+                        lastFetchedEpoch: -1,
+                        logStartOffset: -1n,
+                        partitionMaxBytes,
+                    })),
                 })),
-            })),
-            forgottenTopicsData: [],
-            rackId,
-        });
+                forgottenTopicsData: [],
+                rackId,
+            });
+        }
+        catch (error) {
+            if (error instanceof error_1.KafkaTSApiError && error.errorCode === api_1.API_ERROR.OFFSET_OUT_OF_RANGE) {
+                logger_1.log.warn('Offset out of range. Resetting offsets.');
+                await this.offsetManager.fetchOffsets({ fromTimestamp: this.options.fromTimestamp });
+                return this.fetch(nodeId, assignment);
+            }
+            throw error;
+        }
     }
 }
 exports.Consumer = Consumer;

package/dist/consumer/fetcher.d.ts

@@ -1,5 +1,3 @@
-/// <reference types="node" />
-/// <reference types="node" />
 import { EventEmitter } from 'stream';
 import { FetchResponse } from '../api/fetch';
 import { Assignment } from '../api/sync-group';

package/dist/consumer/processor.d.ts

@@ -1,5 +1,3 @@
-/// <reference types="node" />
-/// <reference types="node" />
 import { EventEmitter } from 'stream';
 import { Batch } from '../types';
 type ProcessorOptions = {

package/dist/producer/producer.js

@@ -53,58 +53,70 @@ class Producer {
         const nodeTopicPartitionMessages = (0, messages_to_topic_partition_leaders_1.distributeMessagesToTopicPartitionLeaders)(partitionedMessages, this.metadata.getTopicPartitionLeaderIds());
         try {
             await Promise.all(Object.entries(nodeTopicPartitionMessages).map(async ([nodeId, topicPartitionMessages]) => {
-                await this.lock.acquire([`node:${nodeId}`], async () => {
-                    const topicData = Object.entries(topicPartitionMessages).map(([topic, partitionMessages]) => ({
-                        name: topic,
-                        partitionData: Object.entries(partitionMessages).map(([partition, messages]) => {
-                            const partitionIndex = parseInt(partition);
-                            let baseTimestamp;
-                            let maxTimestamp;
-                            messages.forEach(({ timestamp = defaultTimestamp }) => {
-                                if (!baseTimestamp || timestamp < baseTimestamp) {
-                                    baseTimestamp = timestamp;
-                                }
-                                if (!maxTimestamp || timestamp > maxTimestamp) {
-                                    maxTimestamp = timestamp;
-                                }
-                            });
-                            return {
-                                index: partitionIndex,
-                                baseOffset: 0n,
-                                partitionLeaderEpoch: -1,
-                                attributes: 0,
-                                lastOffsetDelta: messages.length - 1,
-                                baseTimestamp: baseTimestamp ?? 0n,
-                                maxTimestamp: maxTimestamp ?? 0n,
-                                producerId: this.producerId,
-                                producerEpoch: 0,
-                                baseSequence: this.getSequence(topic, partitionIndex),
-                                records: messages.map((message, index) => ({
+                try {
+                    await this.lock.acquire([`node:${nodeId}`], async () => {
+                        const topicData = Object.entries(topicPartitionMessages).map(([topic, partitionMessages]) => ({
+                            name: topic,
+                            partitionData: Object.entries(partitionMessages).map(([partition, messages]) => {
+                                const partitionIndex = parseInt(partition);
+                                let baseTimestamp;
+                                let maxTimestamp;
+                                messages.forEach(({ timestamp = defaultTimestamp }) => {
+                                    if (!baseTimestamp || timestamp < baseTimestamp) {
+                                        baseTimestamp = timestamp;
+                                    }
+                                    if (!maxTimestamp || timestamp > maxTimestamp) {
+                                        maxTimestamp = timestamp;
+                                    }
+                                });
+                                return {
+                                    index: partitionIndex,
+                                    baseOffset: 0n,
+                                    partitionLeaderEpoch: -1,
                                     attributes: 0,
-                                    timestampDelta: (message.timestamp ?? defaultTimestamp) - (baseTimestamp ?? 0n),
-                                    offsetDelta: index,
-                                    key: message.key ?? null,
-                                    value: message.value,
-                                    headers: Object.entries(message.headers ?? {}).map(([key, value]) => ({
-                                        key,
-                                        value,
+                                    lastOffsetDelta: messages.length - 1,
+                                    baseTimestamp: baseTimestamp ?? 0n,
+                                    maxTimestamp: maxTimestamp ?? 0n,
+                                    producerId: this.producerId,
+                                    producerEpoch: 0,
+                                    baseSequence: this.getSequence(topic, partitionIndex),
+                                    records: messages.map((message, index) => ({
+                                        attributes: 0,
+                                        timestampDelta: (message.timestamp ?? defaultTimestamp) - (baseTimestamp ?? 0n),
+                                        offsetDelta: index,
+                                        key: message.key ?? null,
+                                        value: message.value,
+                                        headers: Object.entries(message.headers ?? {}).map(([key, value]) => ({
+                                            key,
+                                            value,
+                                        })),
                                     })),
-                                })),
-                            };
-                        }),
-                    }));
-                    await this.cluster.sendRequestToNode(parseInt(nodeId))(api_1.API.PRODUCE, {
-                        transactionalId: null,
-                        acks,
-                        timeoutMs: 30000,
-                        topicData,
-                    });
-                    topicData.forEach(({ name, partitionData }) => {
-                        partitionData.forEach(({ index, records }) => {
-                            this.updateSequence(name, index, records.length);
+                                };
+                            }),
+                        }));
+                        await this.cluster.sendRequestToNode(parseInt(nodeId))(api_1.API.PRODUCE, {
+                            transactionalId: null,
+                            acks,
+                            timeoutMs: 30000,
+                            topicData,
+                        });
+                        topicData.forEach(({ name, partitionData }) => {
+                            partitionData.forEach(({ index, records }) => {
+                                this.updateSequence(name, index, records.length);
+                            });
                         });
                     });
-                });
+                }
+                catch (error) {
+                    if (error instanceof error_1.BrokerNotAvailableError || (error instanceof error_1.KafkaTSApiError && error.errorCode === api_1.API_ERROR.NOT_LEADER_OR_FOLLOWER)) {
+                        logger_1.log.debug('Refreshing broker metadata', { reason: error.message, nodeId });
+                        await this.cluster.refreshBrokerMetadata();
+                        await this.metadata.fetchMetadata({ topics, allowTopicAutoCreation });
+                        const messages = Object.values(topicPartitionMessages).flatMap(partitionMessages => Object.values(partitionMessages).flat()).map(({ partition, ...message }) => message);
+                        return this.send(messages, { acks });
+                    }
+                    throw error;
+                }
             }));
         }
         catch (error) {

package/dist/utils/crypto.d.ts

@@ -1,8 +1,7 @@
-/// <reference types="node" />
 export declare const generateNonce: () => string;
-export declare const saltPassword: (password: string, salt: string, iterations: number, keyLength: number, digest: string) => Promise<Buffer>;
-export declare const base64Encode: (input: Buffer | string) => string;
+export declare const saltPassword: (password: string, salt: string, iterations: number, keyLength: number, digest: string) => Promise<Buffer<ArrayBufferLike>>;
+export declare const base64Encode: (input: Buffer) => string;
 export declare const base64Decode: (input: string) => string;
-export declare const hash: (data: Buffer, digest: string) => Buffer;
-export declare const hmac: (key: Buffer, data: Buffer | string, digest: string) => Buffer;
-export declare const xor: (a: Buffer, b: Buffer) => Buffer;
+export declare const hash: (data: Buffer, digest: string) => Buffer<ArrayBufferLike>;
+export declare const hmac: (key: Buffer, data: Buffer | string, digest: string) => Buffer<ArrayBufferLike>;
+export declare const xor: (a: Buffer, b: Buffer) => Buffer<ArrayBuffer>;

package/dist/utils/decoder.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="node" />
 export declare class Decoder {
     private buffer;
     private offset;
@@ -24,8 +23,8 @@ export declare class Decoder {
     readCompactArray<T>(callback: (opts: Decoder) => T): T[];
     readVarIntArray<T>(callback: (opts: Decoder) => T): T[];
     readRecords<T>(callback: (opts: Decoder) => T): T[];
-    read(length?: number): Buffer;
-    readBytes(): Buffer;
-    readCompactBytes(): Buffer | null;
+    read(length?: number): Buffer<ArrayBufferLike>;
+    readBytes(): Buffer<ArrayBufferLike>;
+    readCompactBytes(): Buffer<ArrayBufferLike> | null;
     readTagBuffer(): void;
 }

package/dist/utils/encoder.d.ts

@@ -1,7 +1,6 @@
-/// <reference types="node" />
 export declare class Encoder {
     private chunks;
-    getChunks(): Buffer[];
+    getChunks(): Buffer<ArrayBufferLike>[];
     getBufferLength(): number;
     write(...buffers: Buffer[]): this;
     writeEncoder(encoder: Encoder): this;
@@ -24,5 +23,5 @@ export declare class Encoder {
     writeVarIntArray<T>(arr: T[], callback: (encoder: Encoder, item: T) => Encoder): this;
     writeBytes(value: Buffer): this;
     writeCompactBytes(value: Buffer): this;
-    value(): Buffer;
+    value(): Buffer<ArrayBuffer>;
 }

package/dist/utils/error.d.ts

@@ -9,5 +9,9 @@ export declare class KafkaTSApiError<T = any> extends KafkaTSError {
     request: unknown | undefined;
     constructor(errorCode: number, errorMessage: string | null, response: T);
 }
+export declare class BrokerNotAvailableError extends KafkaTSError {
+    brokerId: number;
+    constructor(brokerId: number);
+}
 export declare class ConnectionError extends KafkaTSError {
 }

package/dist/utils/error.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ConnectionError = exports.KafkaTSApiError = exports.KafkaTSError = void 0;
+exports.ConnectionError = exports.BrokerNotAvailableError = exports.KafkaTSApiError = exports.KafkaTSError = void 0;
 const api_1 = require("../api");
 class KafkaTSError extends Error {
     constructor(message) {
@@ -24,6 +24,14 @@ class KafkaTSApiError extends KafkaTSError {
     }
 }
 exports.KafkaTSApiError = KafkaTSApiError;
+class BrokerNotAvailableError extends KafkaTSError {
+    brokerId;
+    constructor(brokerId) {
+        super(`Broker ${brokerId} is not available`);
+        this.brokerId = brokerId;
+    }
+}
+exports.BrokerNotAvailableError = BrokerNotAvailableError;
 class ConnectionError extends KafkaTSError {
 }
 exports.ConnectionError = ConnectionError;

package/dist/utils/lock.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="node" />
 import EventEmitter from 'events';
 export declare class Lock extends EventEmitter {
     private locks;

package/dist/utils/murmur2.d.ts

@@ -1,3 +1,2 @@
-/// <reference types="node" />
 export declare const murmur2: (data: Buffer) => number;
 export declare const toPositive: (input: number) => number;

package/dist/utils/tracer.js

@@ -11,8 +11,8 @@ class DebugTracer {
         const startTime = Date.now();
         const onEnd = (result) => {
             logger_1.log.debug(`[${module}.${method}] ${metadata?.message ?? ''} +${Date.now() - startTime}ms`, {
-                ...metadata,
                 ...(!!result && { result }),
+                ...metadata,
             });
             return result;
         };

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "kafka-ts",
-    "version": "1.1.5",
+    "version": "1.1.6",
     "main": "dist/index.js",
     "author": "Priit Käärd",
     "license": "MIT",
@@ -9,8 +9,8 @@
         "url": "https://github.com/priitkaard/kafka-ts.git"
     },
     "scripts": {
-        "up": "npm run down && KAFKA_VERSION=3.7.1 docker-compose up -d && sleep 5 && bash ./scripts/create-scram-user.sh",
-        "down": "KAFKA_VERSION=3.7.1 docker-compose down",
+        "up": "npm run down && KAFKA_VERSION=4.0.0 docker-compose up -d && sleep 5 && bash ./scripts/create-scram-user.sh",
+        "down": "KAFKA_VERSION=4.0.0 docker-compose down",
         "version:prerelease": "npm version prerelease --preid=beta",
         "version:patch": "npm version patch",
         "version:major": "npm version major",
@@ -20,10 +20,10 @@
         "test": "vitest --testTimeout 60000 --bail 1"
     },
     "devDependencies": {
-        "@types/node": "^20.12.12",
-        "prettier": "^3.3.3",
-        "typescript": "^5.4.5",
-        "vitest": "^1.6.1"
+        "@types/node": "^22.14.1",
+        "prettier": "^3.5.3",
+        "typescript": "^5.8.3",
+        "vitest": "^3.1.1"
     },
     "keywords": [
         "kafka",