mirror of
https://github.com/tvytlx/ai-agent-deep-dive.git
synced 2026-04-04 16:14:50 +08:00
Add extracted source directory and README navigation
This commit is contained in:
Shawn Bot
732
extracted-source/node_modules/@smithy/node-http-handler/dist-cjs/index.js
generated
vendored
Normal file
732
extracted-source/node_modules/@smithy/node-http-handler/dist-cjs/index.js
generated
vendored
Normal file
@@ -0,0 +1,732 @@
|
||||
'use strict';
|
||||
|
||||
var protocolHttp = require('@smithy/protocol-http');
|
||||
var querystringBuilder = require('@smithy/querystring-builder');
|
||||
var http = require('http');
|
||||
var https = require('https');
|
||||
var stream = require('stream');
|
||||
var http2 = require('http2');
|
||||
|
||||
const NODEJS_TIMEOUT_ERROR_CODES = ["ECONNRESET", "EPIPE", "ETIMEDOUT"];
|
||||
|
||||
const getTransformedHeaders = (headers) => {
|
||||
const transformedHeaders = {};
|
||||
for (const name of Object.keys(headers)) {
|
||||
const headerValues = headers[name];
|
||||
transformedHeaders[name] = Array.isArray(headerValues) ? headerValues.join(",") : headerValues;
|
||||
}
|
||||
return transformedHeaders;
|
||||
};
|
||||
|
||||
const timing = {
|
||||
setTimeout: (cb, ms) => setTimeout(cb, ms),
|
||||
clearTimeout: (timeoutId) => clearTimeout(timeoutId),
|
||||
};
|
||||
|
||||
const DEFER_EVENT_LISTENER_TIME$2 = 1000;
|
||||
const setConnectionTimeout = (request, reject, timeoutInMs = 0) => {
|
||||
if (!timeoutInMs) {
|
||||
return -1;
|
||||
}
|
||||
const registerTimeout = (offset) => {
|
||||
const timeoutId = timing.setTimeout(() => {
|
||||
request.destroy();
|
||||
reject(Object.assign(new Error(`@smithy/node-http-handler - the request socket did not establish a connection with the server within the configured timeout of ${timeoutInMs} ms.`), {
|
||||
name: "TimeoutError",
|
||||
}));
|
||||
}, timeoutInMs - offset);
|
||||
const doWithSocket = (socket) => {
|
||||
if (socket?.connecting) {
|
||||
socket.on("connect", () => {
|
||||
timing.clearTimeout(timeoutId);
|
||||
});
|
||||
}
|
||||
else {
|
||||
timing.clearTimeout(timeoutId);
|
||||
}
|
||||
};
|
||||
if (request.socket) {
|
||||
doWithSocket(request.socket);
|
||||
}
|
||||
else {
|
||||
request.on("socket", doWithSocket);
|
||||
}
|
||||
};
|
||||
if (timeoutInMs < 2000) {
|
||||
registerTimeout(0);
|
||||
return 0;
|
||||
}
|
||||
return timing.setTimeout(registerTimeout.bind(null, DEFER_EVENT_LISTENER_TIME$2), DEFER_EVENT_LISTENER_TIME$2);
|
||||
};
|
||||
|
||||
const setRequestTimeout = (req, reject, timeoutInMs = 0, throwOnRequestTimeout, logger) => {
|
||||
if (timeoutInMs) {
|
||||
return timing.setTimeout(() => {
|
||||
let msg = `@smithy/node-http-handler - [${throwOnRequestTimeout ? "ERROR" : "WARN"}] a request has exceeded the configured ${timeoutInMs} ms requestTimeout.`;
|
||||
if (throwOnRequestTimeout) {
|
||||
const error = Object.assign(new Error(msg), {
|
||||
name: "TimeoutError",
|
||||
code: "ETIMEDOUT",
|
||||
});
|
||||
req.destroy(error);
|
||||
reject(error);
|
||||
}
|
||||
else {
|
||||
msg += ` Init client requestHandler with throwOnRequestTimeout=true to turn this into an error.`;
|
||||
logger?.warn?.(msg);
|
||||
}
|
||||
}, timeoutInMs);
|
||||
}
|
||||
return -1;
|
||||
};
|
||||
|
||||
const DEFER_EVENT_LISTENER_TIME$1 = 3000;
|
||||
const setSocketKeepAlive = (request, { keepAlive, keepAliveMsecs }, deferTimeMs = DEFER_EVENT_LISTENER_TIME$1) => {
|
||||
if (keepAlive !== true) {
|
||||
return -1;
|
||||
}
|
||||
const registerListener = () => {
|
||||
if (request.socket) {
|
||||
request.socket.setKeepAlive(keepAlive, keepAliveMsecs || 0);
|
||||
}
|
||||
else {
|
||||
request.on("socket", (socket) => {
|
||||
socket.setKeepAlive(keepAlive, keepAliveMsecs || 0);
|
||||
});
|
||||
}
|
||||
};
|
||||
if (deferTimeMs === 0) {
|
||||
registerListener();
|
||||
return 0;
|
||||
}
|
||||
return timing.setTimeout(registerListener, deferTimeMs);
|
||||
};
|
||||
|
||||
const DEFER_EVENT_LISTENER_TIME = 3000;
|
||||
const setSocketTimeout = (request, reject, timeoutInMs = 0) => {
|
||||
const registerTimeout = (offset) => {
|
||||
const timeout = timeoutInMs - offset;
|
||||
const onTimeout = () => {
|
||||
request.destroy();
|
||||
reject(Object.assign(new Error(`@smithy/node-http-handler - the request socket timed out after ${timeoutInMs} ms of inactivity (configured by client requestHandler).`), { name: "TimeoutError" }));
|
||||
};
|
||||
if (request.socket) {
|
||||
request.socket.setTimeout(timeout, onTimeout);
|
||||
request.on("close", () => request.socket?.removeListener("timeout", onTimeout));
|
||||
}
|
||||
else {
|
||||
request.setTimeout(timeout, onTimeout);
|
||||
}
|
||||
};
|
||||
if (0 < timeoutInMs && timeoutInMs < 6000) {
|
||||
registerTimeout(0);
|
||||
return 0;
|
||||
}
|
||||
return timing.setTimeout(registerTimeout.bind(null, timeoutInMs === 0 ? 0 : DEFER_EVENT_LISTENER_TIME), DEFER_EVENT_LISTENER_TIME);
|
||||
};
|
||||
|
||||
const MIN_WAIT_TIME = 6_000;
|
||||
async function writeRequestBody(httpRequest, request, maxContinueTimeoutMs = MIN_WAIT_TIME, externalAgent = false) {
|
||||
const headers = request.headers ?? {};
|
||||
const expect = headers.Expect || headers.expect;
|
||||
let timeoutId = -1;
|
||||
let sendBody = true;
|
||||
if (!externalAgent && expect === "100-continue") {
|
||||
sendBody = await Promise.race([
|
||||
new Promise((resolve) => {
|
||||
timeoutId = Number(timing.setTimeout(() => resolve(true), Math.max(MIN_WAIT_TIME, maxContinueTimeoutMs)));
|
||||
}),
|
||||
new Promise((resolve) => {
|
||||
httpRequest.on("continue", () => {
|
||||
timing.clearTimeout(timeoutId);
|
||||
resolve(true);
|
||||
});
|
||||
httpRequest.on("response", () => {
|
||||
timing.clearTimeout(timeoutId);
|
||||
resolve(false);
|
||||
});
|
||||
httpRequest.on("error", () => {
|
||||
timing.clearTimeout(timeoutId);
|
||||
resolve(false);
|
||||
});
|
||||
}),
|
||||
]);
|
||||
}
|
||||
if (sendBody) {
|
||||
writeBody(httpRequest, request.body);
|
||||
}
|
||||
}
|
||||
function writeBody(httpRequest, body) {
|
||||
if (body instanceof stream.Readable) {
|
||||
body.pipe(httpRequest);
|
||||
return;
|
||||
}
|
||||
if (body) {
|
||||
if (Buffer.isBuffer(body) || typeof body === "string") {
|
||||
httpRequest.end(body);
|
||||
return;
|
||||
}
|
||||
const uint8 = body;
|
||||
if (typeof uint8 === "object" &&
|
||||
uint8.buffer &&
|
||||
typeof uint8.byteOffset === "number" &&
|
||||
typeof uint8.byteLength === "number") {
|
||||
httpRequest.end(Buffer.from(uint8.buffer, uint8.byteOffset, uint8.byteLength));
|
||||
return;
|
||||
}
|
||||
httpRequest.end(Buffer.from(body));
|
||||
return;
|
||||
}
|
||||
httpRequest.end();
|
||||
}
|
||||
|
||||
const DEFAULT_REQUEST_TIMEOUT = 0;
|
||||
class NodeHttpHandler {
|
||||
config;
|
||||
configProvider;
|
||||
socketWarningTimestamp = 0;
|
||||
externalAgent = false;
|
||||
metadata = { handlerProtocol: "http/1.1" };
|
||||
static create(instanceOrOptions) {
|
||||
if (typeof instanceOrOptions?.handle === "function") {
|
||||
return instanceOrOptions;
|
||||
}
|
||||
return new NodeHttpHandler(instanceOrOptions);
|
||||
}
|
||||
static checkSocketUsage(agent, socketWarningTimestamp, logger = console) {
|
||||
const { sockets, requests, maxSockets } = agent;
|
||||
if (typeof maxSockets !== "number" || maxSockets === Infinity) {
|
||||
return socketWarningTimestamp;
|
||||
}
|
||||
const interval = 15_000;
|
||||
if (Date.now() - interval < socketWarningTimestamp) {
|
||||
return socketWarningTimestamp;
|
||||
}
|
||||
if (sockets && requests) {
|
||||
for (const origin in sockets) {
|
||||
const socketsInUse = sockets[origin]?.length ?? 0;
|
||||
const requestsEnqueued = requests[origin]?.length ?? 0;
|
||||
if (socketsInUse >= maxSockets && requestsEnqueued >= 2 * maxSockets) {
|
||||
logger?.warn?.(`@smithy/node-http-handler:WARN - socket usage at capacity=${socketsInUse} and ${requestsEnqueued} additional requests are enqueued.
|
||||
See https://docs.aws.amazon.com/sdk-for-javascript/v3/developer-guide/node-configuring-maxsockets.html
|
||||
or increase socketAcquisitionWarningTimeout=(millis) in the NodeHttpHandler config.`);
|
||||
return Date.now();
|
||||
}
|
||||
}
|
||||
}
|
||||
return socketWarningTimestamp;
|
||||
}
|
||||
constructor(options) {
|
||||
this.configProvider = new Promise((resolve, reject) => {
|
||||
if (typeof options === "function") {
|
||||
options()
|
||||
.then((_options) => {
|
||||
resolve(this.resolveDefaultConfig(_options));
|
||||
})
|
||||
.catch(reject);
|
||||
}
|
||||
else {
|
||||
resolve(this.resolveDefaultConfig(options));
|
||||
}
|
||||
});
|
||||
}
|
||||
resolveDefaultConfig(options) {
|
||||
const { requestTimeout, connectionTimeout, socketTimeout, socketAcquisitionWarningTimeout, httpAgent, httpsAgent, throwOnRequestTimeout, } = options || {};
|
||||
const keepAlive = true;
|
||||
const maxSockets = 50;
|
||||
return {
|
||||
connectionTimeout,
|
||||
requestTimeout,
|
||||
socketTimeout,
|
||||
socketAcquisitionWarningTimeout,
|
||||
throwOnRequestTimeout,
|
||||
httpAgent: (() => {
|
||||
if (httpAgent instanceof http.Agent || typeof httpAgent?.destroy === "function") {
|
||||
this.externalAgent = true;
|
||||
return httpAgent;
|
||||
}
|
||||
return new http.Agent({ keepAlive, maxSockets, ...httpAgent });
|
||||
})(),
|
||||
httpsAgent: (() => {
|
||||
if (httpsAgent instanceof https.Agent || typeof httpsAgent?.destroy === "function") {
|
||||
this.externalAgent = true;
|
||||
return httpsAgent;
|
||||
}
|
||||
return new https.Agent({ keepAlive, maxSockets, ...httpsAgent });
|
||||
})(),
|
||||
logger: console,
|
||||
};
|
||||
}
|
||||
destroy() {
|
||||
this.config?.httpAgent?.destroy();
|
||||
this.config?.httpsAgent?.destroy();
|
||||
}
|
||||
async handle(request, { abortSignal, requestTimeout } = {}) {
|
||||
if (!this.config) {
|
||||
this.config = await this.configProvider;
|
||||
}
|
||||
return new Promise((_resolve, _reject) => {
|
||||
const config = this.config;
|
||||
let writeRequestBodyPromise = undefined;
|
||||
const timeouts = [];
|
||||
const resolve = async (arg) => {
|
||||
await writeRequestBodyPromise;
|
||||
timeouts.forEach(timing.clearTimeout);
|
||||
_resolve(arg);
|
||||
};
|
||||
const reject = async (arg) => {
|
||||
await writeRequestBodyPromise;
|
||||
timeouts.forEach(timing.clearTimeout);
|
||||
_reject(arg);
|
||||
};
|
||||
if (abortSignal?.aborted) {
|
||||
const abortError = new Error("Request aborted");
|
||||
abortError.name = "AbortError";
|
||||
reject(abortError);
|
||||
return;
|
||||
}
|
||||
const isSSL = request.protocol === "https:";
|
||||
const headers = request.headers ?? {};
|
||||
const expectContinue = (headers.Expect ?? headers.expect) === "100-continue";
|
||||
let agent = isSSL ? config.httpsAgent : config.httpAgent;
|
||||
if (expectContinue && !this.externalAgent) {
|
||||
agent = new (isSSL ? https.Agent : http.Agent)({
|
||||
keepAlive: false,
|
||||
maxSockets: Infinity,
|
||||
});
|
||||
}
|
||||
timeouts.push(timing.setTimeout(() => {
|
||||
this.socketWarningTimestamp = NodeHttpHandler.checkSocketUsage(agent, this.socketWarningTimestamp, config.logger);
|
||||
}, config.socketAcquisitionWarningTimeout ?? (config.requestTimeout ?? 2000) + (config.connectionTimeout ?? 1000)));
|
||||
const queryString = querystringBuilder.buildQueryString(request.query || {});
|
||||
let auth = undefined;
|
||||
if (request.username != null || request.password != null) {
|
||||
const username = request.username ?? "";
|
||||
const password = request.password ?? "";
|
||||
auth = `${username}:${password}`;
|
||||
}
|
||||
let path = request.path;
|
||||
if (queryString) {
|
||||
path += `?${queryString}`;
|
||||
}
|
||||
if (request.fragment) {
|
||||
path += `#${request.fragment}`;
|
||||
}
|
||||
let hostname = request.hostname ?? "";
|
||||
if (hostname[0] === "[" && hostname.endsWith("]")) {
|
||||
hostname = request.hostname.slice(1, -1);
|
||||
}
|
||||
else {
|
||||
hostname = request.hostname;
|
||||
}
|
||||
const nodeHttpsOptions = {
|
||||
headers: request.headers,
|
||||
host: hostname,
|
||||
method: request.method,
|
||||
path,
|
||||
port: request.port,
|
||||
agent,
|
||||
auth,
|
||||
};
|
||||
const requestFunc = isSSL ? https.request : http.request;
|
||||
const req = requestFunc(nodeHttpsOptions, (res) => {
|
||||
const httpResponse = new protocolHttp.HttpResponse({
|
||||
statusCode: res.statusCode || -1,
|
||||
reason: res.statusMessage,
|
||||
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);
|
||||
}
|
||||
});
|
||||
if (abortSignal) {
|
||||
const onAbort = () => {
|
||||
req.destroy();
|
||||
const abortError = new Error("Request aborted");
|
||||
abortError.name = "AbortError";
|
||||
reject(abortError);
|
||||
};
|
||||
if (typeof abortSignal.addEventListener === "function") {
|
||||
const signal = abortSignal;
|
||||
signal.addEventListener("abort", onAbort, { once: true });
|
||||
req.once("close", () => signal.removeEventListener("abort", onAbort));
|
||||
}
|
||||
else {
|
||||
abortSignal.onabort = onAbort;
|
||||
}
|
||||
}
|
||||
const effectiveRequestTimeout = requestTimeout ?? config.requestTimeout;
|
||||
timeouts.push(setConnectionTimeout(req, reject, config.connectionTimeout));
|
||||
timeouts.push(setRequestTimeout(req, reject, effectiveRequestTimeout, config.throwOnRequestTimeout, config.logger ?? console));
|
||||
timeouts.push(setSocketTimeout(req, reject, config.socketTimeout));
|
||||
const httpAgent = nodeHttpsOptions.agent;
|
||||
if (typeof httpAgent === "object" && "keepAlive" in httpAgent) {
|
||||
timeouts.push(setSocketKeepAlive(req, {
|
||||
keepAlive: httpAgent.keepAlive,
|
||||
keepAliveMsecs: httpAgent.keepAliveMsecs,
|
||||
}));
|
||||
}
|
||||
writeRequestBodyPromise = writeRequestBody(req, request, effectiveRequestTimeout, this.externalAgent).catch((e) => {
|
||||
timeouts.forEach(timing.clearTimeout);
|
||||
return _reject(e);
|
||||
});
|
||||
});
|
||||
}
|
||||
updateHttpClientConfig(key, value) {
|
||||
this.config = undefined;
|
||||
this.configProvider = this.configProvider.then((config) => {
|
||||
return {
|
||||
...config,
|
||||
[key]: value,
|
||||
};
|
||||
});
|
||||
}
|
||||
httpHandlerConfigs() {
|
||||
return this.config ?? {};
|
||||
}
|
||||
}
|
||||
|
||||
class NodeHttp2ConnectionPool {
|
||||
sessions = [];
|
||||
constructor(sessions) {
|
||||
this.sessions = sessions ?? [];
|
||||
}
|
||||
poll() {
|
||||
if (this.sessions.length > 0) {
|
||||
return this.sessions.shift();
|
||||
}
|
||||
}
|
||||
offerLast(session) {
|
||||
this.sessions.push(session);
|
||||
}
|
||||
contains(session) {
|
||||
return this.sessions.includes(session);
|
||||
}
|
||||
remove(session) {
|
||||
this.sessions = this.sessions.filter((s) => s !== session);
|
||||
}
|
||||
[Symbol.iterator]() {
|
||||
return this.sessions[Symbol.iterator]();
|
||||
}
|
||||
destroy(connection) {
|
||||
for (const session of this.sessions) {
|
||||
if (session === connection) {
|
||||
if (!session.destroyed) {
|
||||
session.destroy();
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
class NodeHttp2ConnectionManager {
|
||||
constructor(config) {
|
||||
this.config = config;
|
||||
if (this.config.maxConcurrency && this.config.maxConcurrency <= 0) {
|
||||
throw new RangeError("maxConcurrency must be greater than zero.");
|
||||
}
|
||||
}
|
||||
config;
|
||||
sessionCache = new Map();
|
||||
lease(requestContext, connectionConfiguration) {
|
||||
const url = this.getUrlString(requestContext);
|
||||
const existingPool = this.sessionCache.get(url);
|
||||
if (existingPool) {
|
||||
const existingSession = existingPool.poll();
|
||||
if (existingSession && !this.config.disableConcurrency) {
|
||||
return existingSession;
|
||||
}
|
||||
}
|
||||
const session = http2.connect(url);
|
||||
if (this.config.maxConcurrency) {
|
||||
session.settings({ maxConcurrentStreams: this.config.maxConcurrency }, (err) => {
|
||||
if (err) {
|
||||
throw new Error("Fail to set maxConcurrentStreams to " +
|
||||
this.config.maxConcurrency +
|
||||
"when creating new session for " +
|
||||
requestContext.destination.toString());
|
||||
}
|
||||
});
|
||||
}
|
||||
session.unref();
|
||||
const destroySessionCb = () => {
|
||||
session.destroy();
|
||||
this.deleteSession(url, session);
|
||||
};
|
||||
session.on("goaway", destroySessionCb);
|
||||
session.on("error", destroySessionCb);
|
||||
session.on("frameError", destroySessionCb);
|
||||
session.on("close", () => this.deleteSession(url, session));
|
||||
if (connectionConfiguration.requestTimeout) {
|
||||
session.setTimeout(connectionConfiguration.requestTimeout, destroySessionCb);
|
||||
}
|
||||
const connectionPool = this.sessionCache.get(url) || new NodeHttp2ConnectionPool();
|
||||
connectionPool.offerLast(session);
|
||||
this.sessionCache.set(url, connectionPool);
|
||||
return session;
|
||||
}
|
||||
deleteSession(authority, session) {
|
||||
const existingConnectionPool = this.sessionCache.get(authority);
|
||||
if (!existingConnectionPool) {
|
||||
return;
|
||||
}
|
||||
if (!existingConnectionPool.contains(session)) {
|
||||
return;
|
||||
}
|
||||
existingConnectionPool.remove(session);
|
||||
this.sessionCache.set(authority, existingConnectionPool);
|
||||
}
|
||||
release(requestContext, session) {
|
||||
const cacheKey = this.getUrlString(requestContext);
|
||||
this.sessionCache.get(cacheKey)?.offerLast(session);
|
||||
}
|
||||
destroy() {
|
||||
for (const [key, connectionPool] of this.sessionCache) {
|
||||
for (const session of connectionPool) {
|
||||
if (!session.destroyed) {
|
||||
session.destroy();
|
||||
}
|
||||
connectionPool.remove(session);
|
||||
}
|
||||
this.sessionCache.delete(key);
|
||||
}
|
||||
}
|
||||
setMaxConcurrentStreams(maxConcurrentStreams) {
|
||||
if (maxConcurrentStreams && maxConcurrentStreams <= 0) {
|
||||
throw new RangeError("maxConcurrentStreams must be greater than zero.");
|
||||
}
|
||||
this.config.maxConcurrency = maxConcurrentStreams;
|
||||
}
|
||||
setDisableConcurrentStreams(disableConcurrentStreams) {
|
||||
this.config.disableConcurrency = disableConcurrentStreams;
|
||||
}
|
||||
getUrlString(request) {
|
||||
return request.destination.toString();
|
||||
}
|
||||
}
|
||||
|
||||
class NodeHttp2Handler {
|
||||
config;
|
||||
configProvider;
|
||||
metadata = { handlerProtocol: "h2" };
|
||||
connectionManager = new NodeHttp2ConnectionManager({});
|
||||
static create(instanceOrOptions) {
|
||||
if (typeof instanceOrOptions?.handle === "function") {
|
||||
return instanceOrOptions;
|
||||
}
|
||||
return new NodeHttp2Handler(instanceOrOptions);
|
||||
}
|
||||
constructor(options) {
|
||||
this.configProvider = new Promise((resolve, reject) => {
|
||||
if (typeof options === "function") {
|
||||
options()
|
||||
.then((opts) => {
|
||||
resolve(opts || {});
|
||||
})
|
||||
.catch(reject);
|
||||
}
|
||||
else {
|
||||
resolve(options || {});
|
||||
}
|
||||
});
|
||||
}
|
||||
destroy() {
|
||||
this.connectionManager.destroy();
|
||||
}
|
||||
async handle(request, { abortSignal, requestTimeout } = {}) {
|
||||
if (!this.config) {
|
||||
this.config = await this.configProvider;
|
||||
this.connectionManager.setDisableConcurrentStreams(this.config.disableConcurrentStreams || false);
|
||||
if (this.config.maxConcurrentStreams) {
|
||||
this.connectionManager.setMaxConcurrentStreams(this.config.maxConcurrentStreams);
|
||||
}
|
||||
}
|
||||
const { requestTimeout: configRequestTimeout, disableConcurrentStreams } = this.config;
|
||||
const effectiveRequestTimeout = requestTimeout ?? configRequestTimeout;
|
||||
return new Promise((_resolve, _reject) => {
|
||||
let fulfilled = false;
|
||||
let writeRequestBodyPromise = undefined;
|
||||
const resolve = async (arg) => {
|
||||
await writeRequestBodyPromise;
|
||||
_resolve(arg);
|
||||
};
|
||||
const reject = async (arg) => {
|
||||
await writeRequestBodyPromise;
|
||||
_reject(arg);
|
||||
};
|
||||
if (abortSignal?.aborted) {
|
||||
fulfilled = true;
|
||||
const abortError = new Error("Request aborted");
|
||||
abortError.name = "AbortError";
|
||||
reject(abortError);
|
||||
return;
|
||||
}
|
||||
const { hostname, method, port, protocol, query } = request;
|
||||
let auth = "";
|
||||
if (request.username != null || request.password != null) {
|
||||
const username = request.username ?? "";
|
||||
const password = request.password ?? "";
|
||||
auth = `${username}:${password}@`;
|
||||
}
|
||||
const authority = `${protocol}//${auth}${hostname}${port ? `:${port}` : ""}`;
|
||||
const requestContext = { destination: new URL(authority) };
|
||||
const session = this.connectionManager.lease(requestContext, {
|
||||
requestTimeout: this.config?.sessionTimeout,
|
||||
disableConcurrentStreams: disableConcurrentStreams || false,
|
||||
});
|
||||
const rejectWithDestroy = (err) => {
|
||||
if (disableConcurrentStreams) {
|
||||
this.destroySession(session);
|
||||
}
|
||||
fulfilled = true;
|
||||
reject(err);
|
||||
};
|
||||
const queryString = querystringBuilder.buildQueryString(query || {});
|
||||
let path = request.path;
|
||||
if (queryString) {
|
||||
path += `?${queryString}`;
|
||||
}
|
||||
if (request.fragment) {
|
||||
path += `#${request.fragment}`;
|
||||
}
|
||||
const req = session.request({
|
||||
...request.headers,
|
||||
[http2.constants.HTTP2_HEADER_PATH]: path,
|
||||
[http2.constants.HTTP2_HEADER_METHOD]: method,
|
||||
});
|
||||
session.ref();
|
||||
req.on("response", (headers) => {
|
||||
const httpResponse = new protocolHttp.HttpResponse({
|
||||
statusCode: headers[":status"] || -1,
|
||||
headers: getTransformedHeaders(headers),
|
||||
body: req,
|
||||
});
|
||||
fulfilled = true;
|
||||
resolve({ response: httpResponse });
|
||||
if (disableConcurrentStreams) {
|
||||
session.close();
|
||||
this.connectionManager.deleteSession(authority, session);
|
||||
}
|
||||
});
|
||||
if (effectiveRequestTimeout) {
|
||||
req.setTimeout(effectiveRequestTimeout, () => {
|
||||
req.close();
|
||||
const timeoutError = new Error(`Stream timed out because of no activity for ${effectiveRequestTimeout} ms`);
|
||||
timeoutError.name = "TimeoutError";
|
||||
rejectWithDestroy(timeoutError);
|
||||
});
|
||||
}
|
||||
if (abortSignal) {
|
||||
const onAbort = () => {
|
||||
req.close();
|
||||
const abortError = new Error("Request aborted");
|
||||
abortError.name = "AbortError";
|
||||
rejectWithDestroy(abortError);
|
||||
};
|
||||
if (typeof abortSignal.addEventListener === "function") {
|
||||
const signal = abortSignal;
|
||||
signal.addEventListener("abort", onAbort, { once: true });
|
||||
req.once("close", () => signal.removeEventListener("abort", onAbort));
|
||||
}
|
||||
else {
|
||||
abortSignal.onabort = onAbort;
|
||||
}
|
||||
}
|
||||
req.on("frameError", (type, code, id) => {
|
||||
rejectWithDestroy(new Error(`Frame type id ${type} in stream id ${id} has failed with code ${code}.`));
|
||||
});
|
||||
req.on("error", rejectWithDestroy);
|
||||
req.on("aborted", () => {
|
||||
rejectWithDestroy(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) {
|
||||
rejectWithDestroy(new Error("Unexpected error: http2 request did not get a response"));
|
||||
}
|
||||
});
|
||||
writeRequestBodyPromise = writeRequestBody(req, request, effectiveRequestTimeout);
|
||||
});
|
||||
}
|
||||
updateHttpClientConfig(key, value) {
|
||||
this.config = undefined;
|
||||
this.configProvider = this.configProvider.then((config) => {
|
||||
return {
|
||||
...config,
|
||||
[key]: value,
|
||||
};
|
||||
});
|
||||
}
|
||||
httpHandlerConfigs() {
|
||||
return this.config ?? {};
|
||||
}
|
||||
destroySession(session) {
|
||||
if (!session.destroyed) {
|
||||
session.destroy();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
class Collector extends stream.Writable {
|
||||
bufferedBytes = [];
|
||||
_write(chunk, encoding, callback) {
|
||||
this.bufferedBytes.push(chunk);
|
||||
callback();
|
||||
}
|
||||
}
|
||||
|
||||
const streamCollector = (stream) => {
|
||||
if (isReadableStreamInstance(stream)) {
|
||||
return collectReadableStream(stream);
|
||||
}
|
||||
return 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);
|
||||
});
|
||||
});
|
||||
};
|
||||
const isReadableStreamInstance = (stream) => typeof ReadableStream === "function" && stream instanceof ReadableStream;
|
||||
async function collectReadableStream(stream) {
|
||||
const chunks = [];
|
||||
const reader = stream.getReader();
|
||||
let isDone = false;
|
||||
let length = 0;
|
||||
while (!isDone) {
|
||||
const { done, value } = await reader.read();
|
||||
if (value) {
|
||||
chunks.push(value);
|
||||
length += value.length;
|
||||
}
|
||||
isDone = done;
|
||||
}
|
||||
const collected = new Uint8Array(length);
|
||||
let offset = 0;
|
||||
for (const chunk of chunks) {
|
||||
collected.set(chunk, offset);
|
||||
offset += chunk.length;
|
||||
}
|
||||
return collected;
|
||||
}
|
||||
|
||||
exports.DEFAULT_REQUEST_TIMEOUT = DEFAULT_REQUEST_TIMEOUT;
|
||||
exports.NodeHttp2Handler = NodeHttp2Handler;
|
||||
exports.NodeHttpHandler = NodeHttpHandler;
|
||||
exports.streamCollector = streamCollector;
|
||||
169
extracted-source/node_modules/@smithy/node-http-handler/node_modules/@smithy/protocol-http/dist-cjs/index.js
generated
vendored
Normal file
169
extracted-source/node_modules/@smithy/node-http-handler/node_modules/@smithy/protocol-http/dist-cjs/index.js
generated
vendored
Normal file
@@ -0,0 +1,169 @@
|
||||
'use strict';
|
||||
|
||||
var types = require('@smithy/types');
|
||||
|
||||
const getHttpHandlerExtensionConfiguration = (runtimeConfig) => {
|
||||
return {
|
||||
setHttpHandler(handler) {
|
||||
runtimeConfig.httpHandler = handler;
|
||||
},
|
||||
httpHandler() {
|
||||
return runtimeConfig.httpHandler;
|
||||
},
|
||||
updateHttpClientConfig(key, value) {
|
||||
runtimeConfig.httpHandler?.updateHttpClientConfig(key, value);
|
||||
},
|
||||
httpHandlerConfigs() {
|
||||
return runtimeConfig.httpHandler.httpHandlerConfigs();
|
||||
},
|
||||
};
|
||||
};
|
||||
const resolveHttpHandlerRuntimeConfig = (httpHandlerExtensionConfiguration) => {
|
||||
return {
|
||||
httpHandler: httpHandlerExtensionConfiguration.httpHandler(),
|
||||
};
|
||||
};
|
||||
|
||||
class Field {
|
||||
name;
|
||||
kind;
|
||||
values;
|
||||
constructor({ name, kind = types.FieldPosition.HEADER, values = [] }) {
|
||||
this.name = name;
|
||||
this.kind = kind;
|
||||
this.values = values;
|
||||
}
|
||||
add(value) {
|
||||
this.values.push(value);
|
||||
}
|
||||
set(values) {
|
||||
this.values = values;
|
||||
}
|
||||
remove(value) {
|
||||
this.values = this.values.filter((v) => v !== value);
|
||||
}
|
||||
toString() {
|
||||
return this.values.map((v) => (v.includes(",") || v.includes(" ") ? `"${v}"` : v)).join(", ");
|
||||
}
|
||||
get() {
|
||||
return this.values;
|
||||
}
|
||||
}
|
||||
|
||||
class Fields {
|
||||
entries = {};
|
||||
encoding;
|
||||
constructor({ fields = [], encoding = "utf-8" }) {
|
||||
fields.forEach(this.setField.bind(this));
|
||||
this.encoding = encoding;
|
||||
}
|
||||
setField(field) {
|
||||
this.entries[field.name.toLowerCase()] = field;
|
||||
}
|
||||
getField(name) {
|
||||
return this.entries[name.toLowerCase()];
|
||||
}
|
||||
removeField(name) {
|
||||
delete this.entries[name.toLowerCase()];
|
||||
}
|
||||
getByType(kind) {
|
||||
return Object.values(this.entries).filter((field) => field.kind === kind);
|
||||
}
|
||||
}
|
||||
|
||||
class HttpRequest {
|
||||
method;
|
||||
protocol;
|
||||
hostname;
|
||||
port;
|
||||
path;
|
||||
query;
|
||||
headers;
|
||||
username;
|
||||
password;
|
||||
fragment;
|
||||
body;
|
||||
constructor(options) {
|
||||
this.method = options.method || "GET";
|
||||
this.hostname = options.hostname || "localhost";
|
||||
this.port = options.port;
|
||||
this.query = options.query || {};
|
||||
this.headers = options.headers || {};
|
||||
this.body = options.body;
|
||||
this.protocol = options.protocol
|
||||
? options.protocol.slice(-1) !== ":"
|
||||
? `${options.protocol}:`
|
||||
: options.protocol
|
||||
: "https:";
|
||||
this.path = options.path ? (options.path.charAt(0) !== "/" ? `/${options.path}` : options.path) : "/";
|
||||
this.username = options.username;
|
||||
this.password = options.password;
|
||||
this.fragment = options.fragment;
|
||||
}
|
||||
static clone(request) {
|
||||
const cloned = new HttpRequest({
|
||||
...request,
|
||||
headers: { ...request.headers },
|
||||
});
|
||||
if (cloned.query) {
|
||||
cloned.query = cloneQuery(cloned.query);
|
||||
}
|
||||
return cloned;
|
||||
}
|
||||
static isInstance(request) {
|
||||
if (!request) {
|
||||
return false;
|
||||
}
|
||||
const req = request;
|
||||
return ("method" in req &&
|
||||
"protocol" in req &&
|
||||
"hostname" in req &&
|
||||
"path" in req &&
|
||||
typeof req["query"] === "object" &&
|
||||
typeof req["headers"] === "object");
|
||||
}
|
||||
clone() {
|
||||
return HttpRequest.clone(this);
|
||||
}
|
||||
}
|
||||
function cloneQuery(query) {
|
||||
return Object.keys(query).reduce((carry, paramName) => {
|
||||
const param = query[paramName];
|
||||
return {
|
||||
...carry,
|
||||
[paramName]: Array.isArray(param) ? [...param] : param,
|
||||
};
|
||||
}, {});
|
||||
}
|
||||
|
||||
class HttpResponse {
|
||||
statusCode;
|
||||
reason;
|
||||
headers;
|
||||
body;
|
||||
constructor(options) {
|
||||
this.statusCode = options.statusCode;
|
||||
this.reason = options.reason;
|
||||
this.headers = options.headers || {};
|
||||
this.body = options.body;
|
||||
}
|
||||
static isInstance(response) {
|
||||
if (!response)
|
||||
return false;
|
||||
const resp = response;
|
||||
return typeof resp.statusCode === "number" && typeof resp.headers === "object";
|
||||
}
|
||||
}
|
||||
|
||||
function isValidHostname(hostname) {
|
||||
const hostPattern = /^[a-z0-9][a-z0-9\.\-]*[a-z0-9]$/;
|
||||
return hostPattern.test(hostname);
|
||||
}
|
||||
|
||||
exports.Field = Field;
|
||||
exports.Fields = Fields;
|
||||
exports.HttpRequest = HttpRequest;
|
||||
exports.HttpResponse = HttpResponse;
|
||||
exports.getHttpHandlerExtensionConfiguration = getHttpHandlerExtensionConfiguration;
|
||||
exports.isValidHostname = isValidHostname;
|
||||
exports.resolveHttpHandlerRuntimeConfig = resolveHttpHandlerRuntimeConfig;
|
||||
26
extracted-source/node_modules/@smithy/node-http-handler/node_modules/@smithy/querystring-builder/dist-cjs/index.js
generated
vendored
Normal file
26
extracted-source/node_modules/@smithy/node-http-handler/node_modules/@smithy/querystring-builder/dist-cjs/index.js
generated
vendored
Normal file
@@ -0,0 +1,26 @@
|
||||
'use strict';
|
||||
|
||||
var utilUriEscape = require('@smithy/util-uri-escape');
|
||||
|
||||
function buildQueryString(query) {
|
||||
const parts = [];
|
||||
for (let key of Object.keys(query).sort()) {
|
||||
const value = query[key];
|
||||
key = utilUriEscape.escapeUri(key);
|
||||
if (Array.isArray(value)) {
|
||||
for (let i = 0, iLen = value.length; i < iLen; i++) {
|
||||
parts.push(`${key}=${utilUriEscape.escapeUri(value[i])}`);
|
||||
}
|
||||
}
|
||||
else {
|
||||
let qsEntry = key;
|
||||
if (value || typeof value === "string") {
|
||||
qsEntry += `=${utilUriEscape.escapeUri(value)}`;
|
||||
}
|
||||
parts.push(qsEntry);
|
||||
}
|
||||
}
|
||||
return parts.join("&");
|
||||
}
|
||||
|
||||
exports.buildQueryString = buildQueryString;
|
||||
@@ -0,0 +1,9 @@
|
||||
'use strict';
|
||||
|
||||
const escapeUri = (uri) => encodeURIComponent(uri).replace(/[!'()*]/g, hexEncode);
|
||||
const hexEncode = (c) => `%${c.charCodeAt(0).toString(16).toUpperCase()}`;
|
||||
|
||||
const escapeUriPath = (uri) => uri.split("/").map(escapeUri).join("/");
|
||||
|
||||
exports.escapeUri = escapeUri;
|
||||
exports.escapeUriPath = escapeUriPath;
|
||||
91
extracted-source/node_modules/@smithy/node-http-handler/node_modules/@smithy/types/dist-cjs/index.js
generated
vendored
Normal file
91
extracted-source/node_modules/@smithy/node-http-handler/node_modules/@smithy/types/dist-cjs/index.js
generated
vendored
Normal file
@@ -0,0 +1,91 @@
|
||||
'use strict';
|
||||
|
||||
exports.HttpAuthLocation = void 0;
|
||||
(function (HttpAuthLocation) {
|
||||
HttpAuthLocation["HEADER"] = "header";
|
||||
HttpAuthLocation["QUERY"] = "query";
|
||||
})(exports.HttpAuthLocation || (exports.HttpAuthLocation = {}));
|
||||
|
||||
exports.HttpApiKeyAuthLocation = void 0;
|
||||
(function (HttpApiKeyAuthLocation) {
|
||||
HttpApiKeyAuthLocation["HEADER"] = "header";
|
||||
HttpApiKeyAuthLocation["QUERY"] = "query";
|
||||
})(exports.HttpApiKeyAuthLocation || (exports.HttpApiKeyAuthLocation = {}));
|
||||
|
||||
exports.EndpointURLScheme = void 0;
|
||||
(function (EndpointURLScheme) {
|
||||
EndpointURLScheme["HTTP"] = "http";
|
||||
EndpointURLScheme["HTTPS"] = "https";
|
||||
})(exports.EndpointURLScheme || (exports.EndpointURLScheme = {}));
|
||||
|
||||
exports.AlgorithmId = void 0;
|
||||
(function (AlgorithmId) {
|
||||
AlgorithmId["MD5"] = "md5";
|
||||
AlgorithmId["CRC32"] = "crc32";
|
||||
AlgorithmId["CRC32C"] = "crc32c";
|
||||
AlgorithmId["SHA1"] = "sha1";
|
||||
AlgorithmId["SHA256"] = "sha256";
|
||||
})(exports.AlgorithmId || (exports.AlgorithmId = {}));
|
||||
const getChecksumConfiguration = (runtimeConfig) => {
|
||||
const checksumAlgorithms = [];
|
||||
if (runtimeConfig.sha256 !== undefined) {
|
||||
checksumAlgorithms.push({
|
||||
algorithmId: () => exports.AlgorithmId.SHA256,
|
||||
checksumConstructor: () => runtimeConfig.sha256,
|
||||
});
|
||||
}
|
||||
if (runtimeConfig.md5 != undefined) {
|
||||
checksumAlgorithms.push({
|
||||
algorithmId: () => exports.AlgorithmId.MD5,
|
||||
checksumConstructor: () => runtimeConfig.md5,
|
||||
});
|
||||
}
|
||||
return {
|
||||
addChecksumAlgorithm(algo) {
|
||||
checksumAlgorithms.push(algo);
|
||||
},
|
||||
checksumAlgorithms() {
|
||||
return checksumAlgorithms;
|
||||
},
|
||||
};
|
||||
};
|
||||
const resolveChecksumRuntimeConfig = (clientConfig) => {
|
||||
const runtimeConfig = {};
|
||||
clientConfig.checksumAlgorithms().forEach((checksumAlgorithm) => {
|
||||
runtimeConfig[checksumAlgorithm.algorithmId()] = checksumAlgorithm.checksumConstructor();
|
||||
});
|
||||
return runtimeConfig;
|
||||
};
|
||||
|
||||
const getDefaultClientConfiguration = (runtimeConfig) => {
|
||||
return getChecksumConfiguration(runtimeConfig);
|
||||
};
|
||||
const resolveDefaultRuntimeConfig = (config) => {
|
||||
return resolveChecksumRuntimeConfig(config);
|
||||
};
|
||||
|
||||
exports.FieldPosition = void 0;
|
||||
(function (FieldPosition) {
|
||||
FieldPosition[FieldPosition["HEADER"] = 0] = "HEADER";
|
||||
FieldPosition[FieldPosition["TRAILER"] = 1] = "TRAILER";
|
||||
})(exports.FieldPosition || (exports.FieldPosition = {}));
|
||||
|
||||
const SMITHY_CONTEXT_KEY = "__smithy_context";
|
||||
|
||||
exports.IniSectionType = void 0;
|
||||
(function (IniSectionType) {
|
||||
IniSectionType["PROFILE"] = "profile";
|
||||
IniSectionType["SSO_SESSION"] = "sso-session";
|
||||
IniSectionType["SERVICES"] = "services";
|
||||
})(exports.IniSectionType || (exports.IniSectionType = {}));
|
||||
|
||||
exports.RequestHandlerProtocol = void 0;
|
||||
(function (RequestHandlerProtocol) {
|
||||
RequestHandlerProtocol["HTTP_0_9"] = "http/0.9";
|
||||
RequestHandlerProtocol["HTTP_1_0"] = "http/1.0";
|
||||
RequestHandlerProtocol["TDS_8_0"] = "tds/8.0";
|
||||
})(exports.RequestHandlerProtocol || (exports.RequestHandlerProtocol = {}));
|
||||
|
||||
exports.SMITHY_CONTEXT_KEY = SMITHY_CONTEXT_KEY;
|
||||
exports.getDefaultClientConfiguration = getDefaultClientConfiguration;
|
||||
exports.resolveDefaultRuntimeConfig = resolveDefaultRuntimeConfig;
|
||||
Reference in New Issue
Block a user