@cdklabs/cdk-ecs-codedeploy 0.0.421 → 0.0.423

package/node_modules/@smithy/core/dist-es/index.js

@@ -3,6 +3,6 @@ export * from "./middleware-http-auth-scheme";
 export * from "./middleware-http-signing";
 export * from "./normalizeProvider";
 export { createPaginator } from "./pagination/createPaginator";
-export * from "./protocols/requestBuilder";
+export * from "./request-builder/requestBuilder";
 export * from "./setFeature";
 export * from "./util-identity-and-auth";

package/node_modules/@smithy/core/dist-es/middleware-http-auth-scheme/httpAuthSchemeMiddleware.js

@@ -1,4 +1,3 @@
-import { SMITHY_CONTEXT_KEY, } from "@smithy/types";
 import { getSmithyContext } from "@smithy/util-middleware";
 import { resolveAuthOptions } from "./resolveAuthOptions";
 function convertHttpAuthSchemesToMap(httpAuthSchemes) {

package/node_modules/@smithy/core/dist-es/middleware-http-signing/httpSigningMiddleware.js

@@ -1,5 +1,4 @@
 import { HttpRequest } from "@smithy/protocol-http";
-import { SMITHY_CONTEXT_KEY, } from "@smithy/types";
 import { getSmithyContext } from "@smithy/util-middleware";
 const defaultErrorHandler = (signingProperties) => (error) => {
     throw error;

package/node_modules/@smithy/core/dist-es/submodules/cbor/CborCodec.js

@@ -1,8 +1,11 @@
+import { SerdeContext } from "@smithy/core/protocols";
 import { NormalizedSchema } from "@smithy/core/schema";
-import { copyDocumentWithTransform, parseEpochTimestamp } from "@smithy/core/serde";
+import { _parseEpochTimestamp, generateIdempotencyToken } from "@smithy/core/serde";
+import { NumericValue } from "@smithy/core/serde";
+import { fromBase64 } from "@smithy/util-base64";
 import { cbor } from "./cbor";
 import { dateToTag } from "./parseCborBody";
-export class CborCodec {
+export class CborCodec extends SerdeContext {
     createSerializer() {
         const serializer = new CborShapeSerializer();
         serializer.setSerdeContext(this.serdeContext);
@@ -13,45 +16,80 @@ export class CborCodec {
         deserializer.setSerdeContext(this.serdeContext);
         return deserializer;
     }
-    setSerdeContext(serdeContext) {
-        this.serdeContext = serdeContext;
-    }
 }
-export class CborShapeSerializer {
-    setSerdeContext(serdeContext) {
-        this.serdeContext = serdeContext;
-    }
+export class CborShapeSerializer extends SerdeContext {
+    value;
     write(schema, value) {
-        this.value = copyDocumentWithTransform(value, schema, (_, schemaRef) => {
-            if (_ instanceof Date) {
-                return dateToTag(_);
-            }
-            if (_ instanceof Uint8Array) {
-                return _;
-            }
-            const ns = NormalizedSchema.of(schemaRef);
-            const sparse = !!ns.getMergedTraits().sparse;
-            if (ns.isListSchema() && Array.isArray(_)) {
-                if (!sparse) {
-                    return _.filter((item) => item != null);
+        this.value = this.serialize(schema, value);
+    }
+    serialize(schema, source) {
+        const ns = NormalizedSchema.of(schema);
+        if (source == null) {
+            if (ns.isIdempotencyToken()) {
+                return generateIdempotencyToken();
+            }
+            return source;
+        }
+        if (ns.isBlobSchema()) {
+            if (typeof source === "string") {
+                return (this.serdeContext?.base64Decoder ?? fromBase64)(source);
+            }
+            return source;
+        }
+        if (ns.isTimestampSchema()) {
+            if (typeof source === "number" || typeof source === "bigint") {
+                return dateToTag(new Date((Number(source) / 1000) | 0));
+            }
+            return dateToTag(source);
+        }
+        if (typeof source === "function" || typeof source === "object") {
+            const sourceObject = source;
+            if (ns.isListSchema() && Array.isArray(sourceObject)) {
+                const sparse = !!ns.getMergedTraits().sparse;
+                const newArray = [];
+                let i = 0;
+                for (const item of sourceObject) {
+                    const value = this.serialize(ns.getValueSchema(), item);
+                    if (value != null || sparse) {
+                        newArray[i++] = value;
+                    }
                 }
+                return newArray;
+            }
+            if (sourceObject instanceof Date) {
+                return dateToTag(sourceObject);
             }
-            else if (_ && typeof _ === "object") {
-                const members = ns.getMemberSchemas();
-                const isStruct = ns.isStructSchema();
-                if (!sparse || isStruct) {
-                    for (const [k, v] of Object.entries(_)) {
-                        const filteredOutByNonSparse = !sparse && v == null;
-                        const filteredOutByUnrecognizedMember = isStruct && !(k in members);
-                        if (filteredOutByNonSparse || filteredOutByUnrecognizedMember) {
-                            delete _[k];
-                        }
+            const newObject = {};
+            if (ns.isMapSchema()) {
+                const sparse = !!ns.getMergedTraits().sparse;
+                for (const key of Object.keys(sourceObject)) {
+                    const value = this.serialize(ns.getValueSchema(), sourceObject[key]);
+                    if (value != null || sparse) {
+                        newObject[key] = value;
                     }
-                    return _;
                 }
             }
-            return _;
-        });
+            else if (ns.isStructSchema()) {
+                for (const [key, memberSchema] of ns.structIterator()) {
+                    const value = this.serialize(memberSchema, sourceObject[key]);
+                    if (value != null) {
+                        newObject[key] = value;
+                    }
+                }
+                const isUnion = ns.isUnionSchema();
+                if (isUnion && Array.isArray(sourceObject.$unknown)) {
+                    const [k, v] = sourceObject.$unknown;
+                    newObject[k] = v;
+                }
+            }
+            else if (ns.isDocumentSchema()) {
+                for (const key of Object.keys(sourceObject)) {
+                    newObject[key] = this.serialize(ns.getValueSchema(), sourceObject[key]);
+                }
+            }
+            return newObject;
+        }
+        return source;
     }
     flush() {
         const buffer = cbor.serialize(this.value);
@@ -59,25 +97,29 @@ export class CborShapeSerializer {
         return buffer;
     }
 }
-export class CborShapeDeserializer {
-    setSerdeContext(serdeContext) {
-        this.serdeContext = serdeContext;
-    }
+export class CborShapeDeserializer extends SerdeContext {
     read(schema, bytes) {
         const data = cbor.deserialize(bytes);
         return this.readValue(schema, data);
     }
     readValue(_schema, value) {
         const ns = NormalizedSchema.of(_schema);
-        const schema = ns.getSchema();
-        if (typeof schema === "number") {
-            if (ns.isTimestampSchema()) {
-                return parseEpochTimestamp(value);
+        if (ns.isTimestampSchema()) {
+            if (typeof value === "number") {
+                return _parseEpochTimestamp(value);
             }
-            if (ns.isBlobSchema()) {
-                return value;
+            if (typeof value === "object") {
+                if (value.tag === 1 && "value" in value) {
+                    return _parseEpochTimestamp(value.value);
+                }
             }
         }
+        if (ns.isBlobSchema()) {
+            if (typeof value === "string") {
+                return (this.serdeContext?.base64Decoder ?? fromBase64)(value);
+            }
+            return value;
+        }
         if (typeof value === "undefined" ||
             typeof value === "boolean" ||
             typeof value === "number" ||
@@ -86,7 +128,7 @@ export class CborShapeDeserializer {
             typeof value === "symbol") {
             return value;
         }
-        else if (typeof value === "function" || typeof value === "object") {
+        else if (typeof value === "object") {
             if (value === null) {
                 return null;
             }
@@ -102,31 +144,48 @@ export class CborShapeDeserializer {
             if (ns.isListSchema()) {
                 const newArray = [];
                 const memberSchema = ns.getValueSchema();
-                const sparse = ns.isListSchema() && !!ns.getMergedTraits().sparse;
+                const sparse = !!ns.getMergedTraits().sparse;
                 for (const item of value) {
-                    newArray.push(this.readValue(memberSchema, item));
-                    if (!sparse && newArray[newArray.length - 1] == null) {
-                        newArray.pop();
+                    const itemValue = this.readValue(memberSchema, item);
+                    if (itemValue != null || sparse) {
+                        newArray.push(itemValue);
                     }
                 }
                 return newArray;
             }
             const newObject = {};
             if (ns.isMapSchema()) {
-                const sparse = ns.getMergedTraits().sparse;
+                const sparse = !!ns.getMergedTraits().sparse;
                 const targetSchema = ns.getValueSchema();
                 for (const key of Object.keys(value)) {
-                    newObject[key] = this.readValue(targetSchema, value[key]);
-                    if (newObject[key] == null && !sparse) {
-                        delete newObject[key];
+                    const itemValue = this.readValue(targetSchema, value[key]);
+                    if (itemValue != null || sparse) {
+                        newObject[key] = itemValue;
                     }
                 }
             }
             else if (ns.isStructSchema()) {
+                const isUnion = ns.isUnionSchema();
+                let keys;
+                if (isUnion) {
+                    keys = new Set(Object.keys(value).filter((k) => k !== "__type"));
+                }
                 for (const [key, memberSchema] of ns.structIterator()) {
-                    newObject[key] = this.readValue(memberSchema, value[key]);
+                    if (isUnion) {
+                        keys.delete(key);
+                    }
+                    if (value[key] != null) {
+                        newObject[key] = this.readValue(memberSchema, value[key]);
+                    }
+                }
+                if (isUnion && keys?.size === 1 && Object.keys(newObject).length === 0) {
+                    const k = keys.values().next().value;
+                    newObject.$unknown = [k, value[k]];
                 }
             }
+            else if (value instanceof NumericValue) {
+                return value;
+            }
             return newObject;
         }
         else {

package/node_modules/@smithy/core/dist-es/submodules/cbor/SmithyRpcV2CborProtocol.js

@@ -1,14 +1,14 @@
 import { RpcProtocol } from "@smithy/core/protocols";
-import { deref, TypeRegistry } from "@smithy/core/schema";
+import { deref, NormalizedSchema, TypeRegistry } from "@smithy/core/schema";
 import { getSmithyContext } from "@smithy/util-middleware";
 import { CborCodec } from "./CborCodec";
 import { loadSmithyRpcV2CborErrorCode } from "./parseCborBody";
 export class SmithyRpcV2CborProtocol extends RpcProtocol {
+    codec = new CborCodec();
+    serializer = this.codec.createSerializer();
+    deserializer = this.codec.createDeserializer();
     constructor({ defaultNamespace }) {
         super({ defaultNamespace });
-        this.codec = new CborCodec();
-        this.serializer = this.codec.createSerializer();
-        this.deserializer = this.codec.createDeserializer();
     }
     getShapeId() {
         return "smithy.protocols#rpcv2Cbor";
@@ -19,9 +19,9 @@ export class SmithyRpcV2CborProtocol extends RpcProtocol {
     async serializeRequest(operationSchema, input, context) {
         const request = await super.serializeRequest(operationSchema, input, context);
         Object.assign(request.headers, {
-            "content-type": "application/cbor",
+            "content-type": this.getDefaultContentType(),
             "smithy-protocol": "rpc-v2-cbor",
-            accept: "application/cbor",
+            accept: this.getDefaultContentType(),
         });
         if (deref(operationSchema.input) === "unit") {
             delete request.body;
@@ -51,24 +51,46 @@ export class SmithyRpcV2CborProtocol extends RpcProtocol {
         return super.deserializeResponse(operationSchema, context, response);
     }
     async handleError(operationSchema, context, response, dataObject, metadata) {
-        const error = loadSmithyRpcV2CborErrorCode(response, dataObject) ?? "Unknown";
+        const errorName = loadSmithyRpcV2CborErrorCode(response, dataObject) ?? "Unknown";
         let namespace = this.options.defaultNamespace;
-        if (error.includes("#")) {
-            [namespace] = error.split("#");
+        if (errorName.includes("#")) {
+            [namespace] = errorName.split("#");
         }
+        const errorMetadata = {
+            $metadata: metadata,
+            $fault: response.statusCode <= 500 ? "client" : "server",
+        };
         const registry = TypeRegistry.for(namespace);
-        const errorSchema = registry.getSchema(error);
-        if (!errorSchema) {
-            throw new Error("schema not found for " + error);
+        let errorSchema;
+        try {
+            errorSchema = registry.getSchema(errorName);
+        }
+        catch (e) {
+            if (dataObject.Message) {
+                dataObject.message = dataObject.Message;
+            }
+            const synthetic = TypeRegistry.for("smithy.ts.sdk.synthetic." + namespace);
+            const baseExceptionSchema = synthetic.getBaseException();
+            if (baseExceptionSchema) {
+                const ErrorCtor = synthetic.getErrorCtor(baseExceptionSchema);
+                throw Object.assign(new ErrorCtor({ name: errorName }), errorMetadata, dataObject);
+            }
+            throw Object.assign(new Error(errorName), errorMetadata, dataObject);
         }
+        const ns = NormalizedSchema.of(errorSchema);
+        const ErrorCtor = registry.getErrorCtor(errorSchema);
         const message = dataObject.message ?? dataObject.Message ?? "Unknown";
-        const exception = new errorSchema.ctor(message);
-        Object.assign(exception, {
-            $metadata: metadata,
-            $response: response,
+        const exception = new ErrorCtor(message);
+        const output = {};
+        for (const [name, member] of ns.structIterator()) {
+            output[name] = this.deserializer.readValue(member, dataObject[name]);
+        }
+        throw Object.assign(exception, errorMetadata, {
+            $fault: ns.getMergedTraits().error,
             message,
-            ...dataObject,
-        });
-        throw exception;
+        }, output);
+    }
+    getDefaultContentType() {
+        return "application/cbor";
     }
 }

package/node_modules/@smithy/core/dist-es/submodules/cbor/byte-printer.js

@@ -1,3 +1,37 @@
 export function printBytes(bytes) {
-    return [...bytes].map((n) => ("0".repeat(8) + n.toString(2)).slice(-8) + ` (${n})`);
+    return [...bytes].map((n) => {
+        const pad = (num) => ("0".repeat(8) + num.toString(2)).slice(-8);
+        const b = pad(n);
+        const [maj, min] = [b.slice(0, 3), b.slice(3)];
+        let dmaj = "";
+        switch (maj) {
+            case "000":
+                dmaj = "0 - Uint64";
+                break;
+            case "001":
+                dmaj = "1 - Neg Uint64";
+                break;
+            case "010":
+                dmaj = "2 - unstructured bytestring";
+                break;
+            case "011":
+                dmaj = "3 - utf8 string";
+                break;
+            case "100":
+                dmaj = "4 - list";
+                break;
+            case "101":
+                dmaj = "5 - map";
+                break;
+            case "110":
+                dmaj = "6 - tag";
+                break;
+            case "111":
+                dmaj = "7 - special";
+                break;
+            default:
+                dmaj = String(parseInt(maj, 2));
+        }
+        return `${maj}_${min} (${dmaj}, ${parseInt(min, 2)})`;
+    });
 }

package/node_modules/@smithy/core/dist-es/submodules/cbor/cbor-decode.js

@@ -15,8 +15,8 @@ export function decode(at, to) {
     if (at >= to) {
         throw new Error("unexpected end of (decode) payload.");
     }
-    const major = (payload[at] & 224) >> 5;
-    const minor = payload[at] & 31;
+    const major = (payload[at] & 0b1110_0000) >> 5;
+    const minor = payload[at] & 0b0001_1111;
     switch (major) {
         case majorUint64:
         case majorNegativeInt64:
@@ -168,13 +168,13 @@ const minorValueToArgumentLength = {
 };
 export function bytesToFloat16(a, b) {
     const sign = a >> 7;
-    const exponent = (a & 124) >> 2;
-    const fraction = ((a & 3) << 8) | b;
+    const exponent = (a & 0b0111_1100) >> 2;
+    const fraction = ((a & 0b0000_0011) << 8) | b;
     const scalar = sign === 0 ? 1 : -1;
     let exponentComponent;
     let summation;
     if (exponent === 0b00000) {
-        if (fraction === 0) {
+        if (fraction === 0b00000_00000) {
             return 0;
         }
         else {
@@ -183,7 +183,7 @@ export function bytesToFloat16(a, b) {
         }
     }
     else if (exponent === 0b11111) {
-        if (fraction === 0) {
+        if (fraction === 0b00000_00000) {
             return scalar * Infinity;
         }
         else {
@@ -198,7 +198,7 @@ export function bytesToFloat16(a, b) {
     return scalar * (exponentComponent * summation);
 }
 function decodeCount(at, to) {
-    const minor = payload[at] & 31;
+    const minor = payload[at] & 0b0001_1111;
     if (minor < 24) {
         _offset = 1;
         return minor;
@@ -241,14 +241,14 @@ function decodeUtf8StringIndefinite(at, to) {
     at += 1;
     const vector = [];
     for (const base = at; at < to;) {
-        if (payload[at] === 255) {
+        if (payload[at] === 0b1111_1111) {
             const data = alloc(vector.length);
             data.set(vector, 0);
             _offset = at - base + 2;
             return bytesToUtf8(data, 0, data.length);
         }
-        const major = (payload[at] & 224) >> 5;
-        const minor = payload[at] & 31;
+        const major = (payload[at] & 0b1110_0000) >> 5;
+        const minor = payload[at] & 0b0001_1111;
         if (major !== majorUtf8String) {
             throw new Error(`unexpected major type ${major} in indefinite string.`);
         }
@@ -279,14 +279,14 @@ function decodeUnstructuredByteStringIndefinite(at, to) {
     at += 1;
     const vector = [];
     for (const base = at; at < to;) {
-        if (payload[at] === 255) {
+        if (payload[at] === 0b1111_1111) {
             const data = alloc(vector.length);
             data.set(vector, 0);
             _offset = at - base + 2;
             return data;
         }
-        const major = (payload[at] & 224) >> 5;
-        const minor = payload[at] & 31;
+        const major = (payload[at] & 0b1110_0000) >> 5;
+        const minor = payload[at] & 0b0001_1111;
         if (major !== majorUnstructuredByteString) {
             throw new Error(`unexpected major type ${major} in indefinite string.`);
         }
@@ -321,7 +321,7 @@ function decodeListIndefinite(at, to) {
     at += 1;
     const list = [];
     for (const base = at; at < to;) {
-        if (payload[at] === 255) {
+        if (payload[at] === 0b1111_1111) {
             _offset = at - base + 2;
             return list;
         }
@@ -342,7 +342,7 @@ function decodeMap(at, to) {
         if (at >= to) {
             throw new Error("unexpected end of map payload.");
         }
-        const major = (payload[at] & 224) >> 5;
+        const major = (payload[at] & 0b1110_0000) >> 5;
         if (major !== majorUtf8String) {
             throw new Error(`unexpected major type ${major} for map key at index ${at}.`);
         }
@@ -363,11 +363,11 @@ function decodeMapIndefinite(at, to) {
         if (at >= to) {
             throw new Error("unexpected end of map payload.");
         }
-        if (payload[at] === 255) {
+        if (payload[at] === 0b1111_1111) {
             _offset = at - base + 2;
             return map;
         }
-        const major = (payload[at] & 224) >> 5;
+        const major = (payload[at] & 0b1110_0000) >> 5;
         if (major !== majorUtf8String) {
             throw new Error(`unexpected major type ${major} for map key.`);
         }
@@ -380,7 +380,7 @@ function decodeMapIndefinite(at, to) {
     throw new Error("expected break marker.");
 }
 function decodeSpecial(at, to) {
-    const minor = payload[at] & 31;
+    const minor = payload[at] & 0b0001_1111;
     switch (minor) {
         case specialTrue:
         case specialFalse:

package/node_modules/@smithy/core/dist-es/submodules/cbor/cbor-encode.js

@@ -9,11 +9,11 @@ let cursor = 0;
 function ensureSpace(bytes) {
     const remaining = data.byteLength - cursor;
     if (remaining < bytes) {
-        if (cursor < 16000000) {
+        if (cursor < 16_000_000) {
             resize(Math.max(data.byteLength * 4, data.byteLength + bytes));
         }
         else {
-            resize(data.byteLength + bytes + 16000000);
+            resize(data.byteLength + bytes + 16_000_000);
         }
     }
 }
@@ -127,7 +127,7 @@ export function encode(_input) {
             else if (n < 65536) {
                 data[cursor++] = (major << 5) | extendedFloat16;
                 data[cursor++] = n >> 8;
-                data[cursor++] = n & 255;
+                data[cursor++] = n & 0b1111_1111;
             }
             else if (n < 4294967296) {
                 data[cursor++] = (major << 5) | extendedFloat32;
@@ -149,7 +149,7 @@ export function encode(_input) {
                     b >>= BigInt(8);
                 }
                 ensureSpace(bigIntBytes.byteLength * 2);
-                data[cursor++] = nonNegative ? 194 : 195;
+                data[cursor++] = nonNegative ? 0b110_00010 : 0b110_00011;
                 if (USE_BUFFER) {
                     encodeHeader(majorUnstructuredByteString, Buffer.byteLength(bigIntBytes));
                 }
@@ -191,7 +191,7 @@ export function encode(_input) {
                 const decimalIndex = input.string.indexOf(".");
                 const exponent = decimalIndex === -1 ? 0 : decimalIndex - input.string.length + 1;
                 const mantissa = BigInt(input.string.replace(".", ""));
-                data[cursor++] = 196;
+                data[cursor++] = 0b110_00100;
                 encodeStack.push(mantissa);
                 encodeStack.push(exponent);
                 encodeHeader(majorList, 2);

package/node_modules/@smithy/core/dist-es/submodules/cbor/parseCborBody.js

@@ -2,7 +2,7 @@ import { collectBody } from "@smithy/core/protocols";
 import { HttpRequest as __HttpRequest } from "@smithy/protocol-http";
 import { calculateBodyLength } from "@smithy/util-body-length-browser";
 import { cbor } from "./cbor";
-import { tag, tagSymbol } from "./cbor-types";
+import { tag } from "./cbor-types";
 export const parseCborBody = (streamBody, context) => {
     return collectBody(streamBody, context).then(async (bytes) => {
         if (bytes.length) {