@mavogel/awscdk-rootmail 0.0.310 → 0.0.312

package/node_modules/@aws-sdk/core/dist-es/submodules/protocols/query/AwsQueryProtocol.js

@@ -0,0 +1,147 @@
+import { collectBody, RpcProtocol } from "@smithy/core/protocols";
+import { deref, NormalizedSchema, SCHEMA, TypeRegistry } from "@smithy/core/schema";
+import { calculateBodyLength } from "@smithy/util-body-length-browser";
+import { XmlShapeDeserializer } from "../xml/XmlShapeDeserializer";
+import { QueryShapeSerializer } from "./QueryShapeSerializer";
+export class AwsQueryProtocol extends RpcProtocol {
+    options;
+    serializer;
+    deserializer;
+    constructor(options) {
+        super({
+            defaultNamespace: options.defaultNamespace,
+        });
+        this.options = options;
+        const settings = {
+            timestampFormat: {
+                useTrait: true,
+                default: SCHEMA.TIMESTAMP_DATE_TIME,
+            },
+            httpBindings: false,
+            xmlNamespace: options.xmlNamespace,
+            serviceNamespace: options.defaultNamespace,
+            serializeEmptyLists: true,
+        };
+        this.serializer = new QueryShapeSerializer(settings);
+        this.deserializer = new XmlShapeDeserializer(settings);
+    }
+    getShapeId() {
+        return "aws.protocols#awsQuery";
+    }
+    setSerdeContext(serdeContext) {
+        this.serializer.setSerdeContext(serdeContext);
+        this.deserializer.setSerdeContext(serdeContext);
+    }
+    getPayloadCodec() {
+        throw new Error("AWSQuery protocol has no payload codec.");
+    }
+    async serializeRequest(operationSchema, input, context) {
+        const request = await super.serializeRequest(operationSchema, input, context);
+        if (!request.path.endsWith("/")) {
+            request.path += "/";
+        }
+        Object.assign(request.headers, {
+            "content-type": `application/x-www-form-urlencoded`,
+        });
+        if (deref(operationSchema.input) === "unit" || !request.body) {
+            request.body = "";
+        }
+        request.body = `Action=${operationSchema.name.split("#")[1]}&Version=${this.options.version}` + request.body;
+        if (request.body.endsWith("&")) {
+            request.body = request.body.slice(-1);
+        }
+        try {
+            request.headers["content-length"] = String(calculateBodyLength(request.body));
+        }
+        catch (e) { }
+        return request;
+    }
+    async deserializeResponse(operationSchema, context, response) {
+        const deserializer = this.deserializer;
+        const ns = NormalizedSchema.of(operationSchema.output);
+        const dataObject = {};
+        if (response.statusCode >= 300) {
+            const bytes = await collectBody(response.body, context);
+            if (bytes.byteLength > 0) {
+                Object.assign(dataObject, await deserializer.read(SCHEMA.DOCUMENT, bytes));
+            }
+            await this.handleError(operationSchema, context, response, dataObject, this.deserializeMetadata(response));
+        }
+        for (const header in response.headers) {
+            const value = response.headers[header];
+            delete response.headers[header];
+            response.headers[header.toLowerCase()] = value;
+        }
+        const awsQueryResultKey = ns.isStructSchema() && this.useNestedResult() ? operationSchema.name.split("#")[1] + "Result" : undefined;
+        const bytes = await collectBody(response.body, context);
+        if (bytes.byteLength > 0) {
+            Object.assign(dataObject, await deserializer.read(ns, bytes, awsQueryResultKey));
+        }
+        const output = {
+            $metadata: this.deserializeMetadata(response),
+            ...dataObject,
+        };
+        return output;
+    }
+    useNestedResult() {
+        return true;
+    }
+    async handleError(operationSchema, context, response, dataObject, metadata) {
+        const errorIdentifier = this.loadQueryErrorCode(response, dataObject) ?? "Unknown";
+        let namespace = this.options.defaultNamespace;
+        let errorName = errorIdentifier;
+        if (errorIdentifier.includes("#")) {
+            [namespace, errorName] = errorIdentifier.split("#");
+        }
+        const errorDataSource = this.loadQueryError(dataObject);
+        const registry = TypeRegistry.for(namespace);
+        let errorSchema;
+        try {
+            errorSchema = registry.find((schema) => NormalizedSchema.of(schema).getMergedTraits().awsQueryError?.[0] === errorName);
+            if (!errorSchema) {
+                errorSchema = registry.getSchema(errorIdentifier);
+            }
+        }
+        catch (e) {
+            const baseExceptionSchema = TypeRegistry.for("smithy.ts.sdk.synthetic." + namespace).getBaseException();
+            if (baseExceptionSchema) {
+                const ErrorCtor = baseExceptionSchema.ctor;
+                throw Object.assign(new ErrorCtor(errorName), errorDataSource);
+            }
+            throw new Error(errorName);
+        }
+        const ns = NormalizedSchema.of(errorSchema);
+        const message = this.loadQueryErrorMessage(dataObject);
+        const exception = new errorSchema.ctor(message);
+        const output = {};
+        for (const [name, member] of ns.structIterator()) {
+            const target = member.getMergedTraits().xmlName ?? name;
+            const value = errorDataSource[target] ?? dataObject[target];
+            output[name] = this.deserializer.readSchema(member, value);
+        }
+        Object.assign(exception, {
+            $metadata: metadata,
+            $response: response,
+            $fault: ns.getMergedTraits().error,
+            message,
+            ...output,
+        });
+        throw exception;
+    }
+    loadQueryErrorCode(output, data) {
+        const code = (data.Errors?.[0]?.Error ?? data.Errors?.Error ?? data.Error)?.Code;
+        if (code !== undefined) {
+            return code;
+        }
+        if (output.statusCode == 404) {
+            return "NotFound";
+        }
+    }
+    loadQueryError(data) {
+        return data.Errors?.[0]?.Error ?? data.Errors?.Error ?? data.Error;
+    }
+    loadQueryErrorMessage(data) {
+        const errorData = this.loadQueryError(data);
+        return errorData?.message ?? errorData?.Message ?? data.message ?? data.Message ?? "Unknown";
+    }
+}

package/node_modules/@aws-sdk/core/dist-es/submodules/protocols/query/QuerySerializerSettings.js

@@ -0,0 +1 @@
+export {};

package/node_modules/@aws-sdk/core/dist-es/submodules/protocols/query/QueryShapeSerializer.js

@@ -0,0 +1,152 @@
+import { determineTimestampFormat, extendedEncodeURIComponent } from "@smithy/core/protocols";
+import { NormalizedSchema, SCHEMA } from "@smithy/core/schema";
+import { NumericValue } from "@smithy/core/serde";
+import { dateToUtcString } from "@smithy/smithy-client";
+import { toBase64 } from "@smithy/util-base64";
+import { SerdeContextConfig } from "../ConfigurableSerdeContext";
+export class QueryShapeSerializer extends SerdeContextConfig {
+    settings;
+    buffer;
+    constructor(settings) {
+        super();
+        this.settings = settings;
+    }
+    write(schema, value, prefix = "") {
+        if (this.buffer === undefined) {
+            this.buffer = "";
+        }
+        const ns = NormalizedSchema.of(schema);
+        if (prefix && !prefix.endsWith(".")) {
+            prefix += ".";
+        }
+        if (ns.isBlobSchema()) {
+            if (typeof value === "string" || value instanceof Uint8Array) {
+                this.writeKey(prefix);
+                this.writeValue((this.serdeContext?.base64Encoder ?? toBase64)(value));
+            }
+        }
+        else if (ns.isBooleanSchema() || ns.isNumericSchema() || ns.isStringSchema()) {
+            if (value != null) {
+                this.writeKey(prefix);
+                this.writeValue(String(value));
+            }
+        }
+        else if (ns.isBigIntegerSchema()) {
+            if (value != null) {
+                this.writeKey(prefix);
+                this.writeValue(String(value));
+            }
+        }
+        else if (ns.isBigDecimalSchema()) {
+            if (value != null) {
+                this.writeKey(prefix);
+                this.writeValue(value instanceof NumericValue ? value.string : String(value));
+            }
+        }
+        else if (ns.isTimestampSchema()) {
+            if (value instanceof Date) {
+                this.writeKey(prefix);
+                const format = determineTimestampFormat(ns, this.settings);
+                switch (format) {
+                    case SCHEMA.TIMESTAMP_DATE_TIME:
+                        this.writeValue(value.toISOString().replace(".000Z", "Z"));
+                        break;
+                    case SCHEMA.TIMESTAMP_HTTP_DATE:
+                        this.writeValue(dateToUtcString(value));
+                        break;
+                    case SCHEMA.TIMESTAMP_EPOCH_SECONDS:
+                        this.writeValue(String(value.getTime() / 1000));
+                        break;
+                }
+            }
+        }
+        else if (ns.isDocumentSchema()) {
+            throw new Error(`@aws-sdk/core/protocols - QuerySerializer unsupported document type ${ns.getName(true)}`);
+        }
+        else if (ns.isListSchema()) {
+            if (Array.isArray(value)) {
+                if (value.length === 0) {
+                    if (this.settings.serializeEmptyLists) {
+                        this.writeKey(prefix);
+                        this.writeValue("");
+                    }
+                }
+                else {
+                    const member = ns.getValueSchema();
+                    const flat = this.settings.flattenLists || ns.getMergedTraits().xmlFlattened;
+                    let i = 1;
+                    for (const item of value) {
+                        if (item == null) {
+                            continue;
+                        }
+                        const suffix = this.getKey("member", member.getMergedTraits().xmlName);
+                        const key = flat ? `${prefix}${i}` : `${prefix}${suffix}.${i}`;
+                        this.write(member, item, key);
+                        ++i;
+                    }
+                }
+            }
+        }
+        else if (ns.isMapSchema()) {
+            if (value && typeof value === "object") {
+                const keySchema = ns.getKeySchema();
+                const memberSchema = ns.getValueSchema();
+                const flat = ns.getMergedTraits().xmlFlattened;
+                let i = 1;
+                for (const [k, v] of Object.entries(value)) {
+                    if (v == null) {
+                        continue;
+                    }
+                    const keySuffix = this.getKey("key", keySchema.getMergedTraits().xmlName);
+                    const key = flat ? `${prefix}${i}.${keySuffix}` : `${prefix}entry.${i}.${keySuffix}`;
+                    const valueSuffix = this.getKey("value", memberSchema.getMergedTraits().xmlName);
+                    const valueKey = flat ? `${prefix}${i}.${valueSuffix}` : `${prefix}entry.${i}.${valueSuffix}`;
+                    this.write(keySchema, k, key);
+                    this.write(memberSchema, v, valueKey);
+                    ++i;
+                }
+            }
+        }
+        else if (ns.isStructSchema()) {
+            if (value && typeof value === "object") {
+                for (const [memberName, member] of ns.structIterator()) {
+                    if (value[memberName] == null) {
+                        continue;
+                    }
+                    const suffix = this.getKey(memberName, member.getMergedTraits().xmlName);
+                    const key = `${prefix}${suffix}`;
+                    this.write(member, value[memberName], key);
+                }
+            }
+        }
+        else if (ns.isUnitSchema()) {
+        }
+        else {
+            throw new Error(`@aws-sdk/core/protocols - QuerySerializer unrecognized schema type ${ns.getName(true)}`);
+        }
+    }
+    flush() {
+        if (this.buffer === undefined) {
+            throw new Error("@aws-sdk/core/protocols - QuerySerializer cannot flush with nothing written to buffer.");
+        }
+        const str = this.buffer;
+        delete this.buffer;
+        return str;
+    }
+    getKey(memberName, xmlName) {
+        const key = xmlName ?? memberName;
+        if (this.settings.capitalizeKeys) {
+            return key[0].toUpperCase() + key.slice(1);
+        }
+        return key;
+    }
+    writeKey(key) {
+        if (key.endsWith(".")) {
+            key = key.slice(0, key.length - 1);
+        }
+        this.buffer += `&${extendedEncodeURIComponent(key)}=`;
+    }
+    writeValue(value) {
+        this.buffer += extendedEncodeURIComponent(value);
+    }
+}

package/node_modules/@aws-sdk/core/dist-es/submodules/protocols/xml/AwsRestXmlProtocol.js

@@ -0,0 +1,126 @@
+import { HttpBindingProtocol, HttpInterceptingShapeDeserializer, HttpInterceptingShapeSerializer, } from "@smithy/core/protocols";
+import { NormalizedSchema, SCHEMA, TypeRegistry } from "@smithy/core/schema";
+import { calculateBodyLength } from "@smithy/util-body-length-browser";
+import { loadRestXmlErrorCode } from "./parseXmlBody";
+import { XmlCodec } from "./XmlCodec";
+export class AwsRestXmlProtocol extends HttpBindingProtocol {
+    codec;
+    serializer;
+    deserializer;
+    constructor(options) {
+        super(options);
+        const settings = {
+            timestampFormat: {
+                useTrait: true,
+                default: SCHEMA.TIMESTAMP_DATE_TIME,
+            },
+            httpBindings: true,
+            xmlNamespace: options.xmlNamespace,
+            serviceNamespace: options.defaultNamespace,
+        };
+        this.codec = new XmlCodec(settings);
+        this.serializer = new HttpInterceptingShapeSerializer(this.codec.createSerializer(), settings);
+        this.deserializer = new HttpInterceptingShapeDeserializer(this.codec.createDeserializer(), settings);
+    }
+    getPayloadCodec() {
+        return this.codec;
+    }
+    getShapeId() {
+        return "aws.protocols#restXml";
+    }
+    async serializeRequest(operationSchema, input, context) {
+        const request = await super.serializeRequest(operationSchema, input, context);
+        const ns = NormalizedSchema.of(operationSchema.input);
+        const members = ns.getMemberSchemas();
+        request.path =
+            String(request.path)
+                .split("/")
+                .filter((segment) => {
+                return segment !== "{Bucket}";
+            })
+                .join("/") || "/";
+        if (!request.headers["content-type"]) {
+            const httpPayloadMember = Object.values(members).find((m) => {
+                return !!m.getMergedTraits().httpPayload;
+            });
+            if (httpPayloadMember) {
+                const mediaType = httpPayloadMember.getMergedTraits().mediaType;
+                if (mediaType) {
+                    request.headers["content-type"] = mediaType;
+                }
+                else if (httpPayloadMember.isStringSchema()) {
+                    request.headers["content-type"] = "text/plain";
+                }
+                else if (httpPayloadMember.isBlobSchema()) {
+                    request.headers["content-type"] = "application/octet-stream";
+                }
+                else {
+                    request.headers["content-type"] = "application/xml";
+                }
+            }
+            else if (!ns.isUnitSchema()) {
+                const hasBody = Object.values(members).find((m) => {
+                    const { httpQuery, httpQueryParams, httpHeader, httpLabel, httpPrefixHeaders } = m.getMergedTraits();
+                    return !httpQuery && !httpQueryParams && !httpHeader && !httpLabel && httpPrefixHeaders === void 0;
+                });
+                if (hasBody) {
+                    request.headers["content-type"] = "application/xml";
+                }
+            }
+        }
+        if (request.headers["content-type"] === "application/xml") {
+            if (typeof request.body === "string") {
+                request.body = '<?xml version="1.0" encoding="UTF-8"?>' + request.body;
+            }
+        }
+        if (request.body) {
+            try {
+                request.headers["content-length"] = String(calculateBodyLength(request.body));
+            }
+            catch (e) { }
+        }
+        return request;
+    }
+    async deserializeResponse(operationSchema, context, response) {
+        return super.deserializeResponse(operationSchema, context, response);
+    }
+    async handleError(operationSchema, context, response, dataObject, metadata) {
+        const errorIdentifier = loadRestXmlErrorCode(response, dataObject) ?? "Unknown";
+        let namespace = this.options.defaultNamespace;
+        let errorName = errorIdentifier;
+        if (errorIdentifier.includes("#")) {
+            [namespace, errorName] = errorIdentifier.split("#");
+        }
+        const registry = TypeRegistry.for(namespace);
+        let errorSchema;
+        try {
+            errorSchema = registry.getSchema(errorIdentifier);
+        }
+        catch (e) {
+            const baseExceptionSchema = TypeRegistry.for("smithy.ts.sdk.synthetic." + namespace).getBaseException();
+            if (baseExceptionSchema) {
+                const ErrorCtor = baseExceptionSchema.ctor;
+                throw Object.assign(new ErrorCtor(errorName), dataObject);
+            }
+            throw new Error(errorName);
+        }
+        const ns = NormalizedSchema.of(errorSchema);
+        const message = dataObject.Error?.message ?? dataObject.Error?.Message ?? dataObject.message ?? dataObject.Message ?? "Unknown";
+        const exception = new errorSchema.ctor(message);
+        await this.deserializeHttpMessage(errorSchema, context, response, dataObject);
+        const output = {};
+        for (const [name, member] of ns.structIterator()) {
+            const target = member.getMergedTraits().xmlName ?? name;
+            const value = dataObject.Error?.[target] ?? dataObject[target];
+            output[name] = this.codec.createDeserializer().readSchema(member, value);
+        }
+        Object.assign(exception, {
+            $metadata: metadata,
+            $response: response,
+            $fault: ns.getMergedTraits().error,
+            message,
+            ...output,
+        });
+        throw exception;
+    }
+}

package/node_modules/@aws-sdk/core/dist-es/submodules/protocols/xml/XmlCodec.js

@@ -0,0 +1,20 @@
+import { SerdeContextConfig } from "../ConfigurableSerdeContext";
+import { XmlShapeDeserializer } from "./XmlShapeDeserializer";
+import { XmlShapeSerializer } from "./XmlShapeSerializer";
+export class XmlCodec extends SerdeContextConfig {
+    settings;
+    constructor(settings) {
+        super();
+        this.settings = settings;
+    }
+    createSerializer() {
+        const serializer = new XmlShapeSerializer(this.settings);
+        serializer.setSerdeContext(this.serdeContext);
+        return serializer;
+    }
+    createDeserializer() {
+        const deserializer = new XmlShapeDeserializer(this.settings);
+        deserializer.setSerdeContext(this.serdeContext);
+        return deserializer;
+    }
+}

package/node_modules/@aws-sdk/core/dist-es/submodules/protocols/xml/XmlShapeDeserializer.js

@@ -0,0 +1,154 @@
+import { FromStringShapeDeserializer } from "@smithy/core/protocols";
+import { NormalizedSchema } from "@smithy/core/schema";
+import { getValueFromTextNode } from "@smithy/smithy-client";
+import { toUtf8 } from "@smithy/util-utf8";
+import { XMLParser } from "fast-xml-parser";
+import { SerdeContextConfig } from "../ConfigurableSerdeContext";
+export class XmlShapeDeserializer extends SerdeContextConfig {
+    settings;
+    stringDeserializer;
+    constructor(settings) {
+        super();
+        this.settings = settings;
+        this.stringDeserializer = new FromStringShapeDeserializer(settings);
+    }
+    setSerdeContext(serdeContext) {
+        this.serdeContext = serdeContext;
+        this.stringDeserializer.setSerdeContext(serdeContext);
+    }
+    read(schema, bytes, key) {
+        const ns = NormalizedSchema.of(schema);
+        const memberSchemas = ns.getMemberSchemas();
+        const isEventPayload = ns.isStructSchema() &&
+            ns.isMemberSchema() &&
+            !!Object.values(memberSchemas).find((memberNs) => {
+                return !!memberNs.getMemberTraits().eventPayload;
+            });
+        if (isEventPayload) {
+            const output = {};
+            const memberName = Object.keys(memberSchemas)[0];
+            const eventMemberSchema = memberSchemas[memberName];
+            if (eventMemberSchema.isBlobSchema()) {
+                output[memberName] = bytes;
+            }
+            else {
+                output[memberName] = this.read(memberSchemas[memberName], bytes);
+            }
+            return output;
+        }
+        const xmlString = (this.serdeContext?.utf8Encoder ?? toUtf8)(bytes);
+        const parsedObject = this.parseXml(xmlString);
+        return this.readSchema(schema, key ? parsedObject[key] : parsedObject);
+    }
+    readSchema(_schema, value) {
+        const ns = NormalizedSchema.of(_schema);
+        const traits = ns.getMergedTraits();
+        const schema = ns.getSchema();
+        if (ns.isListSchema() && !Array.isArray(value)) {
+            return this.readSchema(schema, [value]);
+        }
+        if (value == null) {
+            return value;
+        }
+        if (typeof value === "object") {
+            const sparse = !!traits.sparse;
+            const flat = !!traits.xmlFlattened;
+            if (ns.isListSchema()) {
+                const listValue = ns.getValueSchema();
+                const buffer = [];
+                const sourceKey = listValue.getMergedTraits().xmlName ?? "member";
+                const source = flat ? value : (value[0] ?? value)[sourceKey];
+                const sourceArray = Array.isArray(source) ? source : [source];
+                for (const v of sourceArray) {
+                    if (v != null || sparse) {
+                        buffer.push(this.readSchema(listValue, v));
+                    }
+                }
+                return buffer;
+            }
+            const buffer = {};
+            if (ns.isMapSchema()) {
+                const keyNs = ns.getKeySchema();
+                const memberNs = ns.getValueSchema();
+                let entries;
+                if (flat) {
+                    entries = Array.isArray(value) ? value : [value];
+                }
+                else {
+                    entries = Array.isArray(value.entry) ? value.entry : [value.entry];
+                }
+                const keyProperty = keyNs.getMergedTraits().xmlName ?? "key";
+                const valueProperty = memberNs.getMergedTraits().xmlName ?? "value";
+                for (const entry of entries) {
+                    const key = entry[keyProperty];
+                    const value = entry[valueProperty];
+                    if (value != null || sparse) {
+                        buffer[key] = this.readSchema(memberNs, value);
+                    }
+                }
+                return buffer;
+            }
+            if (ns.isStructSchema()) {
+                for (const [memberName, memberSchema] of ns.structIterator()) {
+                    const memberTraits = memberSchema.getMergedTraits();
+                    const xmlObjectKey = !memberTraits.httpPayload
+                        ? memberSchema.getMemberTraits().xmlName ?? memberName
+                        : memberTraits.xmlName ?? memberSchema.getName();
+                    if (value[xmlObjectKey] != null) {
+                        buffer[memberName] = this.readSchema(memberSchema, value[xmlObjectKey]);
+                    }
+                }
+                return buffer;
+            }
+            if (ns.isDocumentSchema()) {
+                return value;
+            }
+            throw new Error(`@aws-sdk/core/protocols - xml deserializer unhandled schema type for ${ns.getName(true)}`);
+        }
+        else {
+            if (ns.isListSchema()) {
+                return [];
+            }
+            else if (ns.isMapSchema() || ns.isStructSchema()) {
+                return {};
+            }
+            return this.stringDeserializer.read(ns, value);
+        }
+    }
+    parseXml(xml) {
+        if (xml.length) {
+            const parser = new XMLParser({
+                attributeNamePrefix: "",
+                htmlEntities: true,
+                ignoreAttributes: false,
+                ignoreDeclaration: true,
+                parseTagValue: false,
+                trimValues: false,
+                tagValueProcessor: (_, val) => (val.trim() === "" && val.includes("\n") ? "" : undefined),
+            });
+            parser.addEntity("#xD", "\r");
+            parser.addEntity("#10", "\n");
+            let parsedObj;
+            try {
+                parsedObj = parser.parse(xml, true);
+            }
+            catch (e) {
+                if (e && typeof e === "object") {
+                    Object.defineProperty(e, "$responseBodyText", {
+                        value: xml,
+                    });
+                }
+                throw e;
+            }
+            const textNodeName = "#text";
+            const key = Object.keys(parsedObj)[0];
+            const parsedObjToReturn = parsedObj[key];
+            if (parsedObjToReturn[textNodeName]) {
+                parsedObjToReturn[key] = parsedObjToReturn[textNodeName];
+                delete parsedObjToReturn[textNodeName];
+            }
+            return getValueFromTextNode(parsedObjToReturn);
+        }
+        return {};
+    }
+}