kafka-ts 0.0.3-beta → 0.0.3

package/dist/cluster.js

@@ -0,0 +1,70 @@
+"use strict";
+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");
+class Cluster {
+    options;
+    seedBroker = new broker_1.Broker({ clientId: null, sasl: null, ssl: null, options: { port: 9092 } });
+    brokerById = {};
+    brokerMetadata = {};
+    constructor(options) {
+        this.options = options;
+    }
+    async connect() {
+        this.seedBroker = await this.findSeedBroker();
+        this.brokerById = {};
+        const metadata = await this.sendRequest(api_1.API.METADATA, {
+            allowTopicAutoCreation: false,
+            includeTopicAuthorizedOperations: false,
+            topics: [],
+        });
+        this.brokerMetadata = Object.fromEntries(metadata.brokers.map((options) => [options.nodeId, options]));
+    }
+    async disconnect() {
+        await Promise.all([this.seedBroker.disconnect(), ...Object.values(this.brokerById).map((x) => x.disconnect())]);
+    }
+    setSeedBroker = async (nodeId) => {
+        await this.seedBroker.disconnect();
+        this.seedBroker = await this.acquireBroker(nodeId);
+    };
+    sendRequest = (...args) => this.seedBroker.sendRequest(...args);
+    sendRequestToNode = (nodeId) => async (...args) => {
+        if (!this.brokerById[nodeId]) {
+            this.brokerById[nodeId] = await this.acquireBroker(nodeId);
+        }
+        return this.brokerById[nodeId].sendRequest(...args);
+    };
+    async acquireBroker(nodeId) {
+        const broker = new broker_1.Broker({
+            clientId: this.options.clientId,
+            sasl: this.options.sasl,
+            ssl: this.options.ssl,
+            options: this.brokerMetadata[nodeId],
+        });
+        await broker.connect();
+        return broker;
+    }
+    async findSeedBroker() {
+        const randomizedBrokers = this.options.bootstrapServers.toSorted(() => Math.random() - 0.5);
+        for (const options of randomizedBrokers) {
+            try {
+                const broker = await new broker_1.Broker({
+                    clientId: this.options.clientId,
+                    sasl: this.options.sasl,
+                    ssl: this.options.ssl,
+                    options,
+                });
+                await broker.connect();
+                return broker;
+            }
+            catch (error) {
+                logger_1.log.warn(`Failed to connect to seed broker ${options.host}:${options.port}`, error);
+            }
+        }
+        throw new error_1.KafkaTSError('No seed brokers found');
+    }
+}
+exports.Cluster = Cluster;

package/dist/cluster.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/cluster.test.js

@@ -0,0 +1,343 @@
+"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: (0, auth_1.saslPlain)({ username: 'admin', password: 'admin' }),
+    ssl: { ca: (0, fs_1.readFileSync)('./certs/ca.crt').toString() },
+});
+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_1.API.DELETE_TOPICS, {
+                topics: [{ name: 'kafka-ts-test-topic', topicId: null }],
+                timeoutMs: 10000,
+            });
+        }
+    });
+    (0, vitest_1.afterAll)(async () => {
+        await cluster.disconnect();
+    });
+    (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 = '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: 10,
+                    replicationFactor: 3,
+                    assignments: [],
+                    configs: [],
+                },
+            ],
+            timeoutMs: 10000,
+            validateOnly: false,
+        });
+        topicId = result.topics[0].topicId;
+        result.topics.forEach((topic) => {
+            topic.topicId = 'Any<UUID>';
+        });
+        (0, vitest_1.expect)(result).toMatchSnapshot();
+        await new Promise((resolve) => setTimeout(resolve, 1000));
+    });
+    (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,
+        });
+        result.controllerId = 0;
+        result.topics = result.topics.filter((topic) => topic.name !== '__consumer_offsets');
+        result.topics.forEach((topic) => {
+            topic.topicId = 'Any<UUID>';
+            topic.partitions.forEach((partition) => {
+                partition.leaderId = 0;
+                partition.isrNodes = [0];
+                partition.replicaNodes = [0];
+            });
+        });
+        (0, vitest_1.expect)(result).toMatchSnapshot();
+    });
+    let partitionIndex = 0;
+    let leaderId = 0;
+    (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) => {
+            topic.topicId = 'Any<UUID>';
+            topic.partitions.forEach((partition) => {
+                partition.leaderId = 0;
+                partition.isrNodes = [0];
+                partition.replicaNodes = [0];
+            });
+        });
+        (0, vitest_1.expect)(result).toMatchSnapshot();
+    });
+    let producerId = 9n;
+    (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;
+        (0, vitest_1.expect)(result).toMatchSnapshot();
+    });
+    (0, vitest_1.it)('should produce messages', async () => {
+        const now = Date.now();
+        const result = await cluster.sendRequestToNode(leaderId)(api_1.API.PRODUCE, {
+            transactionalId: null,
+            timeoutMs: 10000,
+            acks: 1,
+            topicData: [
+                {
+                    name: 'kafka-ts-test-topic',
+                    partitionData: [
+                        {
+                            index: partitionIndex,
+                            baseOffset: 0n,
+                            partitionLeaderEpoch: 0,
+                            attributes: 0,
+                            baseSequence: 0,
+                            baseTimestamp: BigInt(now),
+                            lastOffsetDelta: 0,
+                            maxTimestamp: BigInt(now),
+                            producerEpoch: 0,
+                            producerId,
+                            records: [
+                                {
+                                    attributes: 0,
+                                    offsetDelta: 0,
+                                    timestampDelta: 0n,
+                                    key: Buffer.from('key'),
+                                    value: Buffer.from('value'),
+                                    headers: [
+                                        {
+                                            key: Buffer.from('header-key'),
+                                            value: Buffer.from('header-value'),
+                                        },
+                                    ],
+                                },
+                            ],
+                        },
+                    ],
+                },
+            ],
+        });
+        (0, vitest_1.expect)(result).toMatchSnapshot();
+    });
+    (0, vitest_1.it)('should fetch messages', async () => {
+        const result = await cluster.sendRequestToNode(leaderId)(api_1.API.FETCH, {
+            maxWaitMs: 100,
+            minBytes: 1,
+            maxBytes: 10485760,
+            isolationLevel: 1,
+            sessionId: 0,
+            sessionEpoch: -1,
+            topics: [
+                {
+                    topicId,
+                    partitions: [
+                        {
+                            partition: partitionIndex,
+                            currentLeaderEpoch: -1,
+                            fetchOffset: 0n,
+                            lastFetchedEpoch: 0,
+                            logStartOffset: -1n,
+                            partitionMaxBytes: 10485760,
+                        },
+                    ],
+                },
+            ],
+            forgottenTopicsData: [],
+            rackId: '',
+        });
+        result.responses.forEach((response) => {
+            response.topicId = 'Any<UUID>';
+            response.partitions.forEach((partition) => {
+                partition.records.forEach((record) => {
+                    (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;
+                });
+            });
+        });
+        (0, vitest_1.expect)(result).toMatchSnapshot();
+    });
+    let coordinatorId = -1;
+    (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>';
+        });
+        coordinatorId = result.coordinators[0].nodeId;
+        result.coordinators.forEach((coordinator) => {
+            coordinator.nodeId = 1;
+            coordinator.port = 9093;
+        });
+        (0, vitest_1.expect)(result).toMatchSnapshot();
+    });
+    let memberId = '';
+    (0, vitest_1.it)('should fail join group request with new memberId', async () => {
+        try {
+            const result = await cluster.sendRequestToNode(coordinatorId)(api_1.API.JOIN_GROUP, {
+                groupId,
+                sessionTimeoutMs: 30000,
+                rebalanceTimeoutMs: 60000,
+                memberId,
+                groupInstanceId: null,
+                protocolType: 'consumer',
+                protocols: [
+                    {
+                        name: 'RoundRobinAssigner',
+                        metadata: { version: 0, topics: ['kafka-ts-test-topic'] },
+                    },
+                ],
+                reason: null,
+            });
+            (0, vitest_1.expect)(false, 'Should throw an error').toBe(true);
+        }
+        catch (error) {
+            const { response } = error;
+            memberId = response.memberId;
+            response.memberId = 'Any<UUID>';
+            (0, vitest_1.expect)(response).toMatchSnapshot();
+        }
+    });
+    (0, vitest_1.it)('should join group', async () => {
+        const result = await cluster.sendRequestToNode(coordinatorId)(api_1.API.JOIN_GROUP, {
+            groupId,
+            sessionTimeoutMs: 30000,
+            rebalanceTimeoutMs: 60000,
+            memberId,
+            groupInstanceId: null,
+            protocolType: 'consumer',
+            protocols: [
+                {
+                    name: 'RoundRobinAssigner',
+                    metadata: { version: 0, topics: ['kafka-ts-test-topic'] },
+                },
+            ],
+            reason: null,
+        });
+        result.memberId = 'Any<UUID>';
+        result.leader = 'Any<UUID>';
+        result.members.forEach((member) => {
+            member.memberId = 'Any<UUID>';
+        });
+        (0, vitest_1.expect)(result).toMatchSnapshot();
+    });
+    (0, vitest_1.it)('should sync group', async () => {
+        const result = await cluster.sendRequestToNode(coordinatorId)(api_1.API.SYNC_GROUP, {
+            groupId,
+            generationId: 1,
+            memberId,
+            groupInstanceId: null,
+            protocolType: 'consumer',
+            protocolName: 'RoundRobinAssigner',
+            assignments: [
+                {
+                    memberId,
+                    assignment: { 'kafka-test-topic': [0] },
+                },
+            ],
+        });
+        (0, vitest_1.expect)(result).toMatchSnapshot();
+    });
+    (0, vitest_1.it)('should commit offsets', async () => {
+        const result = await cluster.sendRequestToNode(coordinatorId)(api_1.API.OFFSET_COMMIT, {
+            groupId,
+            generationIdOrMemberEpoch: 1,
+            memberId,
+            groupInstanceId: null,
+            topics: [
+                {
+                    name: 'kafka-ts-test-topic',
+                    partitions: [
+                        { partitionIndex: 0, committedOffset: 1n, committedLeaderEpoch: 0, committedMetadata: null },
+                    ],
+                },
+            ],
+        });
+        (0, vitest_1.expect)(result).toMatchSnapshot();
+    });
+    (0, vitest_1.it)('should fetch offsets', async () => {
+        const result = await cluster.sendRequestToNode(coordinatorId)(api_1.API.OFFSET_FETCH, {
+            groups: [
+                {
+                    groupId,
+                    topics: [
+                        {
+                            name: 'kafka-ts-test-topic',
+                            partitionIndexes: [0],
+                        },
+                    ],
+                },
+            ],
+            requireStable: false,
+        });
+        result.groups.forEach((group) => {
+            group.groupId = 'Any<String>';
+        });
+        (0, vitest_1.expect)(result).toMatchSnapshot();
+    });
+    (0, vitest_1.it)('should heartbeat', async () => {
+        const result = await cluster.sendRequestToNode(coordinatorId)(api_1.API.HEARTBEAT, {
+            groupId,
+            generationId: 1,
+            memberId,
+            groupInstanceId: null,
+        });
+        (0, vitest_1.expect)(result).toMatchSnapshot();
+    });
+    (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>';
+        });
+        (0, vitest_1.expect)(result).toMatchSnapshot();
+    });
+    (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>';
+        });
+        (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);