mirror of
https://github.com/tvytlx/ai-agent-deep-dive.git
synced 2026-04-05 00:24:50 +08:00
Add extracted source directory and README navigation
This commit is contained in:
Shawn Bot
358
extracted-source/node_modules/@smithy/middleware-retry/dist-cjs/index.js
generated
vendored
Normal file
358
extracted-source/node_modules/@smithy/middleware-retry/dist-cjs/index.js
generated
vendored
Normal file
@@ -0,0 +1,358 @@
|
||||
'use strict';
|
||||
|
||||
var utilRetry = require('@smithy/util-retry');
|
||||
var protocolHttp = require('@smithy/protocol-http');
|
||||
var serviceErrorClassification = require('@smithy/service-error-classification');
|
||||
var uuid = require('@smithy/uuid');
|
||||
var utilMiddleware = require('@smithy/util-middleware');
|
||||
var smithyClient = require('@smithy/smithy-client');
|
||||
var isStreamingPayload = require('./isStreamingPayload/isStreamingPayload');
|
||||
|
||||
const getDefaultRetryQuota = (initialRetryTokens, options) => {
|
||||
const MAX_CAPACITY = initialRetryTokens;
|
||||
const noRetryIncrement = utilRetry.NO_RETRY_INCREMENT;
|
||||
const retryCost = utilRetry.RETRY_COST;
|
||||
const timeoutRetryCost = utilRetry.TIMEOUT_RETRY_COST;
|
||||
let availableCapacity = initialRetryTokens;
|
||||
const getCapacityAmount = (error) => (error.name === "TimeoutError" ? timeoutRetryCost : retryCost);
|
||||
const hasRetryTokens = (error) => getCapacityAmount(error) <= availableCapacity;
|
||||
const retrieveRetryTokens = (error) => {
|
||||
if (!hasRetryTokens(error)) {
|
||||
throw new Error("No retry token available");
|
||||
}
|
||||
const capacityAmount = getCapacityAmount(error);
|
||||
availableCapacity -= capacityAmount;
|
||||
return capacityAmount;
|
||||
};
|
||||
const releaseRetryTokens = (capacityReleaseAmount) => {
|
||||
availableCapacity += capacityReleaseAmount ?? noRetryIncrement;
|
||||
availableCapacity = Math.min(availableCapacity, MAX_CAPACITY);
|
||||
};
|
||||
return Object.freeze({
|
||||
hasRetryTokens,
|
||||
retrieveRetryTokens,
|
||||
releaseRetryTokens,
|
||||
});
|
||||
};
|
||||
|
||||
const defaultDelayDecider = (delayBase, attempts) => Math.floor(Math.min(utilRetry.MAXIMUM_RETRY_DELAY, Math.random() * 2 ** attempts * delayBase));
|
||||
|
||||
const defaultRetryDecider = (error) => {
|
||||
if (!error) {
|
||||
return false;
|
||||
}
|
||||
return serviceErrorClassification.isRetryableByTrait(error) || serviceErrorClassification.isClockSkewError(error) || serviceErrorClassification.isThrottlingError(error) || serviceErrorClassification.isTransientError(error);
|
||||
};
|
||||
|
||||
const asSdkError = (error) => {
|
||||
if (error instanceof Error)
|
||||
return error;
|
||||
if (error instanceof Object)
|
||||
return Object.assign(new Error(), error);
|
||||
if (typeof error === "string")
|
||||
return new Error(error);
|
||||
return new Error(`AWS SDK error wrapper for ${error}`);
|
||||
};
|
||||
|
||||
class StandardRetryStrategy {
|
||||
maxAttemptsProvider;
|
||||
retryDecider;
|
||||
delayDecider;
|
||||
retryQuota;
|
||||
mode = utilRetry.RETRY_MODES.STANDARD;
|
||||
constructor(maxAttemptsProvider, options) {
|
||||
this.maxAttemptsProvider = maxAttemptsProvider;
|
||||
this.retryDecider = options?.retryDecider ?? defaultRetryDecider;
|
||||
this.delayDecider = options?.delayDecider ?? defaultDelayDecider;
|
||||
this.retryQuota = options?.retryQuota ?? getDefaultRetryQuota(utilRetry.INITIAL_RETRY_TOKENS);
|
||||
}
|
||||
shouldRetry(error, attempts, maxAttempts) {
|
||||
return attempts < maxAttempts && this.retryDecider(error) && this.retryQuota.hasRetryTokens(error);
|
||||
}
|
||||
async getMaxAttempts() {
|
||||
let maxAttempts;
|
||||
try {
|
||||
maxAttempts = await this.maxAttemptsProvider();
|
||||
}
|
||||
catch (error) {
|
||||
maxAttempts = utilRetry.DEFAULT_MAX_ATTEMPTS;
|
||||
}
|
||||
return maxAttempts;
|
||||
}
|
||||
async retry(next, args, options) {
|
||||
let retryTokenAmount;
|
||||
let attempts = 0;
|
||||
let totalDelay = 0;
|
||||
const maxAttempts = await this.getMaxAttempts();
|
||||
const { request } = args;
|
||||
if (protocolHttp.HttpRequest.isInstance(request)) {
|
||||
request.headers[utilRetry.INVOCATION_ID_HEADER] = uuid.v4();
|
||||
}
|
||||
while (true) {
|
||||
try {
|
||||
if (protocolHttp.HttpRequest.isInstance(request)) {
|
||||
request.headers[utilRetry.REQUEST_HEADER] = `attempt=${attempts + 1}; max=${maxAttempts}`;
|
||||
}
|
||||
if (options?.beforeRequest) {
|
||||
await options.beforeRequest();
|
||||
}
|
||||
const { response, output } = await next(args);
|
||||
if (options?.afterRequest) {
|
||||
options.afterRequest(response);
|
||||
}
|
||||
this.retryQuota.releaseRetryTokens(retryTokenAmount);
|
||||
output.$metadata.attempts = attempts + 1;
|
||||
output.$metadata.totalRetryDelay = totalDelay;
|
||||
return { response, output };
|
||||
}
|
||||
catch (e) {
|
||||
const err = asSdkError(e);
|
||||
attempts++;
|
||||
if (this.shouldRetry(err, attempts, maxAttempts)) {
|
||||
retryTokenAmount = this.retryQuota.retrieveRetryTokens(err);
|
||||
const delayFromDecider = this.delayDecider(serviceErrorClassification.isThrottlingError(err) ? utilRetry.THROTTLING_RETRY_DELAY_BASE : utilRetry.DEFAULT_RETRY_DELAY_BASE, attempts);
|
||||
const delayFromResponse = getDelayFromRetryAfterHeader(err.$response);
|
||||
const delay = Math.max(delayFromResponse || 0, delayFromDecider);
|
||||
totalDelay += delay;
|
||||
await new Promise((resolve) => setTimeout(resolve, delay));
|
||||
continue;
|
||||
}
|
||||
if (!err.$metadata) {
|
||||
err.$metadata = {};
|
||||
}
|
||||
err.$metadata.attempts = attempts;
|
||||
err.$metadata.totalRetryDelay = totalDelay;
|
||||
throw err;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
const getDelayFromRetryAfterHeader = (response) => {
|
||||
if (!protocolHttp.HttpResponse.isInstance(response))
|
||||
return;
|
||||
const retryAfterHeaderName = Object.keys(response.headers).find((key) => key.toLowerCase() === "retry-after");
|
||||
if (!retryAfterHeaderName)
|
||||
return;
|
||||
const retryAfter = response.headers[retryAfterHeaderName];
|
||||
const retryAfterSeconds = Number(retryAfter);
|
||||
if (!Number.isNaN(retryAfterSeconds))
|
||||
return retryAfterSeconds * 1000;
|
||||
const retryAfterDate = new Date(retryAfter);
|
||||
return retryAfterDate.getTime() - Date.now();
|
||||
};
|
||||
|
||||
class AdaptiveRetryStrategy extends StandardRetryStrategy {
|
||||
rateLimiter;
|
||||
constructor(maxAttemptsProvider, options) {
|
||||
const { rateLimiter, ...superOptions } = options ?? {};
|
||||
super(maxAttemptsProvider, superOptions);
|
||||
this.rateLimiter = rateLimiter ?? new utilRetry.DefaultRateLimiter();
|
||||
this.mode = utilRetry.RETRY_MODES.ADAPTIVE;
|
||||
}
|
||||
async retry(next, args) {
|
||||
return super.retry(next, args, {
|
||||
beforeRequest: async () => {
|
||||
return this.rateLimiter.getSendToken();
|
||||
},
|
||||
afterRequest: (response) => {
|
||||
this.rateLimiter.updateClientSendingRate(response);
|
||||
},
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
const ENV_MAX_ATTEMPTS = "AWS_MAX_ATTEMPTS";
|
||||
const CONFIG_MAX_ATTEMPTS = "max_attempts";
|
||||
const NODE_MAX_ATTEMPT_CONFIG_OPTIONS = {
|
||||
environmentVariableSelector: (env) => {
|
||||
const value = env[ENV_MAX_ATTEMPTS];
|
||||
if (!value)
|
||||
return undefined;
|
||||
const maxAttempt = parseInt(value);
|
||||
if (Number.isNaN(maxAttempt)) {
|
||||
throw new Error(`Environment variable ${ENV_MAX_ATTEMPTS} mast be a number, got "${value}"`);
|
||||
}
|
||||
return maxAttempt;
|
||||
},
|
||||
configFileSelector: (profile) => {
|
||||
const value = profile[CONFIG_MAX_ATTEMPTS];
|
||||
if (!value)
|
||||
return undefined;
|
||||
const maxAttempt = parseInt(value);
|
||||
if (Number.isNaN(maxAttempt)) {
|
||||
throw new Error(`Shared config file entry ${CONFIG_MAX_ATTEMPTS} mast be a number, got "${value}"`);
|
||||
}
|
||||
return maxAttempt;
|
||||
},
|
||||
default: utilRetry.DEFAULT_MAX_ATTEMPTS,
|
||||
};
|
||||
const resolveRetryConfig = (input) => {
|
||||
const { retryStrategy, retryMode: _retryMode, maxAttempts: _maxAttempts } = input;
|
||||
const maxAttempts = utilMiddleware.normalizeProvider(_maxAttempts ?? utilRetry.DEFAULT_MAX_ATTEMPTS);
|
||||
return Object.assign(input, {
|
||||
maxAttempts,
|
||||
retryStrategy: async () => {
|
||||
if (retryStrategy) {
|
||||
return retryStrategy;
|
||||
}
|
||||
const retryMode = await utilMiddleware.normalizeProvider(_retryMode)();
|
||||
if (retryMode === utilRetry.RETRY_MODES.ADAPTIVE) {
|
||||
return new utilRetry.AdaptiveRetryStrategy(maxAttempts);
|
||||
}
|
||||
return new utilRetry.StandardRetryStrategy(maxAttempts);
|
||||
},
|
||||
});
|
||||
};
|
||||
const ENV_RETRY_MODE = "AWS_RETRY_MODE";
|
||||
const CONFIG_RETRY_MODE = "retry_mode";
|
||||
const NODE_RETRY_MODE_CONFIG_OPTIONS = {
|
||||
environmentVariableSelector: (env) => env[ENV_RETRY_MODE],
|
||||
configFileSelector: (profile) => profile[CONFIG_RETRY_MODE],
|
||||
default: utilRetry.DEFAULT_RETRY_MODE,
|
||||
};
|
||||
|
||||
const omitRetryHeadersMiddleware = () => (next) => async (args) => {
|
||||
const { request } = args;
|
||||
if (protocolHttp.HttpRequest.isInstance(request)) {
|
||||
delete request.headers[utilRetry.INVOCATION_ID_HEADER];
|
||||
delete request.headers[utilRetry.REQUEST_HEADER];
|
||||
}
|
||||
return next(args);
|
||||
};
|
||||
const omitRetryHeadersMiddlewareOptions = {
|
||||
name: "omitRetryHeadersMiddleware",
|
||||
tags: ["RETRY", "HEADERS", "OMIT_RETRY_HEADERS"],
|
||||
relation: "before",
|
||||
toMiddleware: "awsAuthMiddleware",
|
||||
override: true,
|
||||
};
|
||||
const getOmitRetryHeadersPlugin = (options) => ({
|
||||
applyToStack: (clientStack) => {
|
||||
clientStack.addRelativeTo(omitRetryHeadersMiddleware(), omitRetryHeadersMiddlewareOptions);
|
||||
},
|
||||
});
|
||||
|
||||
const retryMiddleware = (options) => (next, context) => async (args) => {
|
||||
let retryStrategy = await options.retryStrategy();
|
||||
const maxAttempts = await options.maxAttempts();
|
||||
if (isRetryStrategyV2(retryStrategy)) {
|
||||
retryStrategy = retryStrategy;
|
||||
let retryToken = await retryStrategy.acquireInitialRetryToken(context["partition_id"]);
|
||||
let lastError = new Error();
|
||||
let attempts = 0;
|
||||
let totalRetryDelay = 0;
|
||||
const { request } = args;
|
||||
const isRequest = protocolHttp.HttpRequest.isInstance(request);
|
||||
if (isRequest) {
|
||||
request.headers[utilRetry.INVOCATION_ID_HEADER] = uuid.v4();
|
||||
}
|
||||
while (true) {
|
||||
try {
|
||||
if (isRequest) {
|
||||
request.headers[utilRetry.REQUEST_HEADER] = `attempt=${attempts + 1}; max=${maxAttempts}`;
|
||||
}
|
||||
const { response, output } = await next(args);
|
||||
retryStrategy.recordSuccess(retryToken);
|
||||
output.$metadata.attempts = attempts + 1;
|
||||
output.$metadata.totalRetryDelay = totalRetryDelay;
|
||||
return { response, output };
|
||||
}
|
||||
catch (e) {
|
||||
const retryErrorInfo = getRetryErrorInfo(e);
|
||||
lastError = asSdkError(e);
|
||||
if (isRequest && isStreamingPayload.isStreamingPayload(request)) {
|
||||
(context.logger instanceof smithyClient.NoOpLogger ? console : context.logger)?.warn("An error was encountered in a non-retryable streaming request.");
|
||||
throw lastError;
|
||||
}
|
||||
try {
|
||||
retryToken = await retryStrategy.refreshRetryTokenForRetry(retryToken, retryErrorInfo);
|
||||
}
|
||||
catch (refreshError) {
|
||||
if (!lastError.$metadata) {
|
||||
lastError.$metadata = {};
|
||||
}
|
||||
lastError.$metadata.attempts = attempts + 1;
|
||||
lastError.$metadata.totalRetryDelay = totalRetryDelay;
|
||||
throw lastError;
|
||||
}
|
||||
attempts = retryToken.getRetryCount();
|
||||
const delay = retryToken.getRetryDelay();
|
||||
totalRetryDelay += delay;
|
||||
await new Promise((resolve) => setTimeout(resolve, delay));
|
||||
}
|
||||
}
|
||||
}
|
||||
else {
|
||||
retryStrategy = retryStrategy;
|
||||
if (retryStrategy?.mode)
|
||||
context.userAgent = [...(context.userAgent || []), ["cfg/retry-mode", retryStrategy.mode]];
|
||||
return retryStrategy.retry(next, args);
|
||||
}
|
||||
};
|
||||
const isRetryStrategyV2 = (retryStrategy) => typeof retryStrategy.acquireInitialRetryToken !== "undefined" &&
|
||||
typeof retryStrategy.refreshRetryTokenForRetry !== "undefined" &&
|
||||
typeof retryStrategy.recordSuccess !== "undefined";
|
||||
const getRetryErrorInfo = (error) => {
|
||||
const errorInfo = {
|
||||
error,
|
||||
errorType: getRetryErrorType(error),
|
||||
};
|
||||
const retryAfterHint = getRetryAfterHint(error.$response);
|
||||
if (retryAfterHint) {
|
||||
errorInfo.retryAfterHint = retryAfterHint;
|
||||
}
|
||||
return errorInfo;
|
||||
};
|
||||
const getRetryErrorType = (error) => {
|
||||
if (serviceErrorClassification.isThrottlingError(error))
|
||||
return "THROTTLING";
|
||||
if (serviceErrorClassification.isTransientError(error))
|
||||
return "TRANSIENT";
|
||||
if (serviceErrorClassification.isServerError(error))
|
||||
return "SERVER_ERROR";
|
||||
return "CLIENT_ERROR";
|
||||
};
|
||||
const retryMiddlewareOptions = {
|
||||
name: "retryMiddleware",
|
||||
tags: ["RETRY"],
|
||||
step: "finalizeRequest",
|
||||
priority: "high",
|
||||
override: true,
|
||||
};
|
||||
const getRetryPlugin = (options) => ({
|
||||
applyToStack: (clientStack) => {
|
||||
clientStack.add(retryMiddleware(options), retryMiddlewareOptions);
|
||||
},
|
||||
});
|
||||
const getRetryAfterHint = (response) => {
|
||||
if (!protocolHttp.HttpResponse.isInstance(response))
|
||||
return;
|
||||
const retryAfterHeaderName = Object.keys(response.headers).find((key) => key.toLowerCase() === "retry-after");
|
||||
if (!retryAfterHeaderName)
|
||||
return;
|
||||
const retryAfter = response.headers[retryAfterHeaderName];
|
||||
const retryAfterSeconds = Number(retryAfter);
|
||||
if (!Number.isNaN(retryAfterSeconds))
|
||||
return new Date(retryAfterSeconds * 1000);
|
||||
const retryAfterDate = new Date(retryAfter);
|
||||
return retryAfterDate;
|
||||
};
|
||||
|
||||
exports.AdaptiveRetryStrategy = AdaptiveRetryStrategy;
|
||||
exports.CONFIG_MAX_ATTEMPTS = CONFIG_MAX_ATTEMPTS;
|
||||
exports.CONFIG_RETRY_MODE = CONFIG_RETRY_MODE;
|
||||
exports.ENV_MAX_ATTEMPTS = ENV_MAX_ATTEMPTS;
|
||||
exports.ENV_RETRY_MODE = ENV_RETRY_MODE;
|
||||
exports.NODE_MAX_ATTEMPT_CONFIG_OPTIONS = NODE_MAX_ATTEMPT_CONFIG_OPTIONS;
|
||||
exports.NODE_RETRY_MODE_CONFIG_OPTIONS = NODE_RETRY_MODE_CONFIG_OPTIONS;
|
||||
exports.StandardRetryStrategy = StandardRetryStrategy;
|
||||
exports.defaultDelayDecider = defaultDelayDecider;
|
||||
exports.defaultRetryDecider = defaultRetryDecider;
|
||||
exports.getOmitRetryHeadersPlugin = getOmitRetryHeadersPlugin;
|
||||
exports.getRetryAfterHint = getRetryAfterHint;
|
||||
exports.getRetryPlugin = getRetryPlugin;
|
||||
exports.omitRetryHeadersMiddleware = omitRetryHeadersMiddleware;
|
||||
exports.omitRetryHeadersMiddlewareOptions = omitRetryHeadersMiddlewareOptions;
|
||||
exports.resolveRetryConfig = resolveRetryConfig;
|
||||
exports.retryMiddleware = retryMiddleware;
|
||||
exports.retryMiddlewareOptions = retryMiddlewareOptions;
|
||||
7
extracted-source/node_modules/@smithy/middleware-retry/dist-cjs/isStreamingPayload/isStreamingPayload.js
generated
vendored
Normal file
7
extracted-source/node_modules/@smithy/middleware-retry/dist-cjs/isStreamingPayload/isStreamingPayload.js
generated
vendored
Normal file
@@ -0,0 +1,7 @@
|
||||
"use strict";
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
exports.isStreamingPayload = void 0;
|
||||
const stream_1 = require("stream");
|
||||
const isStreamingPayload = (request) => request?.body instanceof stream_1.Readable ||
|
||||
(typeof ReadableStream !== "undefined" && request?.body instanceof ReadableStream);
|
||||
exports.isStreamingPayload = isStreamingPayload;
|
||||
169
extracted-source/node_modules/@smithy/middleware-retry/node_modules/@smithy/protocol-http/dist-cjs/index.js
generated
vendored
Normal file
169
extracted-source/node_modules/@smithy/middleware-retry/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;
|
||||
589
extracted-source/node_modules/@smithy/middleware-retry/node_modules/@smithy/smithy-client/dist-cjs/index.js
generated
vendored
Normal file
589
extracted-source/node_modules/@smithy/middleware-retry/node_modules/@smithy/smithy-client/dist-cjs/index.js
generated
vendored
Normal file
@@ -0,0 +1,589 @@
|
||||
'use strict';
|
||||
|
||||
var middlewareStack = require('@smithy/middleware-stack');
|
||||
var protocols = require('@smithy/core/protocols');
|
||||
var types = require('@smithy/types');
|
||||
var schema = require('@smithy/core/schema');
|
||||
var serde = require('@smithy/core/serde');
|
||||
|
||||
class Client {
|
||||
config;
|
||||
middlewareStack = middlewareStack.constructStack();
|
||||
initConfig;
|
||||
handlers;
|
||||
constructor(config) {
|
||||
this.config = config;
|
||||
}
|
||||
send(command, optionsOrCb, cb) {
|
||||
const options = typeof optionsOrCb !== "function" ? optionsOrCb : undefined;
|
||||
const callback = typeof optionsOrCb === "function" ? optionsOrCb : cb;
|
||||
const useHandlerCache = options === undefined && this.config.cacheMiddleware === true;
|
||||
let handler;
|
||||
if (useHandlerCache) {
|
||||
if (!this.handlers) {
|
||||
this.handlers = new WeakMap();
|
||||
}
|
||||
const handlers = this.handlers;
|
||||
if (handlers.has(command.constructor)) {
|
||||
handler = handlers.get(command.constructor);
|
||||
}
|
||||
else {
|
||||
handler = command.resolveMiddleware(this.middlewareStack, this.config, options);
|
||||
handlers.set(command.constructor, handler);
|
||||
}
|
||||
}
|
||||
else {
|
||||
delete this.handlers;
|
||||
handler = command.resolveMiddleware(this.middlewareStack, this.config, options);
|
||||
}
|
||||
if (callback) {
|
||||
handler(command)
|
||||
.then((result) => callback(null, result.output), (err) => callback(err))
|
||||
.catch(() => { });
|
||||
}
|
||||
else {
|
||||
return handler(command).then((result) => result.output);
|
||||
}
|
||||
}
|
||||
destroy() {
|
||||
this.config?.requestHandler?.destroy?.();
|
||||
delete this.handlers;
|
||||
}
|
||||
}
|
||||
|
||||
const SENSITIVE_STRING$1 = "***SensitiveInformation***";
|
||||
function schemaLogFilter(schema$1, data) {
|
||||
if (data == null) {
|
||||
return data;
|
||||
}
|
||||
const ns = schema.NormalizedSchema.of(schema$1);
|
||||
if (ns.getMergedTraits().sensitive) {
|
||||
return SENSITIVE_STRING$1;
|
||||
}
|
||||
if (ns.isListSchema()) {
|
||||
const isSensitive = !!ns.getValueSchema().getMergedTraits().sensitive;
|
||||
if (isSensitive) {
|
||||
return SENSITIVE_STRING$1;
|
||||
}
|
||||
}
|
||||
else if (ns.isMapSchema()) {
|
||||
const isSensitive = !!ns.getKeySchema().getMergedTraits().sensitive || !!ns.getValueSchema().getMergedTraits().sensitive;
|
||||
if (isSensitive) {
|
||||
return SENSITIVE_STRING$1;
|
||||
}
|
||||
}
|
||||
else if (ns.isStructSchema() && typeof data === "object") {
|
||||
const object = data;
|
||||
const newObject = {};
|
||||
for (const [member, memberNs] of ns.structIterator()) {
|
||||
if (object[member] != null) {
|
||||
newObject[member] = schemaLogFilter(memberNs, object[member]);
|
||||
}
|
||||
}
|
||||
return newObject;
|
||||
}
|
||||
return data;
|
||||
}
|
||||
|
||||
class Command {
|
||||
middlewareStack = middlewareStack.constructStack();
|
||||
schema;
|
||||
static classBuilder() {
|
||||
return new ClassBuilder();
|
||||
}
|
||||
resolveMiddlewareWithContext(clientStack, configuration, options, { middlewareFn, clientName, commandName, inputFilterSensitiveLog, outputFilterSensitiveLog, smithyContext, additionalContext, CommandCtor, }) {
|
||||
for (const mw of middlewareFn.bind(this)(CommandCtor, clientStack, configuration, options)) {
|
||||
this.middlewareStack.use(mw);
|
||||
}
|
||||
const stack = clientStack.concat(this.middlewareStack);
|
||||
const { logger } = configuration;
|
||||
const handlerExecutionContext = {
|
||||
logger,
|
||||
clientName,
|
||||
commandName,
|
||||
inputFilterSensitiveLog,
|
||||
outputFilterSensitiveLog,
|
||||
[types.SMITHY_CONTEXT_KEY]: {
|
||||
commandInstance: this,
|
||||
...smithyContext,
|
||||
},
|
||||
...additionalContext,
|
||||
};
|
||||
const { requestHandler } = configuration;
|
||||
return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
|
||||
}
|
||||
}
|
||||
class ClassBuilder {
|
||||
_init = () => { };
|
||||
_ep = {};
|
||||
_middlewareFn = () => [];
|
||||
_commandName = "";
|
||||
_clientName = "";
|
||||
_additionalContext = {};
|
||||
_smithyContext = {};
|
||||
_inputFilterSensitiveLog = undefined;
|
||||
_outputFilterSensitiveLog = undefined;
|
||||
_serializer = null;
|
||||
_deserializer = null;
|
||||
_operationSchema;
|
||||
init(cb) {
|
||||
this._init = cb;
|
||||
}
|
||||
ep(endpointParameterInstructions) {
|
||||
this._ep = endpointParameterInstructions;
|
||||
return this;
|
||||
}
|
||||
m(middlewareSupplier) {
|
||||
this._middlewareFn = middlewareSupplier;
|
||||
return this;
|
||||
}
|
||||
s(service, operation, smithyContext = {}) {
|
||||
this._smithyContext = {
|
||||
service,
|
||||
operation,
|
||||
...smithyContext,
|
||||
};
|
||||
return this;
|
||||
}
|
||||
c(additionalContext = {}) {
|
||||
this._additionalContext = additionalContext;
|
||||
return this;
|
||||
}
|
||||
n(clientName, commandName) {
|
||||
this._clientName = clientName;
|
||||
this._commandName = commandName;
|
||||
return this;
|
||||
}
|
||||
f(inputFilter = (_) => _, outputFilter = (_) => _) {
|
||||
this._inputFilterSensitiveLog = inputFilter;
|
||||
this._outputFilterSensitiveLog = outputFilter;
|
||||
return this;
|
||||
}
|
||||
ser(serializer) {
|
||||
this._serializer = serializer;
|
||||
return this;
|
||||
}
|
||||
de(deserializer) {
|
||||
this._deserializer = deserializer;
|
||||
return this;
|
||||
}
|
||||
sc(operation) {
|
||||
this._operationSchema = operation;
|
||||
this._smithyContext.operationSchema = operation;
|
||||
return this;
|
||||
}
|
||||
build() {
|
||||
const closure = this;
|
||||
let CommandRef;
|
||||
return (CommandRef = class extends Command {
|
||||
input;
|
||||
static getEndpointParameterInstructions() {
|
||||
return closure._ep;
|
||||
}
|
||||
constructor(...[input]) {
|
||||
super();
|
||||
this.input = input ?? {};
|
||||
closure._init(this);
|
||||
this.schema = closure._operationSchema;
|
||||
}
|
||||
resolveMiddleware(stack, configuration, options) {
|
||||
const op = closure._operationSchema;
|
||||
const input = op?.[4] ?? op?.input;
|
||||
const output = op?.[5] ?? op?.output;
|
||||
return this.resolveMiddlewareWithContext(stack, configuration, options, {
|
||||
CommandCtor: CommandRef,
|
||||
middlewareFn: closure._middlewareFn,
|
||||
clientName: closure._clientName,
|
||||
commandName: closure._commandName,
|
||||
inputFilterSensitiveLog: closure._inputFilterSensitiveLog ?? (op ? schemaLogFilter.bind(null, input) : (_) => _),
|
||||
outputFilterSensitiveLog: closure._outputFilterSensitiveLog ?? (op ? schemaLogFilter.bind(null, output) : (_) => _),
|
||||
smithyContext: closure._smithyContext,
|
||||
additionalContext: closure._additionalContext,
|
||||
});
|
||||
}
|
||||
serialize = closure._serializer;
|
||||
deserialize = closure._deserializer;
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
const SENSITIVE_STRING = "***SensitiveInformation***";
|
||||
|
||||
const createAggregatedClient = (commands, Client) => {
|
||||
for (const command of Object.keys(commands)) {
|
||||
const CommandCtor = commands[command];
|
||||
const methodImpl = async function (args, optionsOrCb, cb) {
|
||||
const command = new CommandCtor(args);
|
||||
if (typeof optionsOrCb === "function") {
|
||||
this.send(command, optionsOrCb);
|
||||
}
|
||||
else if (typeof cb === "function") {
|
||||
if (typeof optionsOrCb !== "object")
|
||||
throw new Error(`Expected http options but got ${typeof optionsOrCb}`);
|
||||
this.send(command, optionsOrCb || {}, cb);
|
||||
}
|
||||
else {
|
||||
return this.send(command, optionsOrCb);
|
||||
}
|
||||
};
|
||||
const methodName = (command[0].toLowerCase() + command.slice(1)).replace(/Command$/, "");
|
||||
Client.prototype[methodName] = methodImpl;
|
||||
}
|
||||
};
|
||||
|
||||
class ServiceException extends Error {
|
||||
$fault;
|
||||
$response;
|
||||
$retryable;
|
||||
$metadata;
|
||||
constructor(options) {
|
||||
super(options.message);
|
||||
Object.setPrototypeOf(this, Object.getPrototypeOf(this).constructor.prototype);
|
||||
this.name = options.name;
|
||||
this.$fault = options.$fault;
|
||||
this.$metadata = options.$metadata;
|
||||
}
|
||||
static isInstance(value) {
|
||||
if (!value)
|
||||
return false;
|
||||
const candidate = value;
|
||||
return (ServiceException.prototype.isPrototypeOf(candidate) ||
|
||||
(Boolean(candidate.$fault) &&
|
||||
Boolean(candidate.$metadata) &&
|
||||
(candidate.$fault === "client" || candidate.$fault === "server")));
|
||||
}
|
||||
static [Symbol.hasInstance](instance) {
|
||||
if (!instance)
|
||||
return false;
|
||||
const candidate = instance;
|
||||
if (this === ServiceException) {
|
||||
return ServiceException.isInstance(instance);
|
||||
}
|
||||
if (ServiceException.isInstance(instance)) {
|
||||
if (candidate.name && this.name) {
|
||||
return this.prototype.isPrototypeOf(instance) || candidate.name === this.name;
|
||||
}
|
||||
return this.prototype.isPrototypeOf(instance);
|
||||
}
|
||||
return false;
|
||||
}
|
||||
}
|
||||
const decorateServiceException = (exception, additions = {}) => {
|
||||
Object.entries(additions)
|
||||
.filter(([, v]) => v !== undefined)
|
||||
.forEach(([k, v]) => {
|
||||
if (exception[k] == undefined || exception[k] === "") {
|
||||
exception[k] = v;
|
||||
}
|
||||
});
|
||||
const message = exception.message || exception.Message || "UnknownError";
|
||||
exception.message = message;
|
||||
delete exception.Message;
|
||||
return exception;
|
||||
};
|
||||
|
||||
const throwDefaultError = ({ output, parsedBody, exceptionCtor, errorCode }) => {
|
||||
const $metadata = deserializeMetadata(output);
|
||||
const statusCode = $metadata.httpStatusCode ? $metadata.httpStatusCode + "" : undefined;
|
||||
const response = new exceptionCtor({
|
||||
name: parsedBody?.code || parsedBody?.Code || errorCode || statusCode || "UnknownError",
|
||||
$fault: "client",
|
||||
$metadata,
|
||||
});
|
||||
throw decorateServiceException(response, parsedBody);
|
||||
};
|
||||
const withBaseException = (ExceptionCtor) => {
|
||||
return ({ output, parsedBody, errorCode }) => {
|
||||
throwDefaultError({ output, parsedBody, exceptionCtor: ExceptionCtor, errorCode });
|
||||
};
|
||||
};
|
||||
const deserializeMetadata = (output) => ({
|
||||
httpStatusCode: output.statusCode,
|
||||
requestId: output.headers["x-amzn-requestid"] ?? output.headers["x-amzn-request-id"] ?? output.headers["x-amz-request-id"],
|
||||
extendedRequestId: output.headers["x-amz-id-2"],
|
||||
cfId: output.headers["x-amz-cf-id"],
|
||||
});
|
||||
|
||||
const loadConfigsForDefaultMode = (mode) => {
|
||||
switch (mode) {
|
||||
case "standard":
|
||||
return {
|
||||
retryMode: "standard",
|
||||
connectionTimeout: 3100,
|
||||
};
|
||||
case "in-region":
|
||||
return {
|
||||
retryMode: "standard",
|
||||
connectionTimeout: 1100,
|
||||
};
|
||||
case "cross-region":
|
||||
return {
|
||||
retryMode: "standard",
|
||||
connectionTimeout: 3100,
|
||||
};
|
||||
case "mobile":
|
||||
return {
|
||||
retryMode: "standard",
|
||||
connectionTimeout: 30000,
|
||||
};
|
||||
default:
|
||||
return {};
|
||||
}
|
||||
};
|
||||
|
||||
let warningEmitted = false;
|
||||
const emitWarningIfUnsupportedVersion = (version) => {
|
||||
if (version && !warningEmitted && parseInt(version.substring(1, version.indexOf("."))) < 16) {
|
||||
warningEmitted = true;
|
||||
}
|
||||
};
|
||||
|
||||
const getChecksumConfiguration = (runtimeConfig) => {
|
||||
const checksumAlgorithms = [];
|
||||
for (const id in types.AlgorithmId) {
|
||||
const algorithmId = types.AlgorithmId[id];
|
||||
if (runtimeConfig[algorithmId] === undefined) {
|
||||
continue;
|
||||
}
|
||||
checksumAlgorithms.push({
|
||||
algorithmId: () => algorithmId,
|
||||
checksumConstructor: () => runtimeConfig[algorithmId],
|
||||
});
|
||||
}
|
||||
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 getRetryConfiguration = (runtimeConfig) => {
|
||||
return {
|
||||
setRetryStrategy(retryStrategy) {
|
||||
runtimeConfig.retryStrategy = retryStrategy;
|
||||
},
|
||||
retryStrategy() {
|
||||
return runtimeConfig.retryStrategy;
|
||||
},
|
||||
};
|
||||
};
|
||||
const resolveRetryRuntimeConfig = (retryStrategyConfiguration) => {
|
||||
const runtimeConfig = {};
|
||||
runtimeConfig.retryStrategy = retryStrategyConfiguration.retryStrategy();
|
||||
return runtimeConfig;
|
||||
};
|
||||
|
||||
const getDefaultExtensionConfiguration = (runtimeConfig) => {
|
||||
return Object.assign(getChecksumConfiguration(runtimeConfig), getRetryConfiguration(runtimeConfig));
|
||||
};
|
||||
const getDefaultClientConfiguration = getDefaultExtensionConfiguration;
|
||||
const resolveDefaultRuntimeConfig = (config) => {
|
||||
return Object.assign(resolveChecksumRuntimeConfig(config), resolveRetryRuntimeConfig(config));
|
||||
};
|
||||
|
||||
const getArrayIfSingleItem = (mayBeArray) => Array.isArray(mayBeArray) ? mayBeArray : [mayBeArray];
|
||||
|
||||
const getValueFromTextNode = (obj) => {
|
||||
const textNodeName = "#text";
|
||||
for (const key in obj) {
|
||||
if (obj.hasOwnProperty(key) && obj[key][textNodeName] !== undefined) {
|
||||
obj[key] = obj[key][textNodeName];
|
||||
}
|
||||
else if (typeof obj[key] === "object" && obj[key] !== null) {
|
||||
obj[key] = getValueFromTextNode(obj[key]);
|
||||
}
|
||||
}
|
||||
return obj;
|
||||
};
|
||||
|
||||
const isSerializableHeaderValue = (value) => {
|
||||
return value != null;
|
||||
};
|
||||
|
||||
class NoOpLogger {
|
||||
trace() { }
|
||||
debug() { }
|
||||
info() { }
|
||||
warn() { }
|
||||
error() { }
|
||||
}
|
||||
|
||||
function map(arg0, arg1, arg2) {
|
||||
let target;
|
||||
let filter;
|
||||
let instructions;
|
||||
if (typeof arg1 === "undefined" && typeof arg2 === "undefined") {
|
||||
target = {};
|
||||
instructions = arg0;
|
||||
}
|
||||
else {
|
||||
target = arg0;
|
||||
if (typeof arg1 === "function") {
|
||||
filter = arg1;
|
||||
instructions = arg2;
|
||||
return mapWithFilter(target, filter, instructions);
|
||||
}
|
||||
else {
|
||||
instructions = arg1;
|
||||
}
|
||||
}
|
||||
for (const key of Object.keys(instructions)) {
|
||||
if (!Array.isArray(instructions[key])) {
|
||||
target[key] = instructions[key];
|
||||
continue;
|
||||
}
|
||||
applyInstruction(target, null, instructions, key);
|
||||
}
|
||||
return target;
|
||||
}
|
||||
const convertMap = (target) => {
|
||||
const output = {};
|
||||
for (const [k, v] of Object.entries(target || {})) {
|
||||
output[k] = [, v];
|
||||
}
|
||||
return output;
|
||||
};
|
||||
const take = (source, instructions) => {
|
||||
const out = {};
|
||||
for (const key in instructions) {
|
||||
applyInstruction(out, source, instructions, key);
|
||||
}
|
||||
return out;
|
||||
};
|
||||
const mapWithFilter = (target, filter, instructions) => {
|
||||
return map(target, Object.entries(instructions).reduce((_instructions, [key, value]) => {
|
||||
if (Array.isArray(value)) {
|
||||
_instructions[key] = value;
|
||||
}
|
||||
else {
|
||||
if (typeof value === "function") {
|
||||
_instructions[key] = [filter, value()];
|
||||
}
|
||||
else {
|
||||
_instructions[key] = [filter, value];
|
||||
}
|
||||
}
|
||||
return _instructions;
|
||||
}, {}));
|
||||
};
|
||||
const applyInstruction = (target, source, instructions, targetKey) => {
|
||||
if (source !== null) {
|
||||
let instruction = instructions[targetKey];
|
||||
if (typeof instruction === "function") {
|
||||
instruction = [, instruction];
|
||||
}
|
||||
const [filter = nonNullish, valueFn = pass, sourceKey = targetKey] = instruction;
|
||||
if ((typeof filter === "function" && filter(source[sourceKey])) || (typeof filter !== "function" && !!filter)) {
|
||||
target[targetKey] = valueFn(source[sourceKey]);
|
||||
}
|
||||
return;
|
||||
}
|
||||
let [filter, value] = instructions[targetKey];
|
||||
if (typeof value === "function") {
|
||||
let _value;
|
||||
const defaultFilterPassed = filter === undefined && (_value = value()) != null;
|
||||
const customFilterPassed = (typeof filter === "function" && !!filter(void 0)) || (typeof filter !== "function" && !!filter);
|
||||
if (defaultFilterPassed) {
|
||||
target[targetKey] = _value;
|
||||
}
|
||||
else if (customFilterPassed) {
|
||||
target[targetKey] = value();
|
||||
}
|
||||
}
|
||||
else {
|
||||
const defaultFilterPassed = filter === undefined && value != null;
|
||||
const customFilterPassed = (typeof filter === "function" && !!filter(value)) || (typeof filter !== "function" && !!filter);
|
||||
if (defaultFilterPassed || customFilterPassed) {
|
||||
target[targetKey] = value;
|
||||
}
|
||||
}
|
||||
};
|
||||
const nonNullish = (_) => _ != null;
|
||||
const pass = (_) => _;
|
||||
|
||||
const serializeFloat = (value) => {
|
||||
if (value !== value) {
|
||||
return "NaN";
|
||||
}
|
||||
switch (value) {
|
||||
case Infinity:
|
||||
return "Infinity";
|
||||
case -Infinity:
|
||||
return "-Infinity";
|
||||
default:
|
||||
return value;
|
||||
}
|
||||
};
|
||||
const serializeDateTime = (date) => date.toISOString().replace(".000Z", "Z");
|
||||
|
||||
const _json = (obj) => {
|
||||
if (obj == null) {
|
||||
return {};
|
||||
}
|
||||
if (Array.isArray(obj)) {
|
||||
return obj.filter((_) => _ != null).map(_json);
|
||||
}
|
||||
if (typeof obj === "object") {
|
||||
const target = {};
|
||||
for (const key of Object.keys(obj)) {
|
||||
if (obj[key] == null) {
|
||||
continue;
|
||||
}
|
||||
target[key] = _json(obj[key]);
|
||||
}
|
||||
return target;
|
||||
}
|
||||
return obj;
|
||||
};
|
||||
|
||||
Object.defineProperty(exports, "collectBody", {
|
||||
enumerable: true,
|
||||
get: function () { return protocols.collectBody; }
|
||||
});
|
||||
Object.defineProperty(exports, "extendedEncodeURIComponent", {
|
||||
enumerable: true,
|
||||
get: function () { return protocols.extendedEncodeURIComponent; }
|
||||
});
|
||||
Object.defineProperty(exports, "resolvedPath", {
|
||||
enumerable: true,
|
||||
get: function () { return protocols.resolvedPath; }
|
||||
});
|
||||
exports.Client = Client;
|
||||
exports.Command = Command;
|
||||
exports.NoOpLogger = NoOpLogger;
|
||||
exports.SENSITIVE_STRING = SENSITIVE_STRING;
|
||||
exports.ServiceException = ServiceException;
|
||||
exports._json = _json;
|
||||
exports.convertMap = convertMap;
|
||||
exports.createAggregatedClient = createAggregatedClient;
|
||||
exports.decorateServiceException = decorateServiceException;
|
||||
exports.emitWarningIfUnsupportedVersion = emitWarningIfUnsupportedVersion;
|
||||
exports.getArrayIfSingleItem = getArrayIfSingleItem;
|
||||
exports.getDefaultClientConfiguration = getDefaultClientConfiguration;
|
||||
exports.getDefaultExtensionConfiguration = getDefaultExtensionConfiguration;
|
||||
exports.getValueFromTextNode = getValueFromTextNode;
|
||||
exports.isSerializableHeaderValue = isSerializableHeaderValue;
|
||||
exports.loadConfigsForDefaultMode = loadConfigsForDefaultMode;
|
||||
exports.map = map;
|
||||
exports.resolveDefaultRuntimeConfig = resolveDefaultRuntimeConfig;
|
||||
exports.serializeDateTime = serializeDateTime;
|
||||
exports.serializeFloat = serializeFloat;
|
||||
exports.take = take;
|
||||
exports.throwDefaultError = throwDefaultError;
|
||||
exports.withBaseException = withBaseException;
|
||||
Object.keys(serde).forEach(function (k) {
|
||||
if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
|
||||
enumerable: true,
|
||||
get: function () { return serde[k]; }
|
||||
});
|
||||
});
|
||||
91
extracted-source/node_modules/@smithy/middleware-retry/node_modules/@smithy/types/dist-cjs/index.js
generated
vendored
Normal file
91
extracted-source/node_modules/@smithy/middleware-retry/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