@pepperize/cdk-organizations
Version:
Manage AWS organizations, organizational units (OU), accounts and service control policies (SCP).
1,402 lines (1,385 loc) • 23.9 MB
JavaScript
"use strict";
var __create = Object.create;
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __getProtoOf = Object.getPrototypeOf;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __commonJS = (cb, mod) => function __require() {
return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
};
var __export = (target, all) => {
for (var name in all)
__defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
if (from && typeof from === "object" || typeof from === "function") {
for (let key of __getOwnPropNames(from))
if (!__hasOwnProp.call(to, key) && key !== except)
__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
}
return to;
};
var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
// If the importer is in node compatibility mode or this is not an ESM
// file that has been converted to a CommonJS file using a Babel-
// compatible transform (i.e. "__esModule" has not been set), then set
// "default" to the CommonJS "module.exports" for node compatibility.
isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
mod
));
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
// node_modules/aws-sdk/lib/json/builder.js
var require_builder = __commonJS({
"node_modules/aws-sdk/lib/json/builder.js"(exports, module2) {
var util = require_util();
function JsonBuilder() {
}
JsonBuilder.prototype.build = function(value, shape) {
return JSON.stringify(translate(value, shape));
};
function translate(value, shape) {
if (!shape || value === void 0 || value === null)
return void 0;
switch (shape.type) {
case "structure":
return translateStructure(value, shape);
case "map":
return translateMap(value, shape);
case "list":
return translateList(value, shape);
default:
return translateScalar(value, shape);
}
}
function translateStructure(structure, shape) {
if (shape.isDocument) {
return structure;
}
var struct = {};
util.each(structure, function(name, value) {
var memberShape = shape.members[name];
if (memberShape) {
if (memberShape.location !== "body")
return;
var locationName = memberShape.isLocationName ? memberShape.name : name;
var result = translate(value, memberShape);
if (result !== void 0)
struct[locationName] = result;
}
});
return struct;
}
function translateList(list, shape) {
var out = [];
util.arrayEach(list, function(value) {
var result = translate(value, shape.member);
if (result !== void 0)
out.push(result);
});
return out;
}
function translateMap(map, shape) {
var out = {};
util.each(map, function(key, value) {
var result = translate(value, shape.value);
if (result !== void 0)
out[key] = result;
});
return out;
}
function translateScalar(value, shape) {
return shape.toWireFormat(value);
}
module2.exports = JsonBuilder;
}
});
// node_modules/aws-sdk/lib/json/parser.js
var require_parser = __commonJS({
"node_modules/aws-sdk/lib/json/parser.js"(exports, module2) {
var util = require_util();
function JsonParser() {
}
JsonParser.prototype.parse = function(value, shape) {
return translate(JSON.parse(value), shape);
};
function translate(value, shape) {
if (!shape || value === void 0)
return void 0;
switch (shape.type) {
case "structure":
return translateStructure(value, shape);
case "map":
return translateMap(value, shape);
case "list":
return translateList(value, shape);
default:
return translateScalar(value, shape);
}
}
function translateStructure(structure, shape) {
if (structure == null)
return void 0;
if (shape.isDocument)
return structure;
var struct = {};
var shapeMembers = shape.members;
var isAwsQueryCompatible = shape.api && shape.api.awsQueryCompatible;
util.each(shapeMembers, function(name, memberShape) {
var locationName = memberShape.isLocationName ? memberShape.name : name;
if (Object.prototype.hasOwnProperty.call(structure, locationName)) {
var value = structure[locationName];
var result = translate(value, memberShape);
if (result !== void 0)
struct[name] = result;
} else if (isAwsQueryCompatible && memberShape.defaultValue) {
if (memberShape.type === "list") {
struct[name] = typeof memberShape.defaultValue === "function" ? memberShape.defaultValue() : memberShape.defaultValue;
}
}
});
return struct;
}
function translateList(list, shape) {
if (list == null)
return void 0;
var out = [];
util.arrayEach(list, function(value) {
var result = translate(value, shape.member);
if (result === void 0)
out.push(null);
else
out.push(result);
});
return out;
}
function translateMap(map, shape) {
if (map == null)
return void 0;
var out = {};
util.each(map, function(key, value) {
var result = translate(value, shape.value);
if (result === void 0)
out[key] = null;
else
out[key] = result;
});
return out;
}
function translateScalar(value, shape) {
return shape.toType(value);
}
module2.exports = JsonParser;
}
});
// node_modules/aws-sdk/lib/protocol/helpers.js
var require_helpers = __commonJS({
"node_modules/aws-sdk/lib/protocol/helpers.js"(exports, module2) {
var util = require_util();
var AWS = require_core();
function populateHostPrefix(request) {
var enabled = request.service.config.hostPrefixEnabled;
if (!enabled)
return request;
var operationModel = request.service.api.operations[request.operation];
if (hasEndpointDiscover(request))
return request;
if (operationModel.endpoint && operationModel.endpoint.hostPrefix) {
var hostPrefixNotation = operationModel.endpoint.hostPrefix;
var hostPrefix = expandHostPrefix(hostPrefixNotation, request.params, operationModel.input);
prependEndpointPrefix(request.httpRequest.endpoint, hostPrefix);
validateHostname(request.httpRequest.endpoint.hostname);
}
return request;
}
function hasEndpointDiscover(request) {
var api = request.service.api;
var operationModel = api.operations[request.operation];
var isEndpointOperation = api.endpointOperation && api.endpointOperation === util.string.lowerFirst(operationModel.name);
return operationModel.endpointDiscoveryRequired !== "NULL" || isEndpointOperation === true;
}
function expandHostPrefix(hostPrefixNotation, params, shape) {
util.each(shape.members, function(name, member) {
if (member.hostLabel === true) {
if (typeof params[name] !== "string" || params[name] === "") {
throw util.error(new Error(), {
message: "Parameter " + name + " should be a non-empty string.",
code: "InvalidParameter"
});
}
var regex = new RegExp("\\{" + name + "\\}", "g");
hostPrefixNotation = hostPrefixNotation.replace(regex, params[name]);
}
});
return hostPrefixNotation;
}
function prependEndpointPrefix(endpoint, prefix) {
if (endpoint.host) {
endpoint.host = prefix + endpoint.host;
}
if (endpoint.hostname) {
endpoint.hostname = prefix + endpoint.hostname;
}
}
function validateHostname(hostname) {
var labels = hostname.split(".");
var hostPattern = /^[a-zA-Z0-9]{1}$|^[a-zA-Z0-9][a-zA-Z0-9\-]*[a-zA-Z0-9]$/;
util.arrayEach(labels, function(label) {
if (!label.length || label.length < 1 || label.length > 63) {
throw util.error(new Error(), {
code: "ValidationError",
message: "Hostname label length should be between 1 to 63 characters, inclusive."
});
}
if (!hostPattern.test(label)) {
throw AWS.util.error(
new Error(),
{ code: "ValidationError", message: label + " is not hostname compatible." }
);
}
});
}
module2.exports = {
populateHostPrefix
};
}
});
// node_modules/aws-sdk/lib/protocol/json.js
var require_json = __commonJS({
"node_modules/aws-sdk/lib/protocol/json.js"(exports, module2) {
var util = require_util();
var JsonBuilder = require_builder();
var JsonParser = require_parser();
var populateHostPrefix = require_helpers().populateHostPrefix;
function buildRequest(req) {
var httpRequest = req.httpRequest;
var api = req.service.api;
var target = api.targetPrefix + "." + api.operations[req.operation].name;
var version = api.jsonVersion || "1.0";
var input = api.operations[req.operation].input;
var builder = new JsonBuilder();
if (version === 1)
version = "1.0";
if (api.awsQueryCompatible) {
if (!httpRequest.params) {
httpRequest.params = {};
}
Object.assign(httpRequest.params, req.params);
}
httpRequest.body = builder.build(req.params || {}, input);
httpRequest.headers["Content-Type"] = "application/x-amz-json-" + version;
httpRequest.headers["X-Amz-Target"] = target;
populateHostPrefix(req);
}
function extractError(resp) {
var error = {};
var httpResponse = resp.httpResponse;
error.code = httpResponse.headers["x-amzn-errortype"] || "UnknownError";
if (typeof error.code === "string") {
error.code = error.code.split(":")[0];
}
if (httpResponse.body.length > 0) {
try {
var e = JSON.parse(httpResponse.body.toString());
var code = e.__type || e.code || e.Code;
if (code) {
error.code = code.split("#").pop();
}
if (error.code === "RequestEntityTooLarge") {
error.message = "Request body must be less than 1 MB";
} else {
error.message = e.message || e.Message || null;
}
for (var key in e || {}) {
if (key === "code" || key === "message") {
continue;
}
error["[" + key + "]"] = "See error." + key + " for details.";
Object.defineProperty(error, key, {
value: e[key],
enumerable: false,
writable: true
});
}
} catch (e2) {
error.statusCode = httpResponse.statusCode;
error.message = httpResponse.statusMessage;
}
} else {
error.statusCode = httpResponse.statusCode;
error.message = httpResponse.statusCode.toString();
}
resp.error = util.error(new Error(), error);
}
function extractData(resp) {
var body = resp.httpResponse.body.toString() || "{}";
if (resp.request.service.config.convertResponseTypes === false) {
resp.data = JSON.parse(body);
} else {
var operation = resp.request.service.api.operations[resp.request.operation];
var shape = operation.output || {};
var parser = new JsonParser();
resp.data = parser.parse(body, shape);
}
}
module2.exports = {
buildRequest,
extractError,
extractData
};
}
});
// node_modules/aws-sdk/lib/query/query_param_serializer.js
var require_query_param_serializer = __commonJS({
"node_modules/aws-sdk/lib/query/query_param_serializer.js"(exports, module2) {
var util = require_util();
function QueryParamSerializer() {
}
QueryParamSerializer.prototype.serialize = function(params, shape, fn) {
serializeStructure("", params, shape, fn);
};
function ucfirst(shape) {
if (shape.isQueryName || shape.api.protocol !== "ec2") {
return shape.name;
} else {
return shape.name[0].toUpperCase() + shape.name.substr(1);
}
}
function serializeStructure(prefix, struct, rules, fn) {
util.each(rules.members, function(name, member) {
var value = struct[name];
if (value === null || value === void 0)
return;
var memberName = ucfirst(member);
memberName = prefix ? prefix + "." + memberName : memberName;
serializeMember(memberName, value, member, fn);
});
}
function serializeMap(name, map, rules, fn) {
var i = 1;
util.each(map, function(key, value) {
var prefix = rules.flattened ? "." : ".entry.";
var position = prefix + i++ + ".";
var keyName = position + (rules.key.name || "key");
var valueName = position + (rules.value.name || "value");
serializeMember(name + keyName, key, rules.key, fn);
serializeMember(name + valueName, value, rules.value, fn);
});
}
function serializeList(name, list, rules, fn) {
var memberRules = rules.member || {};
if (list.length === 0) {
if (rules.api.protocol !== "ec2") {
fn.call(this, name, null);
}
return;
}
util.arrayEach(list, function(v, n) {
var suffix = "." + (n + 1);
if (rules.api.protocol === "ec2") {
suffix = suffix + "";
} else if (rules.flattened) {
if (memberRules.name) {
var parts = name.split(".");
parts.pop();
parts.push(ucfirst(memberRules));
name = parts.join(".");
}
} else {
suffix = "." + (memberRules.name ? memberRules.name : "member") + suffix;
}
serializeMember(name + suffix, v, memberRules, fn);
});
}
function serializeMember(name, value, rules, fn) {
if (value === null || value === void 0)
return;
if (rules.type === "structure") {
serializeStructure(name, value, rules, fn);
} else if (rules.type === "list") {
serializeList(name, value, rules, fn);
} else if (rules.type === "map") {
serializeMap(name, value, rules, fn);
} else {
fn(name, rules.toWireFormat(value).toString());
}
}
module2.exports = QueryParamSerializer;
}
});
// node_modules/aws-sdk/lib/model/collection.js
var require_collection = __commonJS({
"node_modules/aws-sdk/lib/model/collection.js"(exports, module2) {
var memoizedProperty = require_util().memoizedProperty;
function memoize(name, value, factory, nameTr) {
memoizedProperty(this, nameTr(name), function() {
return factory(name, value);
});
}
function Collection(iterable, options, factory, nameTr, callback) {
nameTr = nameTr || String;
var self = this;
for (var id in iterable) {
if (Object.prototype.hasOwnProperty.call(iterable, id)) {
memoize.call(self, id, iterable[id], factory, nameTr);
if (callback)
callback(id, iterable[id]);
}
}
}
module2.exports = Collection;
}
});
// node_modules/aws-sdk/lib/model/shape.js
var require_shape = __commonJS({
"node_modules/aws-sdk/lib/model/shape.js"(exports, module2) {
var Collection = require_collection();
var util = require_util();
function property(obj, name, value) {
if (value !== null && value !== void 0) {
util.property.apply(this, arguments);
}
}
function memoizedProperty(obj, name) {
if (!obj.constructor.prototype[name]) {
util.memoizedProperty.apply(this, arguments);
}
}
function Shape(shape, options, memberName) {
options = options || {};
property(this, "shape", shape.shape);
property(this, "api", options.api, false);
property(this, "type", shape.type);
property(this, "enum", shape.enum);
property(this, "min", shape.min);
property(this, "max", shape.max);
property(this, "pattern", shape.pattern);
property(this, "location", shape.location || this.location || "body");
property(this, "name", this.name || shape.xmlName || shape.queryName || shape.locationName || memberName);
property(this, "isStreaming", shape.streaming || this.isStreaming || false);
property(this, "requiresLength", shape.requiresLength, false);
property(this, "isComposite", shape.isComposite || false);
property(this, "isShape", true, false);
property(this, "isQueryName", Boolean(shape.queryName), false);
property(this, "isLocationName", Boolean(shape.locationName), false);
property(this, "isIdempotent", shape.idempotencyToken === true);
property(this, "isJsonValue", shape.jsonvalue === true);
property(this, "isSensitive", shape.sensitive === true || shape.prototype && shape.prototype.sensitive === true);
property(this, "isEventStream", Boolean(shape.eventstream), false);
property(this, "isEvent", Boolean(shape.event), false);
property(this, "isEventPayload", Boolean(shape.eventpayload), false);
property(this, "isEventHeader", Boolean(shape.eventheader), false);
property(this, "isTimestampFormatSet", Boolean(shape.timestampFormat) || shape.prototype && shape.prototype.isTimestampFormatSet === true, false);
property(this, "endpointDiscoveryId", Boolean(shape.endpointdiscoveryid), false);
property(this, "hostLabel", Boolean(shape.hostLabel), false);
if (options.documentation) {
property(this, "documentation", shape.documentation);
property(this, "documentationUrl", shape.documentationUrl);
}
if (shape.xmlAttribute) {
property(this, "isXmlAttribute", shape.xmlAttribute || false);
}
property(this, "defaultValue", null);
this.toWireFormat = function(value) {
if (value === null || value === void 0)
return "";
return value;
};
this.toType = function(value) {
return value;
};
}
Shape.normalizedTypes = {
character: "string",
double: "float",
long: "integer",
short: "integer",
biginteger: "integer",
bigdecimal: "float",
blob: "binary"
};
Shape.types = {
"structure": StructureShape,
"list": ListShape,
"map": MapShape,
"boolean": BooleanShape,
"timestamp": TimestampShape,
"float": FloatShape,
"integer": IntegerShape,
"string": StringShape,
"base64": Base64Shape,
"binary": BinaryShape
};
Shape.resolve = function resolve(shape, options) {
if (shape.shape) {
var refShape = options.api.shapes[shape.shape];
if (!refShape) {
throw new Error("Cannot find shape reference: " + shape.shape);
}
return refShape;
} else {
return null;
}
};
Shape.create = function create(shape, options, memberName) {
if (shape.isShape)
return shape;
var refShape = Shape.resolve(shape, options);
if (refShape) {
var filteredKeys = Object.keys(shape);
if (!options.documentation) {
filteredKeys = filteredKeys.filter(function(name) {
return !name.match(/documentation/);
});
}
var InlineShape = function() {
refShape.constructor.call(this, shape, options, memberName);
};
InlineShape.prototype = refShape;
return new InlineShape();
} else {
if (!shape.type) {
if (shape.members)
shape.type = "structure";
else if (shape.member)
shape.type = "list";
else if (shape.key)
shape.type = "map";
else
shape.type = "string";
}
var origType = shape.type;
if (Shape.normalizedTypes[shape.type]) {
shape.type = Shape.normalizedTypes[shape.type];
}
if (Shape.types[shape.type]) {
return new Shape.types[shape.type](shape, options, memberName);
} else {
throw new Error("Unrecognized shape type: " + origType);
}
}
};
function CompositeShape(shape) {
Shape.apply(this, arguments);
property(this, "isComposite", true);
if (shape.flattened) {
property(this, "flattened", shape.flattened || false);
}
}
function StructureShape(shape, options) {
var self = this;
var requiredMap = null, firstInit = !this.isShape;
CompositeShape.apply(this, arguments);
if (firstInit) {
property(this, "defaultValue", function() {
return {};
});
property(this, "members", {});
property(this, "memberNames", []);
property(this, "required", []);
property(this, "isRequired", function() {
return false;
});
property(this, "isDocument", Boolean(shape.document));
}
if (shape.members) {
property(this, "members", new Collection(shape.members, options, function(name, member) {
return Shape.create(member, options, name);
}));
memoizedProperty(this, "memberNames", function() {
return shape.xmlOrder || Object.keys(shape.members);
});
if (shape.event) {
memoizedProperty(this, "eventPayloadMemberName", function() {
var members = self.members;
var memberNames = self.memberNames;
for (var i = 0, iLen = memberNames.length; i < iLen; i++) {
if (members[memberNames[i]].isEventPayload) {
return memberNames[i];
}
}
});
memoizedProperty(this, "eventHeaderMemberNames", function() {
var members = self.members;
var memberNames = self.memberNames;
var eventHeaderMemberNames = [];
for (var i = 0, iLen = memberNames.length; i < iLen; i++) {
if (members[memberNames[i]].isEventHeader) {
eventHeaderMemberNames.push(memberNames[i]);
}
}
return eventHeaderMemberNames;
});
}
}
if (shape.required) {
property(this, "required", shape.required);
property(this, "isRequired", function(name) {
if (!requiredMap) {
requiredMap = {};
for (var i = 0; i < shape.required.length; i++) {
requiredMap[shape.required[i]] = true;
}
}
return requiredMap[name];
}, false, true);
}
property(this, "resultWrapper", shape.resultWrapper || null);
if (shape.payload) {
property(this, "payload", shape.payload);
}
if (typeof shape.xmlNamespace === "string") {
property(this, "xmlNamespaceUri", shape.xmlNamespace);
} else if (typeof shape.xmlNamespace === "object") {
property(this, "xmlNamespacePrefix", shape.xmlNamespace.prefix);
property(this, "xmlNamespaceUri", shape.xmlNamespace.uri);
}
}
function ListShape(shape, options) {
var self = this, firstInit = !this.isShape;
CompositeShape.apply(this, arguments);
if (firstInit) {
property(this, "defaultValue", function() {
return [];
});
}
if (shape.member) {
memoizedProperty(this, "member", function() {
return Shape.create(shape.member, options);
});
}
if (this.flattened) {
var oldName = this.name;
memoizedProperty(this, "name", function() {
return self.member.name || oldName;
});
}
}
function MapShape(shape, options) {
var firstInit = !this.isShape;
CompositeShape.apply(this, arguments);
if (firstInit) {
property(this, "defaultValue", function() {
return {};
});
property(this, "key", Shape.create({ type: "string" }, options));
property(this, "value", Shape.create({ type: "string" }, options));
}
if (shape.key) {
memoizedProperty(this, "key", function() {
return Shape.create(shape.key, options);
});
}
if (shape.value) {
memoizedProperty(this, "value", function() {
return Shape.create(shape.value, options);
});
}
}
function TimestampShape(shape) {
var self = this;
Shape.apply(this, arguments);
if (shape.timestampFormat) {
property(this, "timestampFormat", shape.timestampFormat);
} else if (self.isTimestampFormatSet && this.timestampFormat) {
property(this, "timestampFormat", this.timestampFormat);
} else if (this.location === "header") {
property(this, "timestampFormat", "rfc822");
} else if (this.location === "querystring") {
property(this, "timestampFormat", "iso8601");
} else if (this.api) {
switch (this.api.protocol) {
case "json":
case "rest-json":
property(this, "timestampFormat", "unixTimestamp");
break;
case "rest-xml":
case "query":
case "ec2":
property(this, "timestampFormat", "iso8601");
break;
}
}
this.toType = function(value) {
if (value === null || value === void 0)
return null;
if (typeof value.toUTCString === "function")
return value;
return typeof value === "string" || typeof value === "number" ? util.date.parseTimestamp(value) : null;
};
this.toWireFormat = function(value) {
return util.date.format(value, self.timestampFormat);
};
}
function StringShape() {
Shape.apply(this, arguments);
var nullLessProtocols = ["rest-xml", "query", "ec2"];
this.toType = function(value) {
value = this.api && nullLessProtocols.indexOf(this.api.protocol) > -1 ? value || "" : value;
if (this.isJsonValue) {
return JSON.parse(value);
}
return value && typeof value.toString === "function" ? value.toString() : value;
};
this.toWireFormat = function(value) {
return this.isJsonValue ? JSON.stringify(value) : value;
};
}
function FloatShape() {
Shape.apply(this, arguments);
this.toType = function(value) {
if (value === null || value === void 0)
return null;
return parseFloat(value);
};
this.toWireFormat = this.toType;
}
function IntegerShape() {
Shape.apply(this, arguments);
this.toType = function(value) {
if (value === null || value === void 0)
return null;
return parseInt(value, 10);
};
this.toWireFormat = this.toType;
}
function BinaryShape() {
Shape.apply(this, arguments);
this.toType = function(value) {
var buf = util.base64.decode(value);
if (this.isSensitive && util.isNode() && typeof util.Buffer.alloc === "function") {
var secureBuf = util.Buffer.alloc(buf.length, buf);
buf.fill(0);
buf = secureBuf;
}
return buf;
};
this.toWireFormat = util.base64.encode;
}
function Base64Shape() {
BinaryShape.apply(this, arguments);
}
function BooleanShape() {
Shape.apply(this, arguments);
this.toType = function(value) {
if (typeof value === "boolean")
return value;
if (value === null || value === void 0)
return null;
return value === "true";
};
}
Shape.shapes = {
StructureShape,
ListShape,
MapShape,
StringShape,
BooleanShape,
Base64Shape
};
module2.exports = Shape;
}
});
// node_modules/aws-sdk/lib/protocol/query.js
var require_query = __commonJS({
"node_modules/aws-sdk/lib/protocol/query.js"(exports, module2) {
var AWS = require_core();
var util = require_util();
var QueryParamSerializer = require_query_param_serializer();
var Shape = require_shape();
var populateHostPrefix = require_helpers().populateHostPrefix;
function buildRequest(req) {
var operation = req.service.api.operations[req.operation];
var httpRequest = req.httpRequest;
httpRequest.headers["Content-Type"] = "application/x-www-form-urlencoded; charset=utf-8";
httpRequest.params = {
Version: req.service.api.apiVersion,
Action: operation.name
};
var builder = new QueryParamSerializer();
builder.serialize(req.params, operation.input, function(name, value) {
httpRequest.params[name] = value;
});
httpRequest.body = util.queryParamsToString(httpRequest.params);
populateHostPrefix(req);
}
function extractError(resp) {
var data, body = resp.httpResponse.body.toString();
if (body.match("<UnknownOperationException")) {
data = {
Code: "UnknownOperation",
Message: "Unknown operation " + resp.request.operation
};
} else {
try {
data = new AWS.XML.Parser().parse(body);
} catch (e) {
data = {
Code: resp.httpResponse.statusCode,
Message: resp.httpResponse.statusMessage
};
}
}
if (data.requestId && !resp.requestId)
resp.requestId = data.requestId;
if (data.Errors)
data = data.Errors;
if (data.Error)
data = data.Error;
if (data.Code) {
resp.error = util.error(new Error(), {
code: data.Code,
message: data.Message
});
} else {
resp.error = util.error(new Error(), {
code: resp.httpResponse.statusCode,
message: null
});
}
}
function extractData(resp) {
var req = resp.request;
var operation = req.service.api.operations[req.operation];
var shape = operation.output || {};
var origRules = shape;
if (origRules.resultWrapper) {
var tmp = Shape.create({ type: "structure" });
tmp.members[origRules.resultWrapper] = shape;
tmp.memberNames = [origRules.resultWrapper];
util.property(shape, "name", shape.resultWrapper);
shape = tmp;
}
var parser = new AWS.XML.Parser();
if (shape && shape.members && !shape.members._XAMZRequestId) {
var requestIdShape = Shape.create(
{ type: "string" },
{ api: { protocol: "query" } },
"requestId"
);
shape.members._XAMZRequestId = requestIdShape;
}
var data = parser.parse(resp.httpResponse.body.toString(), shape);
resp.requestId = data._XAMZRequestId || data.requestId;
if (data._XAMZRequestId)
delete data._XAMZRequestId;
if (origRules.resultWrapper) {
if (data[origRules.resultWrapper]) {
util.update(data, data[origRules.resultWrapper]);
delete data[origRules.resultWrapper];
}
}
resp.data = data;
}
module2.exports = {
buildRequest,
extractError,
extractData
};
}
});
// node_modules/aws-sdk/lib/protocol/rest.js
var require_rest = __commonJS({
"node_modules/aws-sdk/lib/protocol/rest.js"(exports, module2) {
var util = require_util();
var populateHostPrefix = require_helpers().populateHostPrefix;
function populateMethod(req) {
req.httpRequest.method = req.service.api.operations[req.operation].httpMethod;
}
function generateURI(endpointPath, operationPath, input, params) {
var uri = [endpointPath, operationPath].join("/");
uri = uri.replace(/\/+/g, "/");
var queryString = {}, queryStringSet = false;
util.each(input.members, function(name, member) {
var paramValue = params[name];
if (paramValue === null || paramValue === void 0)
return;
if (member.location === "uri") {
var regex = new RegExp("\\{" + member.name + "(\\+)?\\}");
uri = uri.replace(regex, function(_, plus) {
var fn = plus ? util.uriEscapePath : util.uriEscape;
return fn(String(paramValue));
});
} else if (member.location === "querystring") {
queryStringSet = true;
if (member.type === "list") {
queryString[member.name] = paramValue.map(function(val) {
return util.uriEscape(member.member.toWireFormat(val).toString());
});
} else if (member.type === "map") {
util.each(paramValue, function(key, value) {
if (Array.isArray(value)) {
queryString[key] = value.map(function(val) {
return util.uriEscape(String(val));
});
} else {
queryString[key] = util.uriEscape(String(value));
}
});
} else {
queryString[member.name] = util.uriEscape(member.toWireFormat(paramValue).toString());
}
}
});
if (queryStringSet) {
uri += uri.indexOf("?") >= 0 ? "&" : "?";
var parts = [];
util.arrayEach(Object.keys(queryString).sort(), function(key) {
if (!Array.isArray(queryString[key])) {
queryString[key] = [queryString[key]];
}
for (var i = 0; i < queryString[key].length; i++) {
parts.push(util.uriEscape(String(key)) + "=" + queryString[key][i]);
}
});
uri += parts.join("&");
}
return uri;
}
function populateURI(req) {
var operation = req.service.api.operations[req.operation];
var input = operation.input;
var uri = generateURI(req.httpRequest.endpoint.path, operation.httpPath, input, req.params);
req.httpRequest.path = uri;
}
function populateHeaders(req) {
var operation = req.service.api.operations[req.operation];
util.each(operation.input.members, function(name, member) {
var value = req.params[name];
if (value === null || value === void 0)
return;
if (member.location === "headers" && member.type === "map") {
util.each(value, function(key, memberValue) {
req.httpRequest.headers[member.name + key] = memberValue;
});
} else if (member.location === "header") {
value = member.toWireFormat(value).toString();
if (member.isJsonValue) {
value = util.base64.encode(value);
}
req.httpRequest.headers[member.name] = value;
}
});
}
function buildRequest(req) {
populateMethod(req);
populateURI(req);
populateHeaders(req);
populateHostPrefix(req);
}
function extractError() {
}
function extractData(resp) {
var req = resp.request;
var data = {};
var r = resp.httpResponse;
var operation = req.service.api.operations[req.operation];
var output = operation.output;
var headers = {};
util.each(r.headers, function(k, v) {
headers[k.toLowerCase()] = v;
});
util.each(output.members, function(name, member) {
var header = (member.name || name).toLowerCase();
if (member.location === "headers" && member.type === "map") {
data[name] = {};
var location = member.isLocationName ? member.name : "";
var pattern = new RegExp("^" + location + "(.+)", "i");
util.each(r.headers, function(k, v) {
var result = k.match(pattern);
if (result !== null) {
data[name][result[1]] = v;
}
});
} else if (member.location === "header") {
if (headers[header] !== void 0) {
var value = member.isJsonValue ? util.base64.decode(headers[header]) : headers[header];
data[name] = member.toType(value);
}
} else if (member.location === "statusCode") {
data[name] = parseInt(r.statusCode, 10);
}
});
resp.data = data;
}
module2.exports = {
buildRequest,
extractError,
extractData,
generateURI
};
}
});
// node_modules/aws-sdk/lib/protocol/rest_json.js
var require_rest_json = __commonJS({
"node_modules/aws-sdk/lib/protocol/rest_json.js"(exports, module2) {
var AWS = require_core();
var util = require_util();
var Rest = require_rest();
var Json = require_json();
var JsonBuilder = require_builder();
var JsonParser = require_parser();
var METHODS_WITHOUT_BODY = ["GET", "HEAD", "DELETE"];
function unsetContentLength(req) {
var payloadMember = util.getRequestPayloadShape(req);
if (payloadMember === void 0 && METHODS_WITHOUT_BODY.indexOf(req.httpRequest.method) >= 0) {
delete req.httpRequest.headers["Content-Length"];
}
}
function populateBody(req) {
var builder = new JsonBuilder();
var input = req.service.api.operations[req.operation].input;
if (input.payload) {
var params = {};
var payloadShape = input.members[input.payload];
params = req.params[input.payload];
if (payloadShape.type === "structure") {
req.httpRequest.body = builder.build(params || {}, payloadShape);
applyContentTypeHeader(req);
} else if (params !== void 0) {
req.httpRequest.body = params;
if (payloadShape.type === "binary" || payloadShape.isStreaming) {
applyContentTypeHeader(req, true);
}
}
} else {
req.httpRequest.body = builder.build(req.params, input);
applyContentTypeHeader(req);
}
}
function applyContentTypeHeader(req, isBinary) {
if (!req.httpRequest.headers["Content-Type"]) {
var type = isBinary ? "binary/octet-stream" : "application/json";
req.httpRequest.headers["Content-Type"] = type;
}
}
function buildRequest(req) {
Rest.buildRequest(req);
if (METHODS_WITHOUT_BODY.indexOf(req.httpRequest.method) < 0) {
populateBody(req);
}
}
function extractError(resp) {
Json.extractError(resp);
}
function extractData(resp) {
Rest.extractData(resp);
var req = resp.request;
var operation = req.service.api.operations[req.operation];
var rules = req.service.api.operations[req.operation].output || {};
var parser;
var hasEventOutput = operation.hasEventOutput;
if (rules.payload) {
var payloadMember = rules.members[rules.payload];
var body = resp.httpResponse.body;
if (payloadMember.isEventStream) {
parser = new JsonParser();
resp.data[rules.payload] = util.createEventStream(
AWS.HttpClient.streamsApiVersion === 2 ? resp.httpResponse.stream : body,
parser,
payloadMember
);
} else if (payloadMember.type === "structure" || payloadMember.type === "list") {
var parser = new JsonParser();
resp.data[rules.payload] = parser.parse(body, payloadMember);
} else if (payloadMember.type === "binary" || payloadMember.isStreaming) {
resp.data[rules.payload] = body;
} else {
resp.data[rules.payload] = payloadMember.toType(body);
}
} else {
var data = resp.data;
Json.extractData(resp);
resp.data = util.merge(data, resp.data);
}
}
module2.exports = {
buildRequest,
extractError,
extractData,
unsetContentLength
};
}
});
// node_modules/aws-sdk/lib/protocol/rest_xml.js
var require_rest_xml = __commonJS({
"node_modules/aws-sdk/lib/protocol/rest_xml.js"(exports, module2) {
var AWS = require_core();
var util = require_util();
var Rest = require_rest();
function populateBody(req) {
var input = req.service.api.operations[req.operation].input;
var builder = new AWS.XML.Builder();
var params = req.params;
var payload = input.payload;
if (payload) {
var payloadMember = input.members[payload];
params = params[payload];
if (params === void 0)
return;
if (payloadMember.type === "structure") {
var rootElement = payloadMember.name;
req.httpRequest.body = builder.toXML(params, payloadMember, rootElement, true);
} else {
req.httpRequest.body = params;
}
} else {
req.httpRequest.body = builder.toXML(params, input, input.name || input.shape || util.string.upperFirst(req.operation) + "Request");
}
}
function buildRequest(req) {
Rest.buildRequest(req);
if (["GET", "HEAD"].indexOf(req.httpRequest.method) < 0) {
populateBody(req);
}
}
function extractError(resp) {
Rest.extractError(resp);
var data;
try {
data = new AWS.XML.Parser().parse(resp.httpResponse.body.toString());
} catch (e) {
data = {
Code: resp.httpResponse.statusCode,
Message: resp.httpResponse.statusMessage
};
}
if (data.Errors)
data = data.Errors;
if (data.Error)
data = data.Error;
if (data.Code) {
resp.error = util.error(new Error(), {
code: data.Code,
message: data.Message
});
} else {
resp.error = util.error(new Error(), {
code: resp.httpResponse.statusCode,
message: null
});
}
}
function extractData(resp) {
Rest.extractData(resp);
var parser;
var req = resp.request;
var body = resp.httpResponse.body;
var operation = req.service.api.operations[req.operation];
var output = operation.output;
var hasEventOutput = operation.hasEventOutput;
var payload = output.payload;
if (payload) {
var payloadMember = output.members[payload];
if (payloadMember.isEventStream) {
parser = new AWS.XML.Parser();
resp.data[payload] = util.createEventStream(
AWS.HttpClient.streamsApiVersion === 2 ? resp.httpResponse.stream : resp.httpResponse.body,
parser,
payloadMember
);
} else if (payloadMember.type === "structure") {
parser = new AWS.XML.Parser();
resp.data[payload] = parser.parse(body.toString(), payloadMember);
} else if (payloadMember.type === "binary" || payloadMember.isStreaming) {
resp.data[payload] = body;
} else {
resp.data[payload] = payloadMember.toType(body);
}
} else if (body.length > 0) {
parser = new AWS.XML.Parser();
var data = parser.parse(body.toString(), output);
util.update(resp.data, data);
}
}
module2.exports = {
buildRequest,
extractError,
extractData
};
}
});
// node_modules/aws-sdk/lib/xml/escape-attribute.js
var require_escape_attribute = __commonJS({
"node_modules/aws-sdk/lib/xml/escape-attribute.js"(exports, module2) {
function escapeAttribute(value) {
return value.replace(/&/g, "&").replace(/'/g, "'").replace(/</g, "<").replace(/>/g, ">").replace(/"/g, """);
}
module2.exports = {
escapeAttribute
};
}
});
// node_modules/aws-sdk/lib/xml/xml-node.js
var require_xml_node = __commonJS({
"node_modules/aws-sdk/lib/xml/xml-node.js"(exports, module2) {
var escapeAttribute = require_escape_attribute().escapeAttribute;
function XmlNode(name, children2) {
if (children2 === void 0) {
children2 = [];
}
this.name = name;
this.children = children2;
this.attributes = {};
}
XmlNode.prototype.addAttribute = function(name, value) {
this.attributes[name] = value;
return this;
};
XmlNode.prototype.addChildNode = function(child) {
this.children.push(child);
return this;
};
XmlNode.prototype.removeAttribute = function(name) {
delete this.attributes[name];
return this;
};
XmlNode.prototype.toString = function() {
var hasChildren = Boolean(this.children.length);
var xmlText = "<" + this.name;
var attributes = this.attributes;
for (var i = 0, attributeNames = Object.keys(attributes); i < attributeNames.length; i++) {
var attributeName = attributeNames[i];
var attribute = attributes[attributeName];
if (typeof attribute !== "undefined" && attribute !== null) {
xmlText += " " + attributeName + '="' + escapeAttribute("" + attribute) + '"';
}
}
return xmlText += !hasChildren ? "/>" : ">" + this.children.map(function(c) {
return c.toString();
}).join("") + "</" + this.name + ">";
};
module2.exports = {
XmlNode
};
}
});
// node_modules/aws-sdk/lib/xml/escape-element.js
var require_escape_element = __commonJS({
"node_modules/aws-sdk/lib/xml/escape-element.js"(exports, module2) {
function escapeElement(value) {
return value.replace(/&/g, "&").replace(/</g, "<").replace(/>/g, ">").replace(/\r/g, "
").replace(/\n/g, "
").replace(/\u0085/g, "…").replace(/\u2028/, "
");
}
module2.exports = {
escapeElement
};
}
});
// node_modules/aws-sdk/lib/xml/xml-text.js
var require_xml_text = __commonJS({
"node_modules/aws-sdk/lib/xml/xml-text.js"(exports, module2) {
var escapeElement = require_escape_element().escapeElement;
function XmlText(value) {
this.value = value;
}
XmlText.prototype.toString = function() {
return escapeElement("" + this.value);
};
module2.exports = {
XmlText
};
}
});
// node_modules/aws-sdk/lib/xml/builder.js
var require_builder2 = __commonJS({
"node_modules/aws-sdk/lib/xml/builder.js"(exports, module2) {
var util = require_util();
var XmlNode = require_xml_node().XmlNode;
var XmlText = require_xml_text().XmlText;
function XmlBuilder() {
}
XmlBuilder.prototype.toXML = function(params, shape, rootElement, noEmpty) {
var xml = new XmlNode(rootElement);
applyNamespaces(xml, shape, true);
serialize(xml, params, shape);
return xml.children.length > 0 || noEmpty ? xml.toString() : "";
};
function serialize(xml, value, shape) {
switch (shape.type) {
case "structure":
return serializeStructure(xml, value, shape);
case "map":
return serializeMap(xml, value, shape);
case "list":
return serializeList(xml, value, shape);
default:
return serializeScalar(xml, value, shape);
}
}
function serializeStructure(xml, params, shape) {
util.arrayEach(shape.memberNames, function(memberName) {
var memberShape = shape.members[memberName];
if (memberShape.location !== "body")
return;
var value = params[memberName];
var name = memberShape.name;
if (value !== void 0 && value !== null) {
if (memberShape.isXmlAttribute) {
xml.addAttribute(name, value);
} else if (memberShape.flattened) {
serialize(xml, value, memberShape);
} else {
var element = new XmlNode(name);
xml.addChildNode(element);
applyNamespaces(element, memberShape);
serialize(element, value, memberShape);
}
}
});
}
function serializeMap(xml, map, shape) {
var xmlKey = shape.key.name || "key";
var xmlValue = shape.value.name || "value";
util.each(map, function(key, value) {
var entry = new XmlNode(shape.flattened ? shape.name : "entry");
xml.addChildNode(entry);
var entryKey = new XmlNode(xmlKey);
var entryValue = new XmlNode(xmlValue);
entry.addChildNode(entryKey);
entry.addChildNode(entryValue);
serialize(entryKey, key, shape.key);
serialize(entryValue, value, shape.value);
});
}
function serializeList(xml, list, shape) {
if (shape.flattened) {
util.arrayEach(list, function(value) {
var name = shape.member.name || shape.name;
var element = new XmlNode(name);
xml.addChildNode(element);
serialize(element, value, shape.member);
});
} else {
util.arrayEach(list, function(value) {
var name = shape.member.name || "member";
var element = new XmlNode(name);
xml.addChildNode(element);
serialize(element, value, shape.member);
});
}
}
function serializeScalar(xml, value, shape) {
xml.addChildNode(
new XmlText(shape.toWireFormat(value))
);
}
function applyNamespaces(xml, shape, isRoot) {
var uri, prefix = "xmlns";
if (shape.xmlNamespaceUri) {
uri = shape.xmlNamespaceUri;
if (shape.xmlNamespacePrefix)
prefix += ":" + shape.xmlNamespacePrefix;
} else if (isRoot && shape.api.xmlNamespaceUri) {
uri = shape.api.xmlNamespaceUri;
}
if (uri)
xml.addAttribute(prefix, uri);
}
module2.exports = XmlBuilder;
}
});
// node_modules/aws-sdk/lib/model/operation.js
var require_operation = __commonJS({
"node_modules/aws-sdk/lib/model/operation.js"(exports, module2) {
var Shape = require_shape();
var util = r