@aws-sdk/node-http-handler - npm Package Compare versions

Comparing version 3.186.0 to 3.188.0

CHANGELOG.md

@@ -6,2 +6,10 @@ # Change Log
 
+# [3.188.0](https://github.com/aws/aws-sdk-js-v3/compare/v3.187.0...v3.188.0) (2022-10-13)
+
+**Note:** Version bump only for package @aws-sdk/node-http-handler
+
+
+
+
+
 # [3.186.0](https://github.com/aws/aws-sdk-js-v3/compare/v3.185.0...v3.186.0) (2022-10-06)
@@ -8,0 +16,0 @@

dist-es/constants.js

@@ -1,1 +0,1 @@
-export var NODEJS_TIMEOUT_ERROR_CODES = ["ECONNRESET", "EPIPE", "ETIMEDOUT"];
+export const NODEJS_TIMEOUT_ERROR_CODES = ["ECONNRESET", "EPIPE", "ETIMEDOUT"];

dist-es/get-transformed-headers.js

@@ -1,21 +0,9 @@
-import { __values } from "tslib";
-var getTransformedHeaders = function (headers) {
-    var e_1, _a;
-    var transformedHeaders = {};
-    try {
-        for (var _b = __values(Object.keys(headers)), _c = _b.next(); !_c.done; _c = _b.next()) {
-            var name_1 = _c.value;
-            var headerValues = headers[name_1];
-            transformedHeaders[name_1] = Array.isArray(headerValues) ? headerValues.join(",") : headerValues;
-        }
+const getTransformedHeaders = (headers) => {
+    const transformedHeaders = {};
+    for (const name of Object.keys(headers)) {
+        const headerValues = headers[name];
+        transformedHeaders[name] = Array.isArray(headerValues) ? headerValues.join(",") : headerValues;
     }
-    catch (e_1_1) { e_1 = { error: e_1_1 }; }
-    finally {
-        try {
-            if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
-        }
-        finally { if (e_1) throw e_1.error; }
-    }
     return transformedHeaders;
 };
 export { getTransformedHeaders };

dist-es/node-http-handler.js

@@ -1,2 +0,1 @@
-import { __awaiter, __generator } from "tslib";
 import { HttpResponse } from "@aws-sdk/protocol-http";
@@ -11,11 +10,10 @@ import { buildQueryString } from "@aws-sdk/querystring-builder";
 import { writeRequestBody } from "./write-request-body";
-var NodeHttpHandler = (function () {
-    function NodeHttpHandler(options) {
-        var _this = this;
+export class NodeHttpHandler {
+    constructor(options) {
         this.metadata = { handlerProtocol: "http/1.1" };
-        this.configProvider = new Promise(function (resolve, reject) {
+        this.configProvider = new Promise((resolve, reject) => {
             if (typeof options === "function") {
                 options()
-                    .then(function (_options) {
-                    resolve(_this.resolveDefaultConfig(_options));
+                    .then((_options) => {
+                    resolve(this.resolveDefaultConfig(_options));
                 })
@@ -25,91 +23,75 @@ .catch(reject);
             else {
-                resolve(_this.resolveDefaultConfig(options));
+                resolve(this.resolveDefaultConfig(options));
             }
         });
     }
-    NodeHttpHandler.prototype.resolveDefaultConfig = function (options) {
-        var _a = options || {}, connectionTimeout = _a.connectionTimeout, socketTimeout = _a.socketTimeout, httpAgent = _a.httpAgent, httpsAgent = _a.httpsAgent;
-        var keepAlive = true;
-        var maxSockets = 50;
+    resolveDefaultConfig(options) {
+        const { connectionTimeout, socketTimeout, httpAgent, httpsAgent } = options || {};
+        const keepAlive = true;
+        const maxSockets = 50;
         return {
-            connectionTimeout: connectionTimeout,
-            socketTimeout: socketTimeout,
-            httpAgent: httpAgent || new hAgent({ keepAlive: keepAlive, maxSockets: maxSockets }),
-            httpsAgent: httpsAgent || new hsAgent({ keepAlive: keepAlive, maxSockets: maxSockets }),
+            connectionTimeout,
+            socketTimeout,
+            httpAgent: httpAgent || new hAgent({ keepAlive, maxSockets }),
+            httpsAgent: httpsAgent || new hsAgent({ keepAlive, maxSockets }),
         };
-    };
-    NodeHttpHandler.prototype.destroy = function () {
-        var _a, _b, _c, _d;
-        (_b = (_a = this.config) === null || _a === void 0 ? void 0 : _a.httpAgent) === null || _b === void 0 ? void 0 : _b.destroy();
-        (_d = (_c = this.config) === null || _c === void 0 ? void 0 : _c.httpsAgent) === null || _d === void 0 ? void 0 : _d.destroy();
-    };
-    NodeHttpHandler.prototype.handle = function (request, _a) {
-        var _b = _a === void 0 ? {} : _a, abortSignal = _b.abortSignal;
-        return __awaiter(this, void 0, void 0, function () {
-            var _c;
-            var _this = this;
-            return __generator(this, function (_d) {
-                switch (_d.label) {
-                    case 0:
-                        if (!!this.config) return [3, 2];
-                        _c = this;
-                        return [4, this.configProvider];
-                    case 1:
-                        _c.config = _d.sent();
-                        _d.label = 2;
-                    case 2: return [2, new Promise(function (resolve, reject) {
-                            if (!_this.config) {
-                                throw new Error("Node HTTP request handler config is not resolved");
-                            }
-                            if (abortSignal === null || abortSignal === void 0 ? void 0 : abortSignal.aborted) {
-                                var abortError = new Error("Request aborted");
-                                abortError.name = "AbortError";
-                                reject(abortError);
-                                return;
-                            }
-                            var isSSL = request.protocol === "https:";
-                            var queryString = buildQueryString(request.query || {});
-                            var nodeHttpsOptions = {
-                                headers: request.headers,
-                                host: request.hostname,
-                                method: request.method,
-                                path: queryString ? "".concat(request.path, "?").concat(queryString) : request.path,
-                                port: request.port,
-                                agent: isSSL ? _this.config.httpsAgent : _this.config.httpAgent,
-                            };
-                            var requestFunc = isSSL ? hsRequest : hRequest;
-                            var req = requestFunc(nodeHttpsOptions, function (res) {
-                                var httpResponse = new HttpResponse({
-                                    statusCode: res.statusCode || -1,
-                                    headers: getTransformedHeaders(res.headers),
-                                    body: res,
-                                });
-                                resolve({ response: httpResponse });
-                            });
-                            req.on("error", function (err) {
-                                if (NODEJS_TIMEOUT_ERROR_CODES.includes(err.code)) {
-                                    reject(Object.assign(err, { name: "TimeoutError" }));
-                                }
-                                else {
-                                    reject(err);
-                                }
-                            });
-                            setConnectionTimeout(req, reject, _this.config.connectionTimeout);
-                            setSocketTimeout(req, reject, _this.config.socketTimeout);
-                            if (abortSignal) {
-                                abortSignal.onabort = function () {
-                                    req.abort();
-                                    var abortError = new Error("Request aborted");
-                                    abortError.name = "AbortError";
-                                    reject(abortError);
-                                };
-                            }
-                            writeRequestBody(req, request);
-                        })];
+    }
+    destroy() {
+        this.config?.httpAgent?.destroy();
+        this.config?.httpsAgent?.destroy();
+    }
+    async handle(request, { abortSignal } = {}) {
+        if (!this.config) {
+            this.config = await this.configProvider;
+        }
+        return new Promise((resolve, reject) => {
+            if (!this.config) {
+                throw new Error("Node HTTP request handler config is not resolved");
+            }
+            if (abortSignal?.aborted) {
+                const abortError = new Error("Request aborted");
+                abortError.name = "AbortError";
+                reject(abortError);
+                return;
+            }
+            const isSSL = request.protocol === "https:";
+            const queryString = buildQueryString(request.query || {});
+            const nodeHttpsOptions = {
+                headers: request.headers,
+                host: request.hostname,
+                method: request.method,
+                path: queryString ? `${request.path}?${queryString}` : request.path,
+                port: request.port,
+                agent: isSSL ? this.config.httpsAgent : this.config.httpAgent,
+            };
+            const requestFunc = isSSL ? hsRequest : hRequest;
+            const req = requestFunc(nodeHttpsOptions, (res) => {
+                const httpResponse = new HttpResponse({
+                    statusCode: res.statusCode || -1,
+                    headers: getTransformedHeaders(res.headers),
+                    body: res,
+                });
+                resolve({ response: httpResponse });
+            });
+            req.on("error", (err) => {
+                if (NODEJS_TIMEOUT_ERROR_CODES.includes(err.code)) {
+                    reject(Object.assign(err, { name: "TimeoutError" }));
                 }
+                else {
+                    reject(err);
+                }
             });
+            setConnectionTimeout(req, reject, this.config.connectionTimeout);
+            setSocketTimeout(req, reject, this.config.socketTimeout);
+            if (abortSignal) {
+                abortSignal.onabort = () => {
+                    req.abort();
+                    const abortError = new Error("Request aborted");
+                    abortError.name = "AbortError";
+                    reject(abortError);
+                };
+            }
+            writeRequestBody(req, request);
         });
-    };
-    return NodeHttpHandler;
-}());
-export { NodeHttpHandler };
+    }
+}

dist-es/node-http2-handler.js

@@ -1,2 +0,1 @@
-import { __assign, __awaiter, __generator, __values } from "tslib";
 import { HttpResponse } from "@aws-sdk/protocol-http";
@@ -7,9 +6,9 @@ import { buildQueryString } from "@aws-sdk/querystring-builder";
 import { writeRequestBody } from "./write-request-body";
-var NodeHttp2Handler = (function () {
-    function NodeHttp2Handler(options) {
+export class NodeHttp2Handler {
+    constructor(options) {
         this.metadata = { handlerProtocol: "h2" };
-        this.configProvider = new Promise(function (resolve, reject) {
+        this.configProvider = new Promise((resolve, reject) => {
             if (typeof options === "function") {
                 options()
-                    .then(function (opts) {
+                    .then((opts) => {
                     resolve(opts || {});
@@ -25,122 +24,97 @@ })
     }
-    NodeHttp2Handler.prototype.destroy = function () {
-        var e_1, _a;
-        var _this = this;
-        try {
-            for (var _b = __values(this.sessionCache.values()), _c = _b.next(); !_c.done; _c = _b.next()) {
-                var sessions = _c.value;
-                sessions.forEach(function (session) { return _this.destroySession(session); });
-            }
+    destroy() {
+        for (const sessions of this.sessionCache.values()) {
+            sessions.forEach((session) => this.destroySession(session));
         }
-        catch (e_1_1) { e_1 = { error: e_1_1 }; }
-        finally {
-            try {
-                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+        this.sessionCache.clear();
+    }
+    async handle(request, { abortSignal } = {}) {
+        if (!this.config) {
+            this.config = await this.configProvider;
+        }
+        const { requestTimeout, disableConcurrentStreams } = this.config;
+        return new Promise((resolve, rejectOriginal) => {
+            let fulfilled = false;
+            if (abortSignal?.aborted) {
+                fulfilled = true;
+                const abortError = new Error("Request aborted");
+                abortError.name = "AbortError";
+                rejectOriginal(abortError);
+                return;
             }
-            finally { if (e_1) throw e_1.error; }
-        }
-        this.sessionCache.clear();
-    };
-    NodeHttp2Handler.prototype.handle = function (request, _a) {
-        var _b = _a === void 0 ? {} : _a, abortSignal = _b.abortSignal;
-        return __awaiter(this, void 0, void 0, function () {
-            var _c, _d, requestTimeout, disableConcurrentStreams;
-            var _this = this;
-            return __generator(this, function (_e) {
-                switch (_e.label) {
-                    case 0:
-                        if (!!this.config) return [3, 2];
-                        _c = this;
-                        return [4, this.configProvider];
-                    case 1:
-                        _c.config = _e.sent();
-                        _e.label = 2;
-                    case 2:
-                        _d = this.config, requestTimeout = _d.requestTimeout, disableConcurrentStreams = _d.disableConcurrentStreams;
-                        return [2, new Promise(function (resolve, rejectOriginal) {
-                                var _a;
-                                var fulfilled = false;
-                                if (abortSignal === null || abortSignal === void 0 ? void 0 : abortSignal.aborted) {
-                                    fulfilled = true;
-                                    var abortError = new Error("Request aborted");
-                                    abortError.name = "AbortError";
-                                    rejectOriginal(abortError);
-                                    return;
-                                }
-                                var hostname = request.hostname, method = request.method, port = request.port, protocol = request.protocol, path = request.path, query = request.query;
-                                var authority = "".concat(protocol, "//").concat(hostname).concat(port ? ":".concat(port) : "");
-                                var session = _this.getSession(authority, disableConcurrentStreams || false);
-                                var reject = function (err) {
-                                    if (disableConcurrentStreams) {
-                                        _this.destroySession(session);
-                                    }
-                                    fulfilled = true;
-                                    rejectOriginal(err);
-                                };
-                                var queryString = buildQueryString(query || {});
-                                var req = session.request(__assign(__assign({}, request.headers), (_a = {}, _a[constants.HTTP2_HEADER_PATH] = queryString ? "".concat(path, "?").concat(queryString) : path, _a[constants.HTTP2_HEADER_METHOD] = method, _a)));
-                                session.ref();
-                                req.on("response", function (headers) {
-                                    var httpResponse = new HttpResponse({
-                                        statusCode: headers[":status"] || -1,
-                                        headers: getTransformedHeaders(headers),
-                                        body: req,
-                                    });
-                                    fulfilled = true;
-                                    resolve({ response: httpResponse });
-                                    if (disableConcurrentStreams) {
-                                        session.close();
-                                        _this.deleteSessionFromCache(authority, session);
-                                    }
-                                });
-                                if (requestTimeout) {
-                                    req.setTimeout(requestTimeout, function () {
-                                        req.close();
-                                        var timeoutError = new Error("Stream timed out because of no activity for ".concat(requestTimeout, " ms"));
-                                        timeoutError.name = "TimeoutError";
-                                        reject(timeoutError);
-                                    });
-                                }
-                                if (abortSignal) {
-                                    abortSignal.onabort = function () {
-                                        req.close();
-                                        var abortError = new Error("Request aborted");
-                                        abortError.name = "AbortError";
-                                        reject(abortError);
-                                    };
-                                }
-                                req.on("frameError", function (type, code, id) {
-                                    reject(new Error("Frame type id ".concat(type, " in stream id ").concat(id, " has failed with code ").concat(code, ".")));
-                                });
-                                req.on("error", reject);
-                                req.on("aborted", function () {
-                                    reject(new Error("HTTP/2 stream is abnormally aborted in mid-communication with result code ".concat(req.rstCode, ".")));
-                                });
-                                req.on("close", function () {
-                                    session.unref();
-                                    if (disableConcurrentStreams) {
-                                        session.destroy();
-                                    }
-                                    if (!fulfilled) {
-                                        reject(new Error("Unexpected error: http2 request did not get a response"));
-                                    }
-                                });
-                                writeRequestBody(req, request);
-                            })];
+            const { hostname, method, port, protocol, path, query } = request;
+            const authority = `${protocol}//${hostname}${port ? `:${port}` : ""}`;
+            const session = this.getSession(authority, disableConcurrentStreams || false);
+            const reject = (err) => {
+                if (disableConcurrentStreams) {
+                    this.destroySession(session);
                 }
+                fulfilled = true;
+                rejectOriginal(err);
+            };
+            const queryString = buildQueryString(query || {});
+            const req = session.request({
+                ...request.headers,
+                [constants.HTTP2_HEADER_PATH]: queryString ? `${path}?${queryString}` : path,
+                [constants.HTTP2_HEADER_METHOD]: method,
             });
+            session.ref();
+            req.on("response", (headers) => {
+                const httpResponse = new HttpResponse({
+                    statusCode: headers[":status"] || -1,
+                    headers: getTransformedHeaders(headers),
+                    body: req,
+                });
+                fulfilled = true;
+                resolve({ response: httpResponse });
+                if (disableConcurrentStreams) {
+                    session.close();
+                    this.deleteSessionFromCache(authority, session);
+                }
+            });
+            if (requestTimeout) {
+                req.setTimeout(requestTimeout, () => {
+                    req.close();
+                    const timeoutError = new Error(`Stream timed out because of no activity for ${requestTimeout} ms`);
+                    timeoutError.name = "TimeoutError";
+                    reject(timeoutError);
+                });
+            }
+            if (abortSignal) {
+                abortSignal.onabort = () => {
+                    req.close();
+                    const abortError = new Error("Request aborted");
+                    abortError.name = "AbortError";
+                    reject(abortError);
+                };
+            }
+            req.on("frameError", (type, code, id) => {
+                reject(new Error(`Frame type id ${type} in stream id ${id} has failed with code ${code}.`));
+            });
+            req.on("error", reject);
+            req.on("aborted", () => {
+                reject(new Error(`HTTP/2 stream is abnormally aborted in mid-communication with result code ${req.rstCode}.`));
+            });
+            req.on("close", () => {
+                session.unref();
+                if (disableConcurrentStreams) {
+                    session.destroy();
+                }
+                if (!fulfilled) {
+                    reject(new Error("Unexpected error: http2 request did not get a response"));
+                }
+            });
+            writeRequestBody(req, request);
         });
-    };
-    NodeHttp2Handler.prototype.getSession = function (authority, disableConcurrentStreams) {
-        var _this = this;
-        var _a;
-        var sessionCache = this.sessionCache;
-        var existingSessions = sessionCache.get(authority) || [];
+    }
+    getSession(authority, disableConcurrentStreams) {
+        const sessionCache = this.sessionCache;
+        const existingSessions = sessionCache.get(authority) || [];
         if (existingSessions.length > 0 && !disableConcurrentStreams)
             return existingSessions[0];
-        var newSession = connect(authority);
+        const newSession = connect(authority);
         newSession.unref();
-        var destroySessionCb = function () {
-            _this.destroySession(newSession);
-            _this.deleteSessionFromCache(authority, newSession);
+        const destroySessionCb = () => {
+            this.destroySession(newSession);
+            this.deleteSessionFromCache(authority, newSession);
         };
@@ -150,4 +124,4 @@ newSession.on("goaway", destroySessionCb);
         newSession.on("frameError", destroySessionCb);
-        newSession.on("close", function () { return _this.deleteSessionFromCache(authority, newSession); });
-        if ((_a = this.config) === null || _a === void 0 ? void 0 : _a.sessionTimeout) {
+        newSession.on("close", () => this.deleteSessionFromCache(authority, newSession));
+        if (this.config?.sessionTimeout) {
             newSession.setTimeout(this.config.sessionTimeout, destroySessionCb);
@@ -158,17 +132,15 @@ }
         return newSession;
-    };
-    NodeHttp2Handler.prototype.destroySession = function (session) {
+    }
+    destroySession(session) {
         if (!session.destroyed) {
             session.destroy();
         }
-    };
-    NodeHttp2Handler.prototype.deleteSessionFromCache = function (authority, session) {
-        var existingSessions = this.sessionCache.get(authority) || [];
+    }
+    deleteSessionFromCache(authority, session) {
+        const existingSessions = this.sessionCache.get(authority) || [];
         if (!existingSessions.includes(session)) {
             return;
         }
-        this.sessionCache.set(authority, existingSessions.filter(function (s) { return s !== session; }));
-    };
-    return NodeHttp2Handler;
-}());
-export { NodeHttp2Handler };
+        this.sessionCache.set(authority, existingSessions.filter((s) => s !== session));
+    }
+}

dist-es/readable.mock.js

@@ -1,13 +0,10 @@
-import { __extends } from "tslib";
 import { Readable } from "stream";
-var ReadFromBuffers = (function (_super) {
-    __extends(ReadFromBuffers, _super);
-    function ReadFromBuffers(options) {
-        var _this = _super.call(this, options) || this;
-        _this.numBuffersRead = 0;
-        _this.buffersToRead = options.buffers;
-        _this.errorAfter = typeof options.errorAfter === "number" ? options.errorAfter : -1;
-        return _this;
+export class ReadFromBuffers extends Readable {
+    constructor(options) {
+        super(options);
+        this.numBuffersRead = 0;
+        this.buffersToRead = options.buffers;
+        this.errorAfter = typeof options.errorAfter === "number" ? options.errorAfter : -1;
     }
-    ReadFromBuffers.prototype._read = function () {
+    _read() {
         if (this.errorAfter !== -1 && this.errorAfter === this.numBuffersRead) {
@@ -21,5 +18,3 @@ this.emit("error", new Error("Mock Error"));
         return this.push(this.buffersToRead[this.numBuffersRead++]);
-    };
-    return ReadFromBuffers;
-}(Readable));
-export { ReadFromBuffers };
+    }
+}

dist-es/server.mock.js

@@ -1,2 +0,1 @@
-import { __read, __values } from "tslib";
 import { readFileSync } from "fs";
@@ -8,20 +7,9 @@ import { createServer as createHttpServer } from "http";
 import { Readable } from "stream";
-var fixturesDir = join(__dirname, "..", "fixtures");
-var setResponseHeaders = function (response, headers) {
-    var e_1, _a;
-    try {
-        for (var _b = __values(Object.entries(headers)), _c = _b.next(); !_c.done; _c = _b.next()) {
-            var _d = __read(_c.value, 2), key = _d[0], value = _d[1];
-            response.setHeader(key, value);
-        }
+const fixturesDir = join(__dirname, "..", "fixtures");
+const setResponseHeaders = (response, headers) => {
+    for (const [key, value] of Object.entries(headers)) {
+        response.setHeader(key, value);
     }
-    catch (e_1_1) { e_1 = { error: e_1_1 }; }
-    finally {
-        try {
-            if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
-        }
-        finally { if (e_1) throw e_1.error; }
-    }
 };
-var setResponseBody = function (response, body) {
+const setResponseBody = (response, body) => {
     if (body instanceof Readable) {
@@ -34,20 +22,20 @@ body.pipe(response);
 };
-export var createResponseFunction = function (httpResp) { return function (request, response) {
+export const createResponseFunction = (httpResp) => (request, response) => {
     response.statusCode = httpResp.statusCode;
     setResponseHeaders(response, httpResp.headers);
     setResponseBody(response, httpResp.body);
-}; };
-export var createResponseFunctionWithDelay = function (httpResp, delay) { return function (request, response) {
+};
+export const createResponseFunctionWithDelay = (httpResp, delay) => (request, response) => {
     response.statusCode = httpResp.statusCode;
     setResponseHeaders(response, httpResp.headers);
-    setTimeout(function () { return setResponseBody(response, httpResp.body); }, delay);
-}; };
-export var createContinueResponseFunction = function (httpResp) { return function (request, response) {
+    setTimeout(() => setResponseBody(response, httpResp.body), delay);
+};
+export const createContinueResponseFunction = (httpResp) => (request, response) => {
     response.writeContinue();
-    setTimeout(function () {
+    setTimeout(() => {
         createResponseFunction(httpResp)(request, response);
     }, 100);
-}; };
-export var createMockHttpsServer = function () {
-    var server = createHttpsServer({
+};
+export const createMockHttpsServer = () => {
+    const server = createHttpsServer({
         key: readFileSync(join(fixturesDir, "test-server-key.pem")),
@@ -58,9 +46,9 @@ cert: readFileSync(join(fixturesDir, "test-server-cert.pem")),
 };
-export var createMockHttpServer = function () {
-    var server = createHttpServer();
+export const createMockHttpServer = () => {
+    const server = createHttpServer();
     return server;
 };
-export var createMockHttp2Server = function () {
-    var server = createHttp2Server();
+export const createMockHttp2Server = () => {
+    const server = createHttp2Server();
     return server;
 };

dist-es/set-connection-timeout.js

@@ -1,16 +0,15 @@
-export var setConnectionTimeout = function (request, reject, timeoutInMs) {
-    if (timeoutInMs === void 0) { timeoutInMs = 0; }
+export const setConnectionTimeout = (request, reject, timeoutInMs = 0) => {
     if (!timeoutInMs) {
         return;
     }
-    request.on("socket", function (socket) {
+    request.on("socket", (socket) => {
         if (socket.connecting) {
-            var timeoutId_1 = setTimeout(function () {
+            const timeoutId = setTimeout(() => {
                 request.destroy();
-                reject(Object.assign(new Error("Socket timed out without establishing a connection within ".concat(timeoutInMs, " ms")), {
+                reject(Object.assign(new Error(`Socket timed out without establishing a connection within ${timeoutInMs} ms`), {
                     name: "TimeoutError",
                 }));
             }, timeoutInMs);
-            socket.on("connect", function () {
-                clearTimeout(timeoutId_1);
+            socket.on("connect", () => {
+                clearTimeout(timeoutId);
             });
@@ -17,0 +16,0 @@ }

dist-es/set-socket-timeout.js

@@ -1,7 +0,6 @@
-export var setSocketTimeout = function (request, reject, timeoutInMs) {
-    if (timeoutInMs === void 0) { timeoutInMs = 0; }
-    request.setTimeout(timeoutInMs, function () {
+export const setSocketTimeout = (request, reject, timeoutInMs = 0) => {
+    request.setTimeout(timeoutInMs, () => {
         request.destroy();
-        reject(Object.assign(new Error("Connection timed out after ".concat(timeoutInMs, " ms")), { name: "TimeoutError" }));
+        reject(Object.assign(new Error(`Connection timed out after ${timeoutInMs} ms`), { name: "TimeoutError" }));
     });
 };

dist-es/stream-collector/collector.js

@@ -1,16 +0,11 @@
-import { __extends } from "tslib";
 import { Writable } from "stream";
-var Collector = (function (_super) {
-    __extends(Collector, _super);
-    function Collector() {
-        var _this = _super !== null && _super.apply(this, arguments) || this;
-        _this.bufferedBytes = [];
-        return _this;
+export class Collector extends Writable {
+    constructor() {
+        super(...arguments);
+        this.bufferedBytes = [];
     }
-    Collector.prototype._write = function (chunk, encoding, callback) {
+    _write(chunk, encoding, callback) {
         this.bufferedBytes.push(chunk);
         callback();
-    };
-    return Collector;
-}(Writable));
-export { Collector };
+    }
+}

dist-es/stream-collector/index.js

 import { Collector } from "./collector";
-export var streamCollector = function (stream) {
-    return new Promise(function (resolve, reject) {
-        var collector = new Collector();
-        stream.pipe(collector);
-        stream.on("error", function (err) {
-            collector.end();
-            reject(err);
-        });
-        collector.on("error", reject);
-        collector.on("finish", function () {
-            var bytes = new Uint8Array(Buffer.concat(this.bufferedBytes));
-            resolve(bytes);
-        });
+export const streamCollector = (stream) => new Promise((resolve, reject) => {
+    const collector = new Collector();
+    stream.pipe(collector);
+    stream.on("error", (err) => {
+        collector.end();
+        reject(err);
     });
-};
+    collector.on("error", reject);
+    collector.on("finish", function () {
+        const bytes = new Uint8Array(Buffer.concat(this.bufferedBytes));
+        resolve(bytes);
+    });
+});

dist-es/stream-collector/readable.mock.js

@@ -1,13 +0,10 @@
-import { __extends } from "tslib";
 import { Readable } from "stream";
-var ReadFromBuffers = (function (_super) {
-    __extends(ReadFromBuffers, _super);
-    function ReadFromBuffers(options) {
-        var _this = _super.call(this, options) || this;
-        _this.numBuffersRead = 0;
-        _this.buffersToRead = options.buffers;
-        _this.errorAfter = typeof options.errorAfter === "number" ? options.errorAfter : -1;
-        return _this;
+export class ReadFromBuffers extends Readable {
+    constructor(options) {
+        super(options);
+        this.numBuffersRead = 0;
+        this.buffersToRead = options.buffers;
+        this.errorAfter = typeof options.errorAfter === "number" ? options.errorAfter : -1;
     }
-    ReadFromBuffers.prototype._read = function (size) {
+    _read(size) {
         if (this.errorAfter !== -1 && this.errorAfter === this.numBuffersRead) {
@@ -21,5 +18,3 @@ this.emit("error", new Error("Mock Error"));
         return this.push(this.buffersToRead[this.numBuffersRead++]);
-    };
-    return ReadFromBuffers;
-}(Readable));
-export { ReadFromBuffers };
+    }
+}

dist-es/write-request-body.js

 import { Readable } from "stream";
 export function writeRequestBody(httpRequest, request) {
-    var expect = request.headers["Expect"] || request.headers["expect"];
+    const expect = request.headers["Expect"] || request.headers["expect"];
     if (expect === "100-continue") {
-        httpRequest.on("continue", function () {
+        httpRequest.on("continue", () => {
             writeBody(httpRequest, request.body);
@@ -7,0 +7,0 @@ });

package.json

 {
   "name": "@aws-sdk/node-http-handler",
-  "version": "3.186.0",
+  "version": "3.188.0",
   "description": "Provides a way to make requests",
@@ -25,6 +25,6 @@ "scripts": {
   "dependencies": {
-    "@aws-sdk/abort-controller": "3.186.0",
-    "@aws-sdk/protocol-http": "3.186.0",
-    "@aws-sdk/querystring-builder": "3.186.0",
-    "@aws-sdk/types": "3.186.0",
+    "@aws-sdk/abort-controller": "3.188.0",
+    "@aws-sdk/protocol-http": "3.188.0",
+    "@aws-sdk/querystring-builder": "3.188.0",
+    "@aws-sdk/types": "3.188.0",
     "tslib": "^2.3.1"
@@ -31,0 +31,0 @@ },

No alert changes

Worsened metrics

Total package byte prevSize

113423

decreased by-5.71%

Lines of code

1172

decreased by-7.06%

Dependency changes

• + Added@aws-sdk/abort-controller@3.188.0(transitive)

• + Added@aws-sdk/protocol-http@3.188.0(transitive)

• + Added@aws-sdk/querystring-builder@3.188.0(transitive)

• + Added@aws-sdk/types@3.188.0(transitive)

• + Added@aws-sdk/util-uri-escape@3.188.0(transitive)

• - Removed@aws-sdk/abort-controller@3.186.0(transitive)

• - Removed@aws-sdk/protocol-http@3.186.0(transitive)

• - Removed@aws-sdk/querystring-builder@3.186.0(transitive)

• - Removed@aws-sdk/types@3.186.0(transitive)

• - Removed@aws-sdk/util-uri-escape@3.186.0(transitive)

• Updated@aws-sdk/abort-controller@3.188.0

• Updated@aws-sdk/protocol-http@3.188.0

• Updated@aws-sdk/querystring-builder@3.188.0

• Updated@aws-sdk/types@3.188.0