kafka-ts 1.1.6 → 1.1.8

package/dist/api/index.d.ts

@@ -451,125 +451,126 @@ export declare const API: {
 };
 export declare const getApiName: <Request, Response>(api: Api<Request, Response>) => string;
 export declare const API_ERROR: {
-    UNKNOWN_SERVER_ERROR: number;
-    OFFSET_OUT_OF_RANGE: number;
-    CORRUPT_MESSAGE: number;
-    UNKNOWN_TOPIC_OR_PARTITION: number;
-    INVALID_FETCH_SIZE: number;
-    LEADER_NOT_AVAILABLE: number;
-    NOT_LEADER_OR_FOLLOWER: number;
-    REQUEST_TIMED_OUT: number;
-    BROKER_NOT_AVAILABLE: number;
-    REPLICA_NOT_AVAILABLE: number;
-    MESSAGE_TOO_LARGE: number;
-    STALE_CONTROLLER_EPOCH: number;
-    OFFSET_METADATA_TOO_LARGE: number;
-    NETWORK_EXCEPTION: number;
-    COORDINATOR_LOAD_IN_PROGRESS: number;
-    COORDINATOR_NOT_AVAILABLE: number;
-    NOT_COORDINATOR: number;
-    INVALID_TOPIC_EXCEPTION: number;
-    RECORD_LIST_TOO_LARGE: number;
-    NOT_ENOUGH_REPLICAS: number;
-    NOT_ENOUGH_REPLICAS_AFTER_APPEND: number;
-    INVALID_REQUIRED_ACKS: number;
-    ILLEGAL_GENERATION: number;
-    INCONSISTENT_GROUP_PROTOCOL: number;
-    INVALID_GROUP_ID: number;
-    UNKNOWN_MEMBER_ID: number;
-    INVALID_SESSION_TIMEOUT: number;
-    REBALANCE_IN_PROGRESS: number;
-    INVALID_COMMIT_OFFSET_SIZE: number;
-    TOPIC_AUTHORIZATION_FAILED: number;
-    GROUP_AUTHORIZATION_FAILED: number;
-    CLUSTER_AUTHORIZATION_FAILED: number;
-    INVALID_TIMESTAMP: number;
-    UNSUPPORTED_SASL_MECHANISM: number;
-    ILLEGAL_SASL_STATE: number;
-    UNSUPPORTED_VERSION: number;
-    TOPIC_ALREADY_EXISTS: number;
-    INVALID_PARTITIONS: number;
-    INVALID_REPLICATION_FACTOR: number;
-    INVALID_REPLICA_ASSIGNMENT: number;
-    INVALID_CONFIG: number;
-    NOT_CONTROLLER: number;
-    INVALID_REQUEST: number;
-    UNSUPPORTED_FOR_MESSAGE_FORMAT: number;
-    POLICY_VIOLATION: number;
-    OUT_OF_ORDER_SEQUENCE_NUMBER: number;
-    DUPLICATE_SEQUENCE_NUMBER: number;
-    INVALID_PRODUCER_EPOCH: number;
-    INVALID_TXN_STATE: number;
-    INVALID_PRODUCER_ID_MAPPING: number;
-    INVALID_TRANSACTION_TIMEOUT: number;
-    CONCURRENT_TRANSACTIONS: number;
-    TRANSACTION_COORDINATOR_FENCED: number;
-    TRANSACTIONAL_ID_AUTHORIZATION_FAILED: number;
-    SECURITY_DISABLED: number;
-    OPERATION_NOT_ATTEMPTED: number;
-    KAFKA_STORAGE_ERROR: number;
-    LOG_DIR_NOT_FOUND: number;
-    SASL_AUTHENTICATION_FAILED: number;
-    UNKNOWN_PRODUCER_ID: number;
-    REASSIGNMENT_IN_PROGRESS: number;
-    DELEGATION_TOKEN_AUTH_DISABLED: number;
-    DELEGATION_TOKEN_NOT_FOUND: number;
-    DELEGATION_TOKEN_OWNER_MISMATCH: number;
-    DELEGATION_TOKEN_REQUEST_NOT_ALLOWED: number;
-    DELEGATION_TOKEN_AUTHORIZATION_FAILED: number;
-    DELEGATION_TOKEN_EXPIRED: number;
-    INVALID_PRINCIPAL_TYPE: number;
-    NON_EMPTY_GROUP: number;
-    GROUP_ID_NOT_FOUND: number;
-    FETCH_SESSION_ID_NOT_FOUND: number;
-    INVALID_FETCH_SESSION_EPOCH: number;
-    LISTENER_NOT_FOUND: number;
-    TOPIC_DELETION_DISABLED: number;
-    FENCED_LEADER_EPOCH: number;
-    UNKNOWN_LEADER_EPOCH: number;
-    UNSUPPORTED_COMPRESSION_TYPE: number;
-    STALE_BROKER_EPOCH: number;
-    OFFSET_NOT_AVAILABLE: number;
-    MEMBER_ID_REQUIRED: number;
-    PREFERRED_LEADER_NOT_AVAILABLE: number;
-    GROUP_MAX_SIZE_REACHED: number;
-    FENCED_INSTANCE_ID: number;
-    ELIGIBLE_LEADERS_NOT_AVAILABLE: number;
-    ELECTION_NOT_NEEDED: number;
-    NO_REASSIGNMENT_IN_PROGRESS: number;
-    GROUP_SUBSCRIBED_TO_TOPIC: number;
-    INVALID_RECORD: number;
-    UNSTABLE_OFFSET_COMMIT: number;
-    THROTTLING_QUOTA_EXCEEDED: number;
-    PRODUCER_FENCED: number;
-    RESOURCE_NOT_FOUND: number;
-    DUPLICATE_RESOURCE: number;
-    UNACCEPTABLE_CREDENTIAL: number;
-    INCONSISTENT_VOTER_SET: number;
-    INVALID_UPDATE_VERSION: number;
-    FEATURE_UPDATE_FAILED: number;
-    PRINCIPAL_DESERIALIZATION_FAILURE: number;
-    SNAPSHOT_NOT_FOUND: number;
-    POSITION_OUT_OF_RANGE: number;
-    UNKNOWN_TOPIC_ID: number;
-    DUPLICATE_BROKER_REGISTRATION: number;
-    BROKER_ID_NOT_REGISTERED: number;
-    INCONSISTENT_TOPIC_ID: number;
-    INCONSISTENT_CLUSTER_ID: number;
-    TRANSACTIONAL_ID_NOT_FOUND: number;
-    FETCH_SESSION_TOPIC_ID_ERROR: number;
-    INELIGIBLE_REPLICA: number;
-    NEW_LEADER_ELECTED: number;
-    OFFSET_MOVED_TO_TIERED_STORAGE: number;
-    FENCED_MEMBER_EPOCH: number;
-    UNRELEASED_INSTANCE_ID: number;
-    UNSUPPORTED_ASSIGNOR: number;
-    STALE_MEMBER_EPOCH: number;
-    MISMATCHED_ENDPOINT_TYPE: number;
-    UNSUPPORTED_ENDPOINT_TYPE: number;
-    UNKNOWN_CONTROLLER_ID: number;
-    UNKNOWN_SUBSCRIPTION_ID: number;
-    TELEMETRY_TOO_LARGE: number;
-    INVALID_REGISTRATION: number;
-    TRANSACTION_ABORTABLE: number;
+    readonly UNKNOWN_SERVER_ERROR: -1;
+    readonly OFFSET_OUT_OF_RANGE: 1;
+    readonly CORRUPT_MESSAGE: 2;
+    readonly UNKNOWN_TOPIC_OR_PARTITION: 3;
+    readonly INVALID_FETCH_SIZE: 4;
+    readonly LEADER_NOT_AVAILABLE: 5;
+    readonly NOT_LEADER_OR_FOLLOWER: 6;
+    readonly REQUEST_TIMED_OUT: 7;
+    readonly BROKER_NOT_AVAILABLE: 8;
+    readonly REPLICA_NOT_AVAILABLE: 9;
+    readonly MESSAGE_TOO_LARGE: 10;
+    readonly STALE_CONTROLLER_EPOCH: 11;
+    readonly OFFSET_METADATA_TOO_LARGE: 12;
+    readonly NETWORK_EXCEPTION: 13;
+    readonly COORDINATOR_LOAD_IN_PROGRESS: 14;
+    readonly COORDINATOR_NOT_AVAILABLE: 15;
+    readonly NOT_COORDINATOR: 16;
+    readonly INVALID_TOPIC_EXCEPTION: 17;
+    readonly RECORD_LIST_TOO_LARGE: 18;
+    readonly NOT_ENOUGH_REPLICAS: 19;
+    readonly NOT_ENOUGH_REPLICAS_AFTER_APPEND: 20;
+    readonly INVALID_REQUIRED_ACKS: 21;
+    readonly ILLEGAL_GENERATION: 22;
+    readonly INCONSISTENT_GROUP_PROTOCOL: 23;
+    readonly INVALID_GROUP_ID: 24;
+    readonly UNKNOWN_MEMBER_ID: 25;
+    readonly INVALID_SESSION_TIMEOUT: 26;
+    readonly REBALANCE_IN_PROGRESS: 27;
+    readonly INVALID_COMMIT_OFFSET_SIZE: 28;
+    readonly TOPIC_AUTHORIZATION_FAILED: 29;
+    readonly GROUP_AUTHORIZATION_FAILED: 30;
+    readonly CLUSTER_AUTHORIZATION_FAILED: 31;
+    readonly INVALID_TIMESTAMP: 32;
+    readonly UNSUPPORTED_SASL_MECHANISM: 33;
+    readonly ILLEGAL_SASL_STATE: 34;
+    readonly UNSUPPORTED_VERSION: 35;
+    readonly TOPIC_ALREADY_EXISTS: 36;
+    readonly INVALID_PARTITIONS: 37;
+    readonly INVALID_REPLICATION_FACTOR: 38;
+    readonly INVALID_REPLICA_ASSIGNMENT: 39;
+    readonly INVALID_CONFIG: 40;
+    readonly NOT_CONTROLLER: 41;
+    readonly INVALID_REQUEST: 42;
+    readonly UNSUPPORTED_FOR_MESSAGE_FORMAT: 43;
+    readonly POLICY_VIOLATION: 44;
+    readonly OUT_OF_ORDER_SEQUENCE_NUMBER: 45;
+    readonly DUPLICATE_SEQUENCE_NUMBER: 46;
+    readonly INVALID_PRODUCER_EPOCH: 47;
+    readonly INVALID_TXN_STATE: 48;
+    readonly INVALID_PRODUCER_ID_MAPPING: 49;
+    readonly INVALID_TRANSACTION_TIMEOUT: 50;
+    readonly CONCURRENT_TRANSACTIONS: 51;
+    readonly TRANSACTION_COORDINATOR_FENCED: 52;
+    readonly TRANSACTIONAL_ID_AUTHORIZATION_FAILED: 53;
+    readonly SECURITY_DISABLED: 54;
+    readonly OPERATION_NOT_ATTEMPTED: 55;
+    readonly KAFKA_STORAGE_ERROR: 56;
+    readonly LOG_DIR_NOT_FOUND: 57;
+    readonly SASL_AUTHENTICATION_FAILED: 58;
+    readonly UNKNOWN_PRODUCER_ID: 59;
+    readonly REASSIGNMENT_IN_PROGRESS: 60;
+    readonly DELEGATION_TOKEN_AUTH_DISABLED: 61;
+    readonly DELEGATION_TOKEN_NOT_FOUND: 62;
+    readonly DELEGATION_TOKEN_OWNER_MISMATCH: 63;
+    readonly DELEGATION_TOKEN_REQUEST_NOT_ALLOWED: 64;
+    readonly DELEGATION_TOKEN_AUTHORIZATION_FAILED: 65;
+    readonly DELEGATION_TOKEN_EXPIRED: 66;
+    readonly INVALID_PRINCIPAL_TYPE: 67;
+    readonly NON_EMPTY_GROUP: 68;
+    readonly GROUP_ID_NOT_FOUND: 69;
+    readonly FETCH_SESSION_ID_NOT_FOUND: 70;
+    readonly INVALID_FETCH_SESSION_EPOCH: 71;
+    readonly LISTENER_NOT_FOUND: 72;
+    readonly TOPIC_DELETION_DISABLED: 73;
+    readonly FENCED_LEADER_EPOCH: 74;
+    readonly UNKNOWN_LEADER_EPOCH: 75;
+    readonly UNSUPPORTED_COMPRESSION_TYPE: 76;
+    readonly STALE_BROKER_EPOCH: 77;
+    readonly OFFSET_NOT_AVAILABLE: 78;
+    readonly MEMBER_ID_REQUIRED: 79;
+    readonly PREFERRED_LEADER_NOT_AVAILABLE: 80;
+    readonly GROUP_MAX_SIZE_REACHED: 81;
+    readonly FENCED_INSTANCE_ID: 82;
+    readonly ELIGIBLE_LEADERS_NOT_AVAILABLE: 83;
+    readonly ELECTION_NOT_NEEDED: 84;
+    readonly NO_REASSIGNMENT_IN_PROGRESS: 85;
+    readonly GROUP_SUBSCRIBED_TO_TOPIC: 86;
+    readonly INVALID_RECORD: 87;
+    readonly UNSTABLE_OFFSET_COMMIT: 88;
+    readonly THROTTLING_QUOTA_EXCEEDED: 89;
+    readonly PRODUCER_FENCED: 90;
+    readonly RESOURCE_NOT_FOUND: 91;
+    readonly DUPLICATE_RESOURCE: 92;
+    readonly UNACCEPTABLE_CREDENTIAL: 93;
+    readonly INCONSISTENT_VOTER_SET: 94;
+    readonly INVALID_UPDATE_VERSION: 95;
+    readonly FEATURE_UPDATE_FAILED: 96;
+    readonly PRINCIPAL_DESERIALIZATION_FAILURE: 97;
+    readonly SNAPSHOT_NOT_FOUND: 98;
+    readonly POSITION_OUT_OF_RANGE: 99;
+    readonly UNKNOWN_TOPIC_ID: 100;
+    readonly DUPLICATE_BROKER_REGISTRATION: 101;
+    readonly BROKER_ID_NOT_REGISTERED: 102;
+    readonly INCONSISTENT_TOPIC_ID: 103;
+    readonly INCONSISTENT_CLUSTER_ID: 104;
+    readonly TRANSACTIONAL_ID_NOT_FOUND: 105;
+    readonly FETCH_SESSION_TOPIC_ID_ERROR: 106;
+    readonly INELIGIBLE_REPLICA: 107;
+    readonly NEW_LEADER_ELECTED: 108;
+    readonly OFFSET_MOVED_TO_TIERED_STORAGE: 109;
+    readonly FENCED_MEMBER_EPOCH: 110;
+    readonly UNRELEASED_INSTANCE_ID: 111;
+    readonly UNSUPPORTED_ASSIGNOR: 112;
+    readonly STALE_MEMBER_EPOCH: 113;
+    readonly MISMATCHED_ENDPOINT_TYPE: 114;
+    readonly UNSUPPORTED_ENDPOINT_TYPE: 115;
+    readonly UNKNOWN_CONTROLLER_ID: 116;
+    readonly UNKNOWN_SUBSCRIPTION_ID: 117;
+    readonly TELEMETRY_TOO_LARGE: 118;
+    readonly INVALID_REGISTRATION: 119;
+    readonly TRANSACTION_ABORTABLE: 120;
 };
+export declare const handleApiError: (error: unknown) => Promise<void>;

package/dist/api/index.js

@@ -1,6 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.API_ERROR = exports.getApiName = exports.API = void 0;
+exports.handleApiError = exports.API_ERROR = exports.getApiName = exports.API = void 0;
+const delay_1 = require("../utils/delay");
+const error_1 = require("../utils/error");
+const logger_1 = require("../utils/logger");
 const api_versions_1 = require("./api-versions");
 const create_topics_1 = require("./create-topics");
 const delete_topics_1 = require("./delete-topics");
@@ -163,3 +166,23 @@ exports.API_ERROR = {
     INVALID_REGISTRATION: 119,
     TRANSACTION_ABORTABLE: 120,
 };
+const handleApiError = async (error) => {
+    if (error instanceof error_1.KafkaTSApiError) {
+        switch (error.errorCode) {
+            case exports.API_ERROR.LEADER_NOT_AVAILABLE:
+                logger_1.log.debug('Leader not available yet. Retrying...');
+                return (0, delay_1.delay)(500);
+            case exports.API_ERROR.COORDINATOR_LOAD_IN_PROGRESS:
+                logger_1.log.debug('Coordinator load in progress. Retrying...');
+                return (0, delay_1.delay)(100);
+            case exports.API_ERROR.COORDINATOR_NOT_AVAILABLE:
+                logger_1.log.debug('Coordinator not available yet. Retrying...');
+                return (0, delay_1.delay)(100);
+            case exports.API_ERROR.OFFSET_NOT_AVAILABLE:
+                logger_1.log.debug('Offset not available yet. Retrying...');
+                return (0, delay_1.delay)(100);
+        }
+    }
+    throw error;
+};
+exports.handleApiError = handleApiError;

package/dist/broker.d.ts

@@ -20,7 +20,6 @@ export declare class Broker {
     sendRequest: SendRequest;
     constructor(options: BrokerOptions);
     connect(): Promise<this>;
-    ensureConnected(): Promise<void>;
     disconnect(): Promise<void>;
     private validateApiVersions;
     private saslHandshake;

package/dist/broker.js

@@ -19,16 +19,13 @@ class Broker {
         this.sendRequest = this.connection.sendRequest.bind(this.connection);
     }
     async connect() {
-        await this.connection.connect();
-        await this.validateApiVersions();
-        await this.saslHandshake();
-        await this.saslAuthenticate();
-        return this;
-    }
-    async ensureConnected() {
         if (!this.connection.isConnected()) {
-            await this.connect();
+            await this.connection.connect();
+            await this.validateApiVersions();
+            await this.saslHandshake();
+            await this.saslAuthenticate();
         }
+        return this;
     }
     async disconnect() {
         await this.connection.disconnect();

package/dist/cluster.d.ts

@@ -16,13 +16,13 @@ export declare class Cluster {
     private brokerMetadata;
     constructor(options: ClusterOptions);
     connect(): Promise<void>;
-    refreshBrokerMetadata(): Promise<void>;
-    ensureConnected(): Promise<void>;
     disconnect(): Promise<void>;
+    ensureConnected: () => Promise<void>;
     setSeedBroker: (nodeId: number) => Promise<void>;
     sendRequest: SendRequest;
     sendRequestToNode: (nodeId: number) => SendRequest;
     acquireBroker(nodeId: number): Promise<Broker>;
     private findSeedBroker;
+    private refreshBrokerMetadata;
 }
 export {};

package/dist/cluster.js

@@ -14,6 +14,7 @@ const api_1 = require("./api");
 const broker_1 = require("./broker");
 const error_1 = require("./utils/error");
 const logger_1 = require("./utils/logger");
+const shared_1 = require("./utils/shared");
 const tracer_1 = require("./utils/tracer");
 const trace = (0, tracer_1.createTracer)('Cluster');
 class Cluster {
@@ -29,34 +30,51 @@ class Cluster {
         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]));
-    }
-    async ensureConnected() {
-        if (!this.seedBroker) {
-            return this.connect();
-        }
-        try {
-            await Promise.all([this.seedBroker, ...Object.values(this.brokerById)].map((x) => x.ensureConnected()));
-        }
-        catch {
-            logger_1.log.warn('Failed to connect to known brokers, reconnecting...');
-            await this.disconnect();
-            return this.connect();
-        }
-    }
     async disconnect() {
         await Promise.all([
             this.seedBroker?.disconnect(),
             ...Object.values(this.brokerById).map((x) => x.disconnect()),
         ]);
     }
+    ensureConnected = (0, shared_1.shared)(async () => {
+        if (!this.seedBroker) {
+            return this.connect();
+        }
+        const brokers = [
+            {
+                broker: this.seedBroker,
+                handleError: async (error) => {
+                    logger_1.log.debug(`Failed to connect to seed broker. Reconnecting...`, { reason: error.message });
+                    await this.seedBroker?.disconnect();
+                    this.seedBroker = await this.findSeedBroker();
+                },
+            },
+            ...Object.entries(this.brokerById).map(([nodeId, broker]) => ({
+                broker,
+                handleError: async (error) => {
+                    logger_1.log.debug(`Failed to connect to broker ${nodeId}. Disconnecting...`, { reason: error.message });
+                    await broker.disconnect();
+                    delete this.brokerById[parseInt(nodeId)];
+                },
+            })),
+        ];
+        await Promise.all(brokers.map(async ({ broker, handleError }) => {
+            try {
+                await broker.connect();
+            }
+            catch (error) {
+                await handleError(error);
+            }
+        }));
+    });
     setSeedBroker = async (nodeId) => {
+        const broker = await this.acquireBroker(nodeId);
         await this.seedBroker?.disconnect();
-        this.seedBroker = await this.acquireBroker(nodeId);
+        this.seedBroker = broker;
+    };
+    sendRequest = async (...args) => {
+        return this.seedBroker.sendRequest(...args);
     };
-    sendRequest = (...args) => this.seedBroker.sendRequest(...args);
     sendRequestToNode = (nodeId) => async (...args) => {
         if (!this.brokerById[nodeId]) {
             this.brokerById[nodeId] = await this.acquireBroker(nodeId);
@@ -64,9 +82,10 @@ class Cluster {
         return this.brokerById[nodeId].sendRequest(...args);
     };
     async acquireBroker(nodeId) {
-        if (!(nodeId in this.brokerMetadata)) {
-            throw new error_1.BrokerNotAvailableError(nodeId);
-        }
+        if (!(nodeId in this.brokerMetadata))
+            await this.refreshBrokerMetadata();
+        if (!(nodeId in this.brokerMetadata))
+            throw new error_1.ConnectionError(`Broker ${nodeId} is not available`);
         const broker = new broker_1.Broker({
             clientId: this.options.clientId,
             sasl: this.options.sasl,
@@ -92,11 +111,17 @@ class Cluster {
                 return broker;
             }
             catch (error) {
-                logger_1.log.warn(`Failed to connect to seed broker ${options.host}:${options.port}`, error);
+                logger_1.log.debug(`Failed to connect to seed broker ${options.host}:${options.port}`, {
+                    reason: error.message,
+                });
             }
         }
         throw new error_1.KafkaTSError('No seed brokers found');
     }
+    async refreshBrokerMetadata() {
+        const metadata = await this.sendRequest(api_1.API.METADATA, { topics: [] });
+        this.brokerMetadata = Object.fromEntries(metadata.brokers.map((options) => [options.nodeId, options]));
+    }
 }
 exports.Cluster = Cluster;
 __decorate([

package/dist/connection.js

@@ -71,6 +71,7 @@ class Connection {
     async connect() {
         this.queue = {};
         this.chunks = [];
+        const { stack } = new Error();
         await new Promise((resolve, reject) => {
             const { ssl, connection } = this.options;
             this.socket = ssl
@@ -81,14 +82,16 @@ class Connection {
                 }, resolve)
                 : net_1.default.connect(connection, resolve);
             this.socket.setKeepAlive(true, 30_000);
-            this.socket.once('error', reject);
+            this.socket.once('error', (error) => {
+                reject(new error_1.ConnectionError(error.message, stack));
+            });
         });
         this.socket.removeAllListeners('error');
         this.socket.on('error', (error) => logger_1.log.debug('Socket error', { error }));
         this.socket.on('data', (data) => this.handleData(data));
         this.socket.once('close', async () => {
             Object.values(this.queue).forEach(({ reject }) => {
-                reject(new error_1.ConnectionError('Socket closed unexpectedly'));
+                reject(new error_1.ConnectionError('Socket closed unexpectedly', stack));
             });
             this.queue = {};
         });
@@ -112,18 +115,19 @@ class Connection {
             .writeString(this.options.clientId);
         const request = api.request(encoder, body);
         const requestEncoder = new encoder_1.Encoder().writeInt32(request.getBufferLength()).writeEncoder(request);
+        const { stack } = new Error();
         let timeout;
         const { responseDecoder, responseSize } = await new Promise(async (resolve, reject) => {
             timeout = setTimeout(() => {
                 delete this.queue[correlationId];
-                reject(new error_1.ConnectionError(`${apiName} timed out`));
+                reject(new error_1.ConnectionError(`${apiName} timed out`, stack));
             }, this.options.requestTimeout);
             try {
                 this.queue[correlationId] = { resolve, reject };
                 await this.write(requestEncoder.value());
             }
             catch (error) {
-                reject(error);
+                reject(new error_1.ConnectionError(error.message, stack));
             }
         });
         clearTimeout(timeout);
@@ -142,15 +146,7 @@ class Connection {
     }
     write(buffer) {
         return new Promise((resolve, reject) => {
-            const { stack } = new Error('Write error');
-            this.socket.write(buffer, 'binary', (error) => {
-                if (error) {
-                    const err = new error_1.ConnectionError(error.message);
-                    err.stack += `\n${stack}`;
-                    return reject(err);
-                }
-                resolve();
-            });
+            this.socket.write(buffer, 'binary', (error) => (error ? reject(error) : resolve()));
         });
     }
     handleData(buffer) {

package/dist/consumer/consumer-group.d.ts

@@ -28,12 +28,13 @@ export declare class ConsumerGroup {
     private startHeartbeater;
     private stopHeartbeater;
     handleLastHeartbeat(): void;
-    private findCoordinator;
+    findCoordinator(): Promise<void>;
     private joinGroup;
     private syncGroup;
     private offsetFetch;
     offsetCommit(topicPartitions: Record<string, Set<number>>): Promise<void>;
     heartbeat(): Promise<void>;
     leaveGroup(): Promise<void>;
+    private handleError;
 }
 export {};