kafka-ts 0.0.3-beta → 0.0.4

package/{src/cluster.test.ts → dist/cluster.test.js}

@@ -1,58 +1,51 @@
-import { randomBytes } from 'crypto';
-import { readFileSync } from 'fs';
-import { afterAll, beforeAll, describe, expect, it } from 'vitest';
-import { API } from './api';
-import { KEY_TYPE } from './api/find-coordinator';
-import { createKafkaClient } from './client';
-import { Cluster } from './cluster';
-import { KafkaTSApiError } from './utils/error';
-
-export const kafka = createKafkaClient({
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const crypto_1 = require("crypto");
+const fs_1 = require("fs");
+const vitest_1 = require("vitest");
+const api_1 = require("./api");
+const find_coordinator_1 = require("./api/find-coordinator");
+const auth_1 = require("./auth");
+const client_1 = require("./client");
+const kafka = (0, client_1.createKafkaClient)({
     clientId: 'kafka-ts',
     bootstrapServers: [{ host: 'localhost', port: 9092 }],
-    sasl: { mechanism: 'PLAIN', username: 'admin', password: 'admin' },
-    ssl: { ca: readFileSync('./certs/ca.crt').toString() },
+    sasl: (0, auth_1.saslPlain)({ username: 'admin', password: 'admin' }),
+    ssl: { ca: (0, fs_1.readFileSync)('./certs/ca.crt').toString() },
 });
-
-describe.sequential('Request handler', () => {
-    const groupId = randomBytes(16).toString('hex');
-
-    let cluster: Cluster;
-
-    beforeAll(async () => {
-        cluster = await kafka.createCluster().connect();
-
-        const metadataResult = await cluster.sendRequest(API.METADATA, {
+vitest_1.describe.sequential('Low-level API', () => {
+    const groupId = (0, crypto_1.randomBytes)(16).toString('hex');
+    let cluster;
+    (0, vitest_1.beforeAll)(async () => {
+        cluster = await kafka.createCluster();
+        await cluster.connect();
+        const metadataResult = await cluster.sendRequest(api_1.API.METADATA, {
             topics: null,
             allowTopicAutoCreation: false,
             includeTopicAuthorizedOperations: false,
         });
         if (metadataResult.topics.some((topic) => topic.name === 'kafka-ts-test-topic')) {
-            await cluster.sendRequest(API.DELETE_TOPICS, {
+            await cluster.sendRequest(api_1.API.DELETE_TOPICS, {
                 topics: [{ name: 'kafka-ts-test-topic', topicId: null }],
                 timeoutMs: 10000,
             });
         }
     });
-
-    afterAll(async () => {
+    (0, vitest_1.afterAll)(async () => {
         await cluster.disconnect();
     });
-
-    it('should request api versions', async () => {
-        const result = await cluster.sendRequest(API.API_VERSIONS, {});
-        expect(result).toMatchSnapshot();
+    (0, vitest_1.it)('should request api versions', async () => {
+        const result = await cluster.sendRequest(api_1.API.API_VERSIONS, {});
+        (0, vitest_1.expect)(result).toMatchSnapshot();
     });
-
-    let topicId: string = 'd6718d178e1b47c886441ad2d19faea5';
-
-    it('should create topics', async () => {
-        const result = await cluster.sendRequest(API.CREATE_TOPICS, {
+    let topicId = 'd6718d178e1b47c886441ad2d19faea5';
+    (0, vitest_1.it)('should create topics', async () => {
+        const result = await cluster.sendRequest(api_1.API.CREATE_TOPICS, {
             topics: [
                 {
                     name: 'kafka-ts-test-topic',
-                    numPartitions: 1,
-                    replicationFactor: 1,
+                    numPartitions: 10,
+                    replicationFactor: 3,
                     assignments: [],
                     configs: [],
                 },
@@ -64,13 +57,11 @@ describe.sequential('Request handler', () => {
         result.topics.forEach((topic) => {
             topic.topicId = 'Any<UUID>';
         });
-        expect(result).toMatchSnapshot();
-
+        (0, vitest_1.expect)(result).toMatchSnapshot();
         await new Promise((resolve) => setTimeout(resolve, 1000));
     });
-
-    it('should request metadata for all topics', async () => {
-        const result = await cluster.sendRequest(API.METADATA, {
+    (0, vitest_1.it)('should request metadata for all topics', async () => {
+        const result = await cluster.sendRequest(api_1.API.METADATA, {
             topics: null,
             allowTopicAutoCreation: false,
             includeTopicAuthorizedOperations: false,
@@ -85,17 +76,17 @@ describe.sequential('Request handler', () => {
                 partition.replicaNodes = [0];
             });
         });
-        expect(result).toMatchSnapshot();
+        (0, vitest_1.expect)(result).toMatchSnapshot();
     });
-
+    let partitionIndex = 0;
     let leaderId = 0;
-
-    it('should request metadata for a topic', async () => {
-        const result = await cluster.sendRequest(API.METADATA, {
+    (0, vitest_1.it)('should request metadata for a topic', async () => {
+        const result = await cluster.sendRequest(api_1.API.METADATA, {
             topics: [{ id: topicId, name: 'kafka-ts-test-topic' }],
             allowTopicAutoCreation: false,
             includeTopicAuthorizedOperations: false,
         });
+        partitionIndex = result.topics[0].partitions[0].partitionIndex;
         leaderId = result.topics[0].partitions[0].leaderId;
         result.controllerId = 0;
         result.topics.forEach((topic) => {
@@ -106,25 +97,22 @@ describe.sequential('Request handler', () => {
                 partition.replicaNodes = [0];
             });
         });
-        expect(result).toMatchSnapshot();
+        (0, vitest_1.expect)(result).toMatchSnapshot();
     });
-
     let producerId = 9n;
-
-    it('should init producer id', async () => {
-        const result = await cluster.sendRequest(API.INIT_PRODUCER_ID, {
+    (0, vitest_1.it)('should init producer id', async () => {
+        const result = await cluster.sendRequest(api_1.API.INIT_PRODUCER_ID, {
             transactionalId: null,
             transactionTimeoutMs: 0,
             producerId,
             producerEpoch: 0,
         });
         result.producerId = 0n;
-        expect(result).toMatchSnapshot();
+        (0, vitest_1.expect)(result).toMatchSnapshot();
     });
-
-    it('should produce messages', async () => {
+    (0, vitest_1.it)('should produce messages', async () => {
         const now = Date.now();
-        const result = await cluster.sendRequestToNode(leaderId)(API.PRODUCE, {
+        const result = await cluster.sendRequestToNode(leaderId)(api_1.API.PRODUCE, {
             transactionalId: null,
             timeoutMs: 10000,
             acks: 1,
@@ -133,7 +121,7 @@ describe.sequential('Request handler', () => {
                     name: 'kafka-ts-test-topic',
                     partitionData: [
                         {
-                            index: 0,
+                            index: partitionIndex,
                             baseOffset: 0n,
                             partitionLeaderEpoch: 0,
                             attributes: 0,
@@ -148,12 +136,12 @@ describe.sequential('Request handler', () => {
                                     attributes: 0,
                                     offsetDelta: 0,
                                     timestampDelta: 0n,
-                                    key: 'key',
-                                    value: 'value',
+                                    key: Buffer.from('key'),
+                                    value: Buffer.from('value'),
                                     headers: [
                                         {
-                                            key: 'header-key',
-                                            value: 'header-value',
+                                            key: Buffer.from('header-key'),
+                                            value: Buffer.from('header-value'),
                                         },
                                     ],
                                 },
@@ -163,11 +151,10 @@ describe.sequential('Request handler', () => {
                 },
             ],
         });
-        expect(result).toMatchSnapshot();
+        (0, vitest_1.expect)(result).toMatchSnapshot();
     });
-
-    it('should fetch messages', async () => {
-        const result = await cluster.sendRequestToNode(leaderId)(API.FETCH, {
+    (0, vitest_1.it)('should fetch messages', async () => {
+        const result = await cluster.sendRequestToNode(leaderId)(api_1.API.FETCH, {
             maxWaitMs: 100,
             minBytes: 1,
             maxBytes: 10485760,
@@ -179,7 +166,7 @@ describe.sequential('Request handler', () => {
                     topicId,
                     partitions: [
                         {
-                            partition: 0,
+                            partition: partitionIndex,
                             currentLeaderEpoch: -1,
                             fetchOffset: 0n,
                             lastFetchedEpoch: 0,
@@ -196,23 +183,20 @@ describe.sequential('Request handler', () => {
             response.topicId = 'Any<UUID>';
             response.partitions.forEach((partition) => {
                 partition.records.forEach((record) => {
-                    expect(record.baseTimestamp).toBeGreaterThan(1721926744730n);
-                    expect(record.maxTimestamp).toBeGreaterThan(1721926744730n);
-                    expect(record.crc).toBeGreaterThan(0);
-
+                    (0, vitest_1.expect)(record.baseTimestamp).toBeGreaterThan(1721926744730n);
+                    (0, vitest_1.expect)(record.maxTimestamp).toBeGreaterThan(1721926744730n);
+                    (0, vitest_1.expect)(record.crc).toBeGreaterThan(0);
                     record.baseTimestamp = 0n;
                     record.maxTimestamp = 0n;
                     record.crc = 0;
                 });
             });
         });
-        expect(result).toMatchSnapshot();
+        (0, vitest_1.expect)(result).toMatchSnapshot();
     });
-
     let coordinatorId = -1;
-
-    it('should find coordinator', async () => {
-        const result = await cluster.sendRequest(API.FIND_COORDINATOR, { keyType: KEY_TYPE.GROUP, keys: [groupId] });
+    (0, vitest_1.it)('should find coordinator', async () => {
+        const result = await cluster.sendRequest(api_1.API.FIND_COORDINATOR, { keyType: find_coordinator_1.KEY_TYPE.GROUP, keys: [groupId] });
         result.coordinators.forEach((coordinator) => {
             coordinator.key = 'Any<String>';
         });
@@ -221,14 +205,12 @@ describe.sequential('Request handler', () => {
             coordinator.nodeId = 1;
             coordinator.port = 9093;
         });
-        expect(result).toMatchSnapshot();
+        (0, vitest_1.expect)(result).toMatchSnapshot();
     });
-
     let memberId = '';
-
-    it('should fail join group request with new memberId', async () => {
+    (0, vitest_1.it)('should fail join group request with new memberId', async () => {
         try {
-            const result = await cluster.sendRequestToNode(coordinatorId)(API.JOIN_GROUP, {
+            const result = await cluster.sendRequestToNode(coordinatorId)(api_1.API.JOIN_GROUP, {
                 groupId,
                 sessionTimeoutMs: 30000,
                 rebalanceTimeoutMs: 60000,
@@ -243,17 +225,17 @@ describe.sequential('Request handler', () => {
                 ],
                 reason: null,
             });
-            expect(false, 'Should throw an error').toBe(true);
-        } catch (error) {
-            const { response } = error as KafkaTSApiError;
+            (0, vitest_1.expect)(false, 'Should throw an error').toBe(true);
+        }
+        catch (error) {
+            const { response } = error;
             memberId = response.memberId;
             response.memberId = 'Any<UUID>';
-            expect(response).toMatchSnapshot();
+            (0, vitest_1.expect)(response).toMatchSnapshot();
         }
     });
-
-    it('should join group', async () => {
-        const result = await cluster.sendRequestToNode(coordinatorId)(API.JOIN_GROUP, {
+    (0, vitest_1.it)('should join group', async () => {
+        const result = await cluster.sendRequestToNode(coordinatorId)(api_1.API.JOIN_GROUP, {
             groupId,
             sessionTimeoutMs: 30000,
             rebalanceTimeoutMs: 60000,
@@ -273,11 +255,10 @@ describe.sequential('Request handler', () => {
         result.members.forEach((member) => {
             member.memberId = 'Any<UUID>';
         });
-        expect(result).toMatchSnapshot();
+        (0, vitest_1.expect)(result).toMatchSnapshot();
     });
-
-    it('should sync group', async () => {
-        const result = await cluster.sendRequestToNode(coordinatorId)(API.SYNC_GROUP, {
+    (0, vitest_1.it)('should sync group', async () => {
+        const result = await cluster.sendRequestToNode(coordinatorId)(api_1.API.SYNC_GROUP, {
             groupId,
             generationId: 1,
             memberId,
@@ -291,11 +272,10 @@ describe.sequential('Request handler', () => {
                 },
             ],
         });
-        expect(result).toMatchSnapshot();
+        (0, vitest_1.expect)(result).toMatchSnapshot();
     });
-
-    it('should commit offsets', async () => {
-        const result = await cluster.sendRequestToNode(coordinatorId)(API.OFFSET_COMMIT, {
+    (0, vitest_1.it)('should commit offsets', async () => {
+        const result = await cluster.sendRequestToNode(coordinatorId)(api_1.API.OFFSET_COMMIT, {
             groupId,
             generationIdOrMemberEpoch: 1,
             memberId,
@@ -309,16 +289,13 @@ describe.sequential('Request handler', () => {
                 },
             ],
         });
-        expect(result).toMatchSnapshot();
+        (0, vitest_1.expect)(result).toMatchSnapshot();
     });
-
-    it('should fetch offsets', async () => {
-        const result = await cluster.sendRequestToNode(coordinatorId)(API.OFFSET_FETCH, {
+    (0, vitest_1.it)('should fetch offsets', async () => {
+        const result = await cluster.sendRequestToNode(coordinatorId)(api_1.API.OFFSET_FETCH, {
             groups: [
                 {
                     groupId,
-                    memberId,
-                    memberEpoch: 0,
                     topics: [
                         {
                             name: 'kafka-ts-test-topic',
@@ -332,38 +309,35 @@ describe.sequential('Request handler', () => {
         result.groups.forEach((group) => {
             group.groupId = 'Any<String>';
         });
-        expect(result).toMatchSnapshot();
+        (0, vitest_1.expect)(result).toMatchSnapshot();
     });
-
-    it('should heartbeat', async () => {
-        const result = await cluster.sendRequestToNode(coordinatorId)(API.HEARTBEAT, {
+    (0, vitest_1.it)('should heartbeat', async () => {
+        const result = await cluster.sendRequestToNode(coordinatorId)(api_1.API.HEARTBEAT, {
             groupId,
             generationId: 1,
             memberId,
             groupInstanceId: null,
         });
-        expect(result).toMatchSnapshot();
+        (0, vitest_1.expect)(result).toMatchSnapshot();
     });
-
-    it('should leave group', async () => {
-        const result = await cluster.sendRequestToNode(coordinatorId)(API.LEAVE_GROUP, {
+    (0, vitest_1.it)('should leave group', async () => {
+        const result = await cluster.sendRequestToNode(coordinatorId)(api_1.API.LEAVE_GROUP, {
             groupId,
             members: [{ memberId, groupInstanceId: null, reason: null }],
         });
         result.members.forEach((member) => {
             member.memberId = 'Any<UUID>';
         });
-        expect(result).toMatchSnapshot();
+        (0, vitest_1.expect)(result).toMatchSnapshot();
     });
-
-    it('should delete topics', async () => {
-        const result = await cluster.sendRequest(API.DELETE_TOPICS, {
+    (0, vitest_1.it)('should delete topics', async () => {
+        const result = await cluster.sendRequest(api_1.API.DELETE_TOPICS, {
             topics: [{ name: 'kafka-ts-test-topic', topicId: null }],
             timeoutMs: 10000,
         });
         result.responses.forEach((response) => {
             response.topicId = 'Any<UUID>';
         });
-        expect(result).toMatchSnapshot();
+        (0, vitest_1.expect)(result).toMatchSnapshot();
     });
 });

package/dist/codecs/gzip.d.ts

@@ -0,0 +1,2 @@
+import { Codec } from './types';
+export declare const GZIP: Codec;

package/dist/codecs/gzip.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GZIP = void 0;
+const zlib_1 = require("zlib");
+exports.GZIP = {
+    compress: async (data) => new Promise((resolve, reject) => (0, zlib_1.gzip)(data, (err, result) => (err ? reject(err) : resolve(result)))),
+    decompress: async (data) => new Promise((resolve, reject) => (0, zlib_1.unzip)(data, (err, result) => (err ? reject(err) : resolve(result)))),
+};

package/dist/codecs/index.d.ts

@@ -0,0 +1,2 @@
+import { Codec } from './types';
+export declare const findCodec: (type: number) => Codec;

package/dist/codecs/index.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findCodec = void 0;
+const gzip_1 = require("./gzip");
+const none_1 = require("./none");
+const codecs = {
+    0: none_1.NONE,
+    1: gzip_1.GZIP,
+};
+const findCodec = (type) => {
+    const codec = codecs[type];
+    if (!codec) {
+        throw new Error(`Unsupported codec: ${type}`);
+    }
+    return codec;
+};
+exports.findCodec = findCodec;

package/dist/codecs/none.d.ts

@@ -0,0 +1,2 @@
+import { Codec } from './types';
+export declare const NONE: Codec;

package/dist/codecs/none.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NONE = void 0;
+exports.NONE = {
+    compress: (data) => Promise.resolve(data),
+    decompress: (data) => Promise.resolve(data),
+};

package/dist/codecs/types.d.ts

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

package/dist/codecs/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/connection.d.ts

@@ -0,0 +1,26 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import { TcpSocketConnectOpts } from 'net';
+import { TLSSocketOptions } from 'tls';
+import { Api } from './utils/api';
+type ConnectionOptions = {
+    clientId: string | null;
+    connection: TcpSocketConnectOpts;
+    ssl: TLSSocketOptions | null;
+};
+export declare class Connection {
+    private options;
+    private socket;
+    private queue;
+    private lastCorrelationId;
+    private chunks;
+    constructor(options: ConnectionOptions);
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    sendRequest<Request, Response>(api: Api<Request, Response>, body: Request): Promise<Response>;
+    private write;
+    private handleData;
+    private nextCorrelationId;
+}
+export type SendRequest = typeof Connection.prototype.sendRequest;
+export {};

package/dist/connection.js

@@ -0,0 +1,175 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+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 __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 __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Connection = void 0;
+const assert_1 = __importDefault(require("assert"));
+const net_1 = __importStar(require("net"));
+const tls_1 = __importDefault(require("tls"));
+const api_1 = require("./api");
+const decoder_1 = require("./utils/decoder");
+const encoder_1 = require("./utils/encoder");
+const error_1 = require("./utils/error");
+const logger_1 = require("./utils/logger");
+const tracer_1 = require("./utils/tracer");
+const trace = (0, tracer_1.createTracer)('Connection');
+class Connection {
+    options;
+    socket = new net_1.Socket();
+    queue = {};
+    lastCorrelationId = 0;
+    chunks = [];
+    constructor(options) {
+        this.options = options;
+    }
+    async connect() {
+        this.queue = {};
+        this.chunks = [];
+        await new Promise((resolve, reject) => {
+            const { ssl, connection } = this.options;
+            this.socket = ssl
+                ? tls_1.default.connect({
+                    ...connection,
+                    ...ssl,
+                    ...(connection.host && !(0, net_1.isIP)(connection.host) && { servername: connection.host }),
+                }, resolve)
+                : net_1.default.connect(connection, resolve);
+            this.socket.once('error', reject);
+        });
+        this.socket.removeAllListeners('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'));
+            });
+            this.queue = {};
+        });
+    }
+    disconnect() {
+        this.socket.removeAllListeners();
+        return new Promise((resolve) => {
+            if (this.socket.pending) {
+                return resolve();
+            }
+            this.socket.end(resolve);
+        });
+    }
+    async sendRequest(api, body) {
+        const correlationId = this.nextCorrelationId();
+        const apiName = (0, api_1.getApiName)(api);
+        const encoder = new encoder_1.Encoder()
+            .writeInt16(api.apiKey)
+            .writeInt16(api.apiVersion)
+            .writeInt32(correlationId)
+            .writeString(this.options.clientId);
+        const request = api.request(encoder, body);
+        const requestEncoder = new encoder_1.Encoder().writeInt32(request.getByteLength()).writeEncoder(request);
+        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`));
+            }, 30_000);
+            try {
+                this.queue[correlationId] = { resolve, reject };
+                await this.write(requestEncoder.value());
+            }
+            catch (error) {
+                reject(error);
+            }
+        });
+        clearTimeout(timeout);
+        const response = await api.response(responseDecoder);
+        (0, assert_1.default)(responseDecoder.getOffset() - 4 === responseSize, `Buffer not correctly consumed: ${responseDecoder.getOffset() - 4} !== ${responseSize}`);
+        return response;
+    }
+    write(buffer) {
+        return new Promise((resolve, reject) => {
+            const { stack } = new Error('Write error');
+            this.socket.write(buffer, (error) => {
+                if (error) {
+                    const err = new error_1.ConnectionError(error.message);
+                    err.stack += `\n${stack}`;
+                    return reject(err);
+                }
+                resolve();
+            });
+        });
+    }
+    handleData(buffer) {
+        this.chunks.push(buffer);
+        const decoder = new decoder_1.Decoder(Buffer.concat(this.chunks));
+        if (decoder.getBufferLength() < 4) {
+            return;
+        }
+        const size = decoder.readInt32();
+        if (size !== decoder.getBufferLength() - 4) {
+            return;
+        }
+        const correlationId = decoder.readInt32();
+        const context = this.queue[correlationId];
+        if (context) {
+            delete this.queue[correlationId];
+            context.resolve({ responseDecoder: decoder, responseSize: size });
+        }
+        else {
+            logger_1.log.debug('Could not find pending request for correlationId', { correlationId });
+        }
+        this.chunks = [];
+    }
+    nextCorrelationId() {
+        return this.lastCorrelationId++;
+    }
+}
+exports.Connection = Connection;
+__decorate([
+    trace(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], Connection.prototype, "connect", null);
+__decorate([
+    trace(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", void 0)
+], Connection.prototype, "disconnect", null);
+__decorate([
+    trace((api, body) => ({ message: (0, api_1.getApiName)(api), body })),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Request]),
+    __metadata("design:returntype", Promise)
+], Connection.prototype, "sendRequest", null);