590 lines
19 KiB
JavaScript
590 lines
19 KiB
JavaScript
'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]; }
|
|
});
|
|
});
|