@aws-sdk/node-http-handler
Advanced tools
Comparing version 3.185.0 to 3.186.0
@@ -6,2 +6,10 @@ # Change Log | ||
# [3.186.0](https://github.com/aws/aws-sdk-js-v3/compare/v3.185.0...v3.186.0) (2022-10-06) | ||
**Note:** Version bump only for package @aws-sdk/node-http-handler | ||
# [3.185.0](https://github.com/aws/aws-sdk-js-v3/compare/v3.184.0...v3.185.0) (2022-10-05) | ||
@@ -8,0 +16,0 @@ |
@@ -1,1 +0,1 @@ | ||
export const NODEJS_TIMEOUT_ERROR_CODES = ["ECONNRESET", "EPIPE", "ETIMEDOUT"]; | ||
export var NODEJS_TIMEOUT_ERROR_CODES = ["ECONNRESET", "EPIPE", "ETIMEDOUT"]; |
@@ -1,9 +0,21 @@ | ||
const getTransformedHeaders = (headers) => { | ||
const transformedHeaders = {}; | ||
for (const name of Object.keys(headers)) { | ||
const headerValues = headers[name]; | ||
transformedHeaders[name] = Array.isArray(headerValues) ? headerValues.join(",") : headerValues; | ||
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; | ||
} | ||
} | ||
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 }; |
@@ -0,1 +1,2 @@ | ||
import { __awaiter, __generator } from "tslib"; | ||
import { HttpResponse } from "@aws-sdk/protocol-http"; | ||
@@ -10,10 +11,11 @@ import { buildQueryString } from "@aws-sdk/querystring-builder"; | ||
import { writeRequestBody } from "./write-request-body"; | ||
export class NodeHttpHandler { | ||
constructor(options) { | ||
var NodeHttpHandler = (function () { | ||
function NodeHttpHandler(options) { | ||
var _this = this; | ||
this.metadata = { handlerProtocol: "http/1.1" }; | ||
this.configProvider = new Promise((resolve, reject) => { | ||
this.configProvider = new Promise(function (resolve, reject) { | ||
if (typeof options === "function") { | ||
options() | ||
.then((_options) => { | ||
resolve(this.resolveDefaultConfig(_options)); | ||
.then(function (_options) { | ||
resolve(_this.resolveDefaultConfig(_options)); | ||
}) | ||
@@ -23,75 +25,91 @@ .catch(reject); | ||
else { | ||
resolve(this.resolveDefaultConfig(options)); | ||
resolve(_this.resolveDefaultConfig(options)); | ||
} | ||
}); | ||
} | ||
resolveDefaultConfig(options) { | ||
const { connectionTimeout, socketTimeout, httpAgent, httpsAgent } = options || {}; | ||
const keepAlive = true; | ||
const maxSockets = 50; | ||
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; | ||
return { | ||
connectionTimeout, | ||
socketTimeout, | ||
httpAgent: httpAgent || new hAgent({ keepAlive, maxSockets }), | ||
httpsAgent: httpsAgent || new hsAgent({ keepAlive, maxSockets }), | ||
connectionTimeout: connectionTimeout, | ||
socketTimeout: socketTimeout, | ||
httpAgent: httpAgent || new hAgent({ keepAlive: keepAlive, maxSockets: maxSockets }), | ||
httpsAgent: httpsAgent || new hsAgent({ keepAlive: keepAlive, maxSockets: maxSockets }), | ||
}; | ||
} | ||
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" })); | ||
}; | ||
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); | ||
})]; | ||
} | ||
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 }; |
@@ -0,1 +1,2 @@ | ||
import { __assign, __awaiter, __generator, __values } from "tslib"; | ||
import { HttpResponse } from "@aws-sdk/protocol-http"; | ||
@@ -6,9 +7,9 @@ import { buildQueryString } from "@aws-sdk/querystring-builder"; | ||
import { writeRequestBody } from "./write-request-body"; | ||
export class NodeHttp2Handler { | ||
constructor(options) { | ||
var NodeHttp2Handler = (function () { | ||
function NodeHttp2Handler(options) { | ||
this.metadata = { handlerProtocol: "h2" }; | ||
this.configProvider = new Promise((resolve, reject) => { | ||
this.configProvider = new Promise(function (resolve, reject) { | ||
if (typeof options === "function") { | ||
options() | ||
.then((opts) => { | ||
.then(function (opts) { | ||
resolve(opts || {}); | ||
@@ -24,97 +25,122 @@ }) | ||
} | ||
destroy() { | ||
for (const sessions of this.sessionCache.values()) { | ||
sessions.forEach((session) => this.destroySession(session)); | ||
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); }); | ||
} | ||
} | ||
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; } | ||
} | ||
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; | ||
} | ||
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); | ||
}; | ||
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); | ||
})]; | ||
} | ||
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); | ||
}); | ||
} | ||
getSession(authority, disableConcurrentStreams) { | ||
const sessionCache = this.sessionCache; | ||
const existingSessions = sessionCache.get(authority) || []; | ||
}; | ||
NodeHttp2Handler.prototype.getSession = function (authority, disableConcurrentStreams) { | ||
var _this = this; | ||
var _a; | ||
var sessionCache = this.sessionCache; | ||
var existingSessions = sessionCache.get(authority) || []; | ||
if (existingSessions.length > 0 && !disableConcurrentStreams) | ||
return existingSessions[0]; | ||
const newSession = connect(authority); | ||
var newSession = connect(authority); | ||
newSession.unref(); | ||
const destroySessionCb = () => { | ||
this.destroySession(newSession); | ||
this.deleteSessionFromCache(authority, newSession); | ||
var destroySessionCb = function () { | ||
_this.destroySession(newSession); | ||
_this.deleteSessionFromCache(authority, newSession); | ||
}; | ||
@@ -124,4 +150,4 @@ newSession.on("goaway", destroySessionCb); | ||
newSession.on("frameError", destroySessionCb); | ||
newSession.on("close", () => this.deleteSessionFromCache(authority, newSession)); | ||
if (this.config?.sessionTimeout) { | ||
newSession.on("close", function () { return _this.deleteSessionFromCache(authority, newSession); }); | ||
if ((_a = this.config) === null || _a === void 0 ? void 0 : _a.sessionTimeout) { | ||
newSession.setTimeout(this.config.sessionTimeout, destroySessionCb); | ||
@@ -132,15 +158,17 @@ } | ||
return newSession; | ||
} | ||
destroySession(session) { | ||
}; | ||
NodeHttp2Handler.prototype.destroySession = function (session) { | ||
if (!session.destroyed) { | ||
session.destroy(); | ||
} | ||
} | ||
deleteSessionFromCache(authority, session) { | ||
const existingSessions = this.sessionCache.get(authority) || []; | ||
}; | ||
NodeHttp2Handler.prototype.deleteSessionFromCache = function (authority, session) { | ||
var existingSessions = this.sessionCache.get(authority) || []; | ||
if (!existingSessions.includes(session)) { | ||
return; | ||
} | ||
this.sessionCache.set(authority, existingSessions.filter((s) => s !== session)); | ||
} | ||
} | ||
this.sessionCache.set(authority, existingSessions.filter(function (s) { return s !== session; })); | ||
}; | ||
return NodeHttp2Handler; | ||
}()); | ||
export { NodeHttp2Handler }; |
@@ -0,10 +1,13 @@ | ||
import { __extends } from "tslib"; | ||
import { Readable } from "stream"; | ||
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; | ||
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; | ||
} | ||
_read() { | ||
ReadFromBuffers.prototype._read = function () { | ||
if (this.errorAfter !== -1 && this.errorAfter === this.numBuffersRead) { | ||
@@ -18,3 +21,5 @@ this.emit("error", new Error("Mock Error")); | ||
return this.push(this.buffersToRead[this.numBuffersRead++]); | ||
} | ||
} | ||
}; | ||
return ReadFromBuffers; | ||
}(Readable)); | ||
export { ReadFromBuffers }; |
@@ -0,1 +1,2 @@ | ||
import { __read, __values } from "tslib"; | ||
import { readFileSync } from "fs"; | ||
@@ -7,9 +8,20 @@ import { createServer as createHttpServer } from "http"; | ||
import { Readable } from "stream"; | ||
const fixturesDir = join(__dirname, "..", "fixtures"); | ||
const setResponseHeaders = (response, headers) => { | ||
for (const [key, value] of Object.entries(headers)) { | ||
response.setHeader(key, value); | ||
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); | ||
} | ||
} | ||
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; } | ||
} | ||
}; | ||
const setResponseBody = (response, body) => { | ||
var setResponseBody = function (response, body) { | ||
if (body instanceof Readable) { | ||
@@ -22,20 +34,20 @@ body.pipe(response); | ||
}; | ||
export const createResponseFunction = (httpResp) => (request, response) => { | ||
export var createResponseFunction = function (httpResp) { return function (request, response) { | ||
response.statusCode = httpResp.statusCode; | ||
setResponseHeaders(response, httpResp.headers); | ||
setResponseBody(response, httpResp.body); | ||
}; | ||
export const createResponseFunctionWithDelay = (httpResp, delay) => (request, response) => { | ||
}; }; | ||
export var createResponseFunctionWithDelay = function (httpResp, delay) { return function (request, response) { | ||
response.statusCode = httpResp.statusCode; | ||
setResponseHeaders(response, httpResp.headers); | ||
setTimeout(() => setResponseBody(response, httpResp.body), delay); | ||
}; | ||
export const createContinueResponseFunction = (httpResp) => (request, response) => { | ||
setTimeout(function () { return setResponseBody(response, httpResp.body); }, delay); | ||
}; }; | ||
export var createContinueResponseFunction = function (httpResp) { return function (request, response) { | ||
response.writeContinue(); | ||
setTimeout(() => { | ||
setTimeout(function () { | ||
createResponseFunction(httpResp)(request, response); | ||
}, 100); | ||
}; | ||
export const createMockHttpsServer = () => { | ||
const server = createHttpsServer({ | ||
}; }; | ||
export var createMockHttpsServer = function () { | ||
var server = createHttpsServer({ | ||
key: readFileSync(join(fixturesDir, "test-server-key.pem")), | ||
@@ -46,9 +58,9 @@ cert: readFileSync(join(fixturesDir, "test-server-cert.pem")), | ||
}; | ||
export const createMockHttpServer = () => { | ||
const server = createHttpServer(); | ||
export var createMockHttpServer = function () { | ||
var server = createHttpServer(); | ||
return server; | ||
}; | ||
export const createMockHttp2Server = () => { | ||
const server = createHttp2Server(); | ||
export var createMockHttp2Server = function () { | ||
var server = createHttp2Server(); | ||
return server; | ||
}; |
@@ -1,15 +0,16 @@ | ||
export const setConnectionTimeout = (request, reject, timeoutInMs = 0) => { | ||
export var setConnectionTimeout = function (request, reject, timeoutInMs) { | ||
if (timeoutInMs === void 0) { timeoutInMs = 0; } | ||
if (!timeoutInMs) { | ||
return; | ||
} | ||
request.on("socket", (socket) => { | ||
request.on("socket", function (socket) { | ||
if (socket.connecting) { | ||
const timeoutId = setTimeout(() => { | ||
var timeoutId_1 = setTimeout(function () { | ||
request.destroy(); | ||
reject(Object.assign(new Error(`Socket timed out without establishing a connection within ${timeoutInMs} ms`), { | ||
reject(Object.assign(new Error("Socket timed out without establishing a connection within ".concat(timeoutInMs, " ms")), { | ||
name: "TimeoutError", | ||
})); | ||
}, timeoutInMs); | ||
socket.on("connect", () => { | ||
clearTimeout(timeoutId); | ||
socket.on("connect", function () { | ||
clearTimeout(timeoutId_1); | ||
}); | ||
@@ -16,0 +17,0 @@ } |
@@ -1,6 +0,7 @@ | ||
export const setSocketTimeout = (request, reject, timeoutInMs = 0) => { | ||
request.setTimeout(timeoutInMs, () => { | ||
export var setSocketTimeout = function (request, reject, timeoutInMs) { | ||
if (timeoutInMs === void 0) { timeoutInMs = 0; } | ||
request.setTimeout(timeoutInMs, function () { | ||
request.destroy(); | ||
reject(Object.assign(new Error(`Connection timed out after ${timeoutInMs} ms`), { name: "TimeoutError" })); | ||
reject(Object.assign(new Error("Connection timed out after ".concat(timeoutInMs, " ms")), { name: "TimeoutError" })); | ||
}); | ||
}; |
@@ -0,11 +1,16 @@ | ||
import { __extends } from "tslib"; | ||
import { Writable } from "stream"; | ||
export class Collector extends Writable { | ||
constructor() { | ||
super(...arguments); | ||
this.bufferedBytes = []; | ||
var Collector = (function (_super) { | ||
__extends(Collector, _super); | ||
function Collector() { | ||
var _this = _super !== null && _super.apply(this, arguments) || this; | ||
_this.bufferedBytes = []; | ||
return _this; | ||
} | ||
_write(chunk, encoding, callback) { | ||
Collector.prototype._write = function (chunk, encoding, callback) { | ||
this.bufferedBytes.push(chunk); | ||
callback(); | ||
} | ||
} | ||
}; | ||
return Collector; | ||
}(Writable)); | ||
export { Collector }; |
import { Collector } from "./collector"; | ||
export const streamCollector = (stream) => new Promise((resolve, reject) => { | ||
const collector = new Collector(); | ||
stream.pipe(collector); | ||
stream.on("error", (err) => { | ||
collector.end(); | ||
reject(err); | ||
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); | ||
}); | ||
}); | ||
collector.on("error", reject); | ||
collector.on("finish", function () { | ||
const bytes = new Uint8Array(Buffer.concat(this.bufferedBytes)); | ||
resolve(bytes); | ||
}); | ||
}); | ||
}; |
@@ -0,10 +1,13 @@ | ||
import { __extends } from "tslib"; | ||
import { Readable } from "stream"; | ||
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; | ||
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; | ||
} | ||
_read(size) { | ||
ReadFromBuffers.prototype._read = function (size) { | ||
if (this.errorAfter !== -1 && this.errorAfter === this.numBuffersRead) { | ||
@@ -18,3 +21,5 @@ this.emit("error", new Error("Mock Error")); | ||
return this.push(this.buffersToRead[this.numBuffersRead++]); | ||
} | ||
} | ||
}; | ||
return ReadFromBuffers; | ||
}(Readable)); | ||
export { ReadFromBuffers }; |
import { Readable } from "stream"; | ||
export function writeRequestBody(httpRequest, request) { | ||
const expect = request.headers["Expect"] || request.headers["expect"]; | ||
var expect = request.headers["Expect"] || request.headers["expect"]; | ||
if (expect === "100-continue") { | ||
httpRequest.on("continue", () => { | ||
httpRequest.on("continue", function () { | ||
writeBody(httpRequest, request.body); | ||
@@ -7,0 +7,0 @@ }); |
{ | ||
"name": "@aws-sdk/node-http-handler", | ||
"version": "3.185.0", | ||
"version": "3.186.0", | ||
"description": "Provides a way to make requests", | ||
@@ -25,6 +25,6 @@ "scripts": { | ||
"dependencies": { | ||
"@aws-sdk/abort-controller": "3.183.0", | ||
"@aws-sdk/protocol-http": "3.183.0", | ||
"@aws-sdk/querystring-builder": "3.183.0", | ||
"@aws-sdk/types": "3.183.0", | ||
"@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", | ||
"tslib": "^2.3.1" | ||
@@ -31,0 +31,0 @@ }, |
License Policy Violation
LicenseThis package is not allowed per your license policy. Review the package's license to ensure compliance.
Found 1 instance in 1 package
License Policy Violation
LicenseThis package is not allowed per your license policy. Review the package's license to ensure compliance.
Found 1 instance in 1 package
120295
1261
+ Added@aws-sdk/abort-controller@3.186.0(transitive)
+ Added@aws-sdk/protocol-http@3.186.0(transitive)
+ Added@aws-sdk/querystring-builder@3.186.0(transitive)
+ Added@aws-sdk/types@3.186.0(transitive)
+ Added@aws-sdk/util-uri-escape@3.186.0(transitive)
- Removed@aws-sdk/abort-controller@3.183.0(transitive)
- Removed@aws-sdk/protocol-http@3.183.0(transitive)
- Removed@aws-sdk/querystring-builder@3.183.0(transitive)
- Removed@aws-sdk/types@3.183.0(transitive)
- Removed@aws-sdk/util-uri-escape@3.183.0(transitive)
Updated@aws-sdk/types@3.186.0