@jjrawlins/cdk-iam-policy-builder-helper 0.0.58 → 0.0.59

package/node_modules/@smithy/core/dist-cjs/submodules/schema/index.js

@@ -10,6 +10,113 @@ const deref = (schemaRef) => {
     return schemaRef;
 };
 
+const operation = (namespace, name, traits, input, output) => ({
+    name,
+    namespace,
+    traits,
+    input,
+    output,
+});
+
+const schemaDeserializationMiddleware = (config) => (next, context) => async (args) => {
+    const { response } = await next(args);
+    const { operationSchema } = utilMiddleware.getSmithyContext(context);
+    const [, ns, n, t, i, o] = operationSchema ?? [];
+    try {
+        const parsed = await config.protocol.deserializeResponse(operation(ns, n, t, i, o), {
+            ...config,
+            ...context,
+        }, response);
+        return {
+            response,
+            output: parsed,
+        };
+    }
+    catch (error) {
+        Object.defineProperty(error, "$response", {
+            value: response,
+        });
+        if (!("$metadata" in error)) {
+            const hint = `Deserialization error: to see the raw response, inspect the hidden field {error}.$response on this object.`;
+            try {
+                error.message += "\n  " + hint;
+            }
+            catch (e) {
+                if (!context.logger || context.logger?.constructor?.name === "NoOpLogger") {
+                    console.warn(hint);
+                }
+                else {
+                    context.logger?.warn?.(hint);
+                }
+            }
+            if (typeof error.$responseBodyText !== "undefined") {
+                if (error.$response) {
+                    error.$response.body = error.$responseBodyText;
+                }
+            }
+            try {
+                if (protocolHttp.HttpResponse.isInstance(response)) {
+                    const { headers = {} } = response;
+                    const headerEntries = Object.entries(headers);
+                    error.$metadata = {
+                        httpStatusCode: response.statusCode,
+                        requestId: findHeader(/^x-[\w-]+-request-?id$/, headerEntries),
+                        extendedRequestId: findHeader(/^x-[\w-]+-id-2$/, headerEntries),
+                        cfId: findHeader(/^x-[\w-]+-cf-id$/, headerEntries),
+                    };
+                }
+            }
+            catch (e) {
+            }
+        }
+        throw error;
+    }
+};
+const findHeader = (pattern, headers) => {
+    return (headers.find(([k]) => {
+        return k.match(pattern);
+    }) || [void 0, void 0])[1];
+};
+
+const schemaSerializationMiddleware = (config) => (next, context) => async (args) => {
+    const { operationSchema } = utilMiddleware.getSmithyContext(context);
+    const [, ns, n, t, i, o] = operationSchema ?? [];
+    const endpoint = context.endpointV2?.url && config.urlParser
+        ? async () => config.urlParser(context.endpointV2.url)
+        : config.endpoint;
+    const request = await config.protocol.serializeRequest(operation(ns, n, t, i, o), args.input, {
+        ...config,
+        ...context,
+        endpoint,
+    });
+    return next({
+        ...args,
+        request,
+    });
+};
+
+const deserializerMiddlewareOption = {
+    name: "deserializerMiddleware",
+    step: "deserialize",
+    tags: ["DESERIALIZER"],
+    override: true,
+};
+const serializerMiddlewareOption = {
+    name: "serializerMiddleware",
+    step: "serialize",
+    tags: ["SERIALIZER"],
+    override: true,
+};
+function getSchemaSerdePlugin(config) {
+    return {
+        applyToStack: (commandStack) => {
+            commandStack.add(schemaSerializationMiddleware(config), serializerMiddlewareOption);
+            commandStack.add(schemaDeserializationMiddleware(config), deserializerMiddlewareOption);
+            config.protocol.setSerdeContext(config);
+        },
+    };
+}
+
 class Schema {
     name;
     namespace;
@@ -31,36 +138,6 @@ class Schema {
     }
 }
 
-class StructureSchema extends Schema {
-    static symbol = Symbol.for("@smithy/str");
-    name;
-    traits;
-    memberNames;
-    memberList;
-    symbol = StructureSchema.symbol;
-}
-const struct = (namespace, name, traits, memberNames, memberList) => Schema.assign(new StructureSchema(), {
-    name,
-    namespace,
-    traits,
-    memberNames,
-    memberList,
-});
-
-class ErrorSchema extends StructureSchema {
-    static symbol = Symbol.for("@smithy/err");
-    ctor;
-    symbol = ErrorSchema.symbol;
-}
-const error = (namespace, name, traits, memberNames, memberList, ctor) => Schema.assign(new ErrorSchema(), {
-    name,
-    namespace,
-    traits,
-    memberNames,
-    memberList,
-    ctor: null,
-});
-
 class ListSchema extends Schema {
     static symbol = Symbol.for("@smithy/lis");
     name;
@@ -107,24 +184,34 @@ const op = (namespace, name, traits, input, output) => Schema.assign(new Operati
     output,
 });
 
-class SimpleSchema extends Schema {
-    static symbol = Symbol.for("@smithy/sim");
+class StructureSchema extends Schema {
+    static symbol = Symbol.for("@smithy/str");
     name;
-    schemaRef;
     traits;
-    symbol = SimpleSchema.symbol;
+    memberNames;
+    memberList;
+    symbol = StructureSchema.symbol;
 }
-const sim = (namespace, name, schemaRef, traits) => Schema.assign(new SimpleSchema(), {
+const struct = (namespace, name, traits, memberNames, memberList) => Schema.assign(new StructureSchema(), {
     name,
     namespace,
     traits,
-    schemaRef,
+    memberNames,
+    memberList,
 });
-const simAdapter = (namespace, name, traits, schemaRef) => Schema.assign(new SimpleSchema(), {
+
+class ErrorSchema extends StructureSchema {
+    static symbol = Symbol.for("@smithy/err");
+    ctor;
+    symbol = ErrorSchema.symbol;
+}
+const error = (namespace, name, traits, memberNames, memberList, ctor) => Schema.assign(new ErrorSchema(), {
     name,
     namespace,
     traits,
-    schemaRef,
+    memberNames,
+    memberList,
+    ctor: null,
 });
 
 function translateTraits(indicator) {
@@ -174,8 +261,6 @@ class NormalizedSchema {
             schema = deref(_ref);
             this._isMemberSchema = true;
         }
-        if (isStaticSchema(schema))
-            schema = hydrate(schema);
         if (traitStack.length > 0) {
             this.memberTraits = {};
             for (let i = traitStack.length - 1; i >= 0; --i) {
@@ -195,19 +280,25 @@ class NormalizedSchema {
             return;
         }
         this.schema = deref(schema);
-        if (this.schema && typeof this.schema === "object") {
-            this.traits = this.schema?.traits ?? {};
+        if (isStaticSchema(this.schema)) {
+            this.name = `${this.schema[1]}#${this.schema[2]}`;
+            this.traits = this.schema[3];
         }
         else {
+            this.name = this.memberName ?? String(schema);
             this.traits = 0;
         }
-        this.name = (this.schema instanceof Schema ? this.schema.getName?.() : void 0) ?? this.memberName ?? String(schema);
         if (this._isMemberSchema && !memberName) {
             throw new Error(`@smithy/core/schema - NormalizedSchema member init ${this.getName(true)} missing member name.`);
         }
     }
     static [Symbol.hasInstance](lhs) {
-        return Schema[Symbol.hasInstance].bind(this)(lhs);
+        const isPrototype = this.prototype.isPrototypeOf(lhs);
+        if (!isPrototype && typeof lhs === "object" && lhs !== null) {
+            const ns = lhs;
+            return ns.symbol === this.symbol;
+        }
+        return isPrototype;
     }
     static of(ref) {
         const sc = deref(ref);
@@ -225,7 +316,11 @@ class NormalizedSchema {
         return new NormalizedSchema(sc);
     }
     getSchema() {
-        return deref(this.schema?.schemaRef ?? this.schema);
+        const sc = this.schema;
+        if (sc[0] === 0) {
+            return sc[4];
+        }
+        return sc;
     }
     getName(withNamespace = false) {
         const { name } = this;
@@ -242,17 +337,18 @@ class NormalizedSchema {
         const sc = this.getSchema();
         return typeof sc === "number"
             ? sc >= 64 && sc < 128
-            : sc instanceof ListSchema;
+            : sc[0] === 1;
     }
     isMapSchema() {
         const sc = this.getSchema();
         return typeof sc === "number"
             ? sc >= 128 && sc <= 0b1111_1111
-            : sc instanceof MapSchema;
+            : sc[0] === 2;
     }
     isStructSchema() {
         const sc = this.getSchema();
-        return (sc !== null && typeof sc === "object" && "members" in sc) || sc instanceof StructureSchema;
+        return (sc[0] === 3 ||
+            sc[0] === -3);
     }
     isBlobSchema() {
         const sc = this.getSchema();
@@ -316,7 +412,7 @@ class NormalizedSchema {
         const schema = this.getSchema();
         const memberSchema = isDoc
             ? 15
-            : schema?.keySchema ?? 0;
+            : schema[4] ?? 0;
         return member([memberSchema, 0], "key");
     }
     getValueSchema() {
@@ -325,7 +421,7 @@ class NormalizedSchema {
         const memberSchema = typeof sc === "number"
             ? 0b0011_1111 & sc
             : sc && typeof sc === "object" && (isMap || isList)
-                ? sc.valueSchema
+                ? sc[3 + sc[0]]
                 : isDoc
                     ? 15
                     : void 0;
@@ -336,9 +432,9 @@ class NormalizedSchema {
     }
     getMemberSchema(memberName) {
         const struct = this.getSchema();
-        if (this.isStructSchema() && struct.memberNames.includes(memberName)) {
-            const i = struct.memberNames.indexOf(memberName);
-            const memberSchema = struct.memberList[i];
+        if (this.isStructSchema() && struct[4].includes(memberName)) {
+            const i = struct[4].indexOf(memberName);
+            const memberSchema = struct[5][i];
             return member(isMemberSchema(memberSchema) ? memberSchema : [memberSchema, 0], memberName);
         }
         if (this.isDocumentSchema()) {
@@ -374,8 +470,8 @@ class NormalizedSchema {
             throw new Error("@smithy/core/schema - cannot iterate non-struct schema.");
         }
         const struct = this.getSchema();
-        for (let i = 0; i < struct.memberNames.length; ++i) {
-            yield [struct.memberNames[i], member([struct.memberList[i], 0], struct.memberNames[i])];
+        for (let i = 0; i < struct[4].length; ++i) {
+            yield [struct[4][i], member([struct[5][i], 0], struct[4][i])];
         }
     }
 }
@@ -389,122 +485,28 @@ function member(memberSchema, memberName) {
     const internalCtorAccess = NormalizedSchema;
     return new internalCtorAccess(memberSchema, memberName);
 }
-function hydrate(ss) {
-    const [id, ...rest] = ss;
-    return {
-        [0]: simAdapter,
-        [1]: list,
-        [2]: map,
-        [3]: struct,
-        [-3]: error,
-        [9]: op,
-    }[id].call(null, ...rest);
-}
 const isMemberSchema = (sc) => Array.isArray(sc) && sc.length === 2;
 const isStaticSchema = (sc) => Array.isArray(sc) && sc.length >= 5;
 
-const schemaDeserializationMiddleware = (config) => (next, context) => async (args) => {
-    const { response } = await next(args);
-    let { operationSchema } = utilMiddleware.getSmithyContext(context);
-    if (isStaticSchema(operationSchema)) {
-        operationSchema = hydrate(operationSchema);
-    }
-    try {
-        const parsed = await config.protocol.deserializeResponse(operationSchema, {
-            ...config,
-            ...context,
-        }, response);
-        return {
-            response,
-            output: parsed,
-        };
-    }
-    catch (error) {
-        Object.defineProperty(error, "$response", {
-            value: response,
-        });
-        if (!("$metadata" in error)) {
-            const hint = `Deserialization error: to see the raw response, inspect the hidden field {error}.$response on this object.`;
-            try {
-                error.message += "\n  " + hint;
-            }
-            catch (e) {
-                if (!context.logger || context.logger?.constructor?.name === "NoOpLogger") {
-                    console.warn(hint);
-                }
-                else {
-                    context.logger?.warn?.(hint);
-                }
-            }
-            if (typeof error.$responseBodyText !== "undefined") {
-                if (error.$response) {
-                    error.$response.body = error.$responseBodyText;
-                }
-            }
-            try {
-                if (protocolHttp.HttpResponse.isInstance(response)) {
-                    const { headers = {} } = response;
-                    const headerEntries = Object.entries(headers);
-                    error.$metadata = {
-                        httpStatusCode: response.statusCode,
-                        requestId: findHeader(/^x-[\w-]+-request-?id$/, headerEntries),
-                        extendedRequestId: findHeader(/^x-[\w-]+-id-2$/, headerEntries),
-                        cfId: findHeader(/^x-[\w-]+-cf-id$/, headerEntries),
-                    };
-                }
-            }
-            catch (e) {
-            }
-        }
-        throw error;
-    }
-};
-const findHeader = (pattern, headers) => {
-    return (headers.find(([k]) => {
-        return k.match(pattern);
-    }) || [void 0, void 0])[1];
-};
-
-const schemaSerializationMiddleware = (config) => (next, context) => async (args) => {
-    let { operationSchema } = utilMiddleware.getSmithyContext(context);
-    if (isStaticSchema(operationSchema)) {
-        operationSchema = hydrate(operationSchema);
-    }
-    const endpoint = context.endpointV2?.url && config.urlParser
-        ? async () => config.urlParser(context.endpointV2.url)
-        : config.endpoint;
-    const request = await config.protocol.serializeRequest(operationSchema, args.input, {
-        ...config,
-        ...context,
-        endpoint,
-    });
-    return next({
-        ...args,
-        request,
-    });
-};
-
-const deserializerMiddlewareOption = {
-    name: "deserializerMiddleware",
-    step: "deserialize",
-    tags: ["DESERIALIZER"],
-    override: true,
-};
-const serializerMiddlewareOption = {
-    name: "serializerMiddleware",
-    step: "serialize",
-    tags: ["SERIALIZER"],
-    override: true,
-};
-function getSchemaSerdePlugin(config) {
-    return {
-        applyToStack: (commandStack) => {
-            commandStack.add(schemaSerializationMiddleware(config), serializerMiddlewareOption);
-            commandStack.add(schemaDeserializationMiddleware(config), deserializerMiddlewareOption);
-            config.protocol.setSerdeContext(config);
-        },
-    };
+class SimpleSchema extends Schema {
+    static symbol = Symbol.for("@smithy/sim");
+    name;
+    schemaRef;
+    traits;
+    symbol = SimpleSchema.symbol;
 }
+const sim = (namespace, name, schemaRef, traits) => Schema.assign(new SimpleSchema(), {
+    name,
+    namespace,
+    traits,
+    schemaRef,
+});
+const simAdapter = (namespace, name, traits, schemaRef) => Schema.assign(new SimpleSchema(), {
+    name,
+    namespace,
+    traits,
+    schemaRef,
+});
 
 const SCHEMA = {
     BLOB: 0b0001_0101,
@@ -560,7 +562,7 @@ class TypeRegistry {
     getErrorCtor(es) {
         const $error = es;
         const registry = TypeRegistry.for($error[1]);
-        return registry.exceptions.get(es);
+        return registry.exceptions.get($error);
     }
     getBaseException() {
         for (const exceptionKey of this.exceptions.keys()) {
@@ -603,11 +605,11 @@ exports.deref = deref;
 exports.deserializerMiddlewareOption = deserializerMiddlewareOption;
 exports.error = error;
 exports.getSchemaSerdePlugin = getSchemaSerdePlugin;
-exports.hydrate = hydrate;
 exports.isStaticSchema = isStaticSchema;
 exports.list = list;
 exports.map = map;
 exports.op = op;
+exports.operation = operation;
 exports.serializerMiddlewareOption = serializerMiddlewareOption;
 exports.sim = sim;
 exports.simAdapter = simAdapter;

package/node_modules/@smithy/core/dist-es/submodules/event-streams/EventStreamSerde.js

@@ -16,7 +16,6 @@ export class EventStreamSerde {
         const marshaller = this.marshaller;
         const eventStreamMember = requestSchema.getEventStreamMember();
         const unionSchema = requestSchema.getMemberSchema(eventStreamMember);
-        const memberSchemas = unionSchema.getMemberSchemas();
         const serializer = this.serializer;
         const defaultContentType = this.defaultContentType;
         const initialRequestMarker = Symbol("initialRequestMarker");
@@ -129,7 +128,7 @@ export class EventStreamSerde {
         let explicitPayloadContentType;
         const isKnownSchema = (() => {
             const struct = unionSchema.getSchema();
-            return struct.memberNames.includes(unionMember);
+            return struct[4].includes(unionMember);
         })();
         const additionalHeaders = {};
         if (!isKnownSchema) {

package/node_modules/@smithy/core/dist-es/submodules/protocols/HttpProtocol.js

@@ -1,4 +1,4 @@
-import { NormalizedSchema } from "@smithy/core/schema";
+import { NormalizedSchema, translateTraits } from "@smithy/core/schema";
 import { HttpRequest, HttpResponse } from "@smithy/protocol-http";
 import { SerdeContext } from "./SerdeContext";
 export class HttpProtocol extends SerdeContext {
@@ -50,10 +50,10 @@ export class HttpProtocol extends SerdeContext {
         }
     }
     setHostPrefix(request, operationSchema, input) {
-        const operationNs = NormalizedSchema.of(operationSchema);
         const inputNs = NormalizedSchema.of(operationSchema.input);
-        if (operationNs.getMergedTraits().endpoint) {
-            let hostPrefix = operationNs.getMergedTraits().endpoint?.[0];
+        const opTraits = translateTraits(operationSchema.traits ?? {});
+        if (opTraits.endpoint) {
+            let hostPrefix = opTraits.endpoint?.[0];
             if (typeof hostPrefix === "string") {
                 const hostLabelInputs = [...inputNs.structIterator()].filter(([, member]) => member.getMergedTraits().hostLabel);
                 for (const [name] of hostLabelInputs) {

package/node_modules/@smithy/core/dist-es/submodules/schema/TypeRegistry.js

@@ -35,7 +35,7 @@ export class TypeRegistry {
     getErrorCtor(es) {
         const $error = es;
         const registry = TypeRegistry.for($error[1]);
-        return registry.exceptions.get(es);
+        return registry.exceptions.get($error);
     }
     getBaseException() {
         for (const exceptionKey of this.exceptions.keys()) {

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

@@ -3,6 +3,7 @@ export * from "./middleware/getSchemaSerdePlugin";
 export * from "./schemas/ListSchema";
 export * from "./schemas/MapSchema";
 export * from "./schemas/OperationSchema";
+export * from "./schemas/operation";
 export * from "./schemas/ErrorSchema";
 export * from "./schemas/NormalizedSchema";
 export * from "./schemas/Schema";

package/node_modules/@smithy/core/dist-es/submodules/schema/middleware/schemaDeserializationMiddleware.js

@@ -1,14 +1,12 @@
 import { HttpResponse } from "@smithy/protocol-http";
 import { getSmithyContext } from "@smithy/util-middleware";
-import { hydrate, isStaticSchema } from "../schemas/NormalizedSchema";
+import { operation } from "../schemas/operation";
 export const schemaDeserializationMiddleware = (config) => (next, context) => async (args) => {
     const { response } = await next(args);
-    let { operationSchema } = getSmithyContext(context);
-    if (isStaticSchema(operationSchema)) {
-        operationSchema = hydrate(operationSchema);
-    }
+    const { operationSchema } = getSmithyContext(context);
+    const [, ns, n, t, i, o] = operationSchema ?? [];
     try {
-        const parsed = await config.protocol.deserializeResponse(operationSchema, {
+        const parsed = await config.protocol.deserializeResponse(operation(ns, n, t, i, o), {
             ...config,
             ...context,
         }, response);

package/node_modules/@smithy/core/dist-es/submodules/schema/middleware/schemaSerializationMiddleware.js

@@ -1,14 +1,12 @@
 import { getSmithyContext } from "@smithy/util-middleware";
-import { hydrate, isStaticSchema } from "../schemas/NormalizedSchema";
+import { operation } from "../schemas/operation";
 export const schemaSerializationMiddleware = (config) => (next, context) => async (args) => {
-    let { operationSchema } = getSmithyContext(context);
-    if (isStaticSchema(operationSchema)) {
-        operationSchema = hydrate(operationSchema);
-    }
+    const { operationSchema } = getSmithyContext(context);
+    const [, ns, n, t, i, o] = operationSchema ?? [];
     const endpoint = context.endpointV2?.url && config.urlParser
         ? async () => config.urlParser(context.endpointV2.url)
         : config.endpoint;
-    const request = await config.protocol.serializeRequest(operationSchema, args.input, {
+    const request = await config.protocol.serializeRequest(operation(ns, n, t, i, o), args.input, {
         ...config,
         ...context,
         endpoint,