@cdk8s/awscdk-resolver 0.0.347 → 0.0.349

package/node_modules/@aws-sdk/credential-provider-node/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aws-sdk/credential-provider-node",
-  "version": "3.873.0",
+  "version": "3.876.0",
   "description": "AWS credential provider that sources credentials from a Node.JS environment. ",
   "engines": {
     "node": ">=18.0.0"
@@ -29,12 +29,12 @@
   },
   "license": "Apache-2.0",
   "dependencies": {
-    "@aws-sdk/credential-provider-env": "3.873.0",
-    "@aws-sdk/credential-provider-http": "3.873.0",
-    "@aws-sdk/credential-provider-ini": "3.873.0",
-    "@aws-sdk/credential-provider-process": "3.873.0",
-    "@aws-sdk/credential-provider-sso": "3.873.0",
-    "@aws-sdk/credential-provider-web-identity": "3.873.0",
+    "@aws-sdk/credential-provider-env": "3.876.0",
+    "@aws-sdk/credential-provider-http": "3.876.0",
+    "@aws-sdk/credential-provider-ini": "3.876.0",
+    "@aws-sdk/credential-provider-process": "3.876.0",
+    "@aws-sdk/credential-provider-sso": "3.876.0",
+    "@aws-sdk/credential-provider-web-identity": "3.876.0",
     "@aws-sdk/types": "3.862.0",
     "@smithy/credential-provider-imds": "^4.0.7",
     "@smithy/property-provider": "^4.0.5",

package/node_modules/@aws-sdk/credential-provider-process/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aws-sdk/credential-provider-process",
-  "version": "3.873.0",
+  "version": "3.876.0",
   "description": "AWS credential provider that sources credential_process from ~/.aws/credentials and ~/.aws/config",
   "main": "./dist-cjs/index.js",
   "module": "./dist-es/index.js",
@@ -25,7 +25,7 @@
   },
   "license": "Apache-2.0",
   "dependencies": {
-    "@aws-sdk/core": "3.873.0",
+    "@aws-sdk/core": "3.876.0",
     "@aws-sdk/types": "3.862.0",
     "@smithy/property-provider": "^4.0.5",
     "@smithy/shared-ini-file-loader": "^4.0.5",

package/node_modules/@aws-sdk/credential-provider-sso/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aws-sdk/credential-provider-sso",
-  "version": "3.873.0",
+  "version": "3.876.0",
   "description": "AWS credential provider that exchanges a resolved SSO login token file for temporary AWS credentials",
   "main": "./dist-cjs/index.js",
   "module": "./dist-es/index.js",
@@ -25,9 +25,9 @@
   },
   "license": "Apache-2.0",
   "dependencies": {
-    "@aws-sdk/client-sso": "3.873.0",
-    "@aws-sdk/core": "3.873.0",
-    "@aws-sdk/token-providers": "3.873.0",
+    "@aws-sdk/client-sso": "3.876.0",
+    "@aws-sdk/core": "3.876.0",
+    "@aws-sdk/token-providers": "3.876.0",
     "@aws-sdk/types": "3.862.0",
     "@smithy/property-provider": "^4.0.5",
     "@smithy/shared-ini-file-loader": "^4.0.5",

package/node_modules/@aws-sdk/credential-provider-web-identity/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aws-sdk/credential-provider-web-identity",
-  "version": "3.873.0",
+  "version": "3.876.0",
   "description": "AWS credential provider that calls STS assumeRole for temporary AWS credentials",
   "main": "./dist-cjs/index.js",
   "module": "./dist-es/index.js",
@@ -33,8 +33,8 @@
   },
   "license": "Apache-2.0",
   "dependencies": {
-    "@aws-sdk/core": "3.873.0",
-    "@aws-sdk/nested-clients": "3.873.0",
+    "@aws-sdk/core": "3.876.0",
+    "@aws-sdk/nested-clients": "3.876.0",
     "@aws-sdk/types": "3.862.0",
     "@smithy/property-provider": "^4.0.5",
     "@smithy/types": "^4.3.2",

package/node_modules/@aws-sdk/middleware-logger/dist-types/loggerMiddleware.d.ts

@@ -1,4 +1,4 @@
-import { AbsoluteLocation, HandlerExecutionContext, InitializeHandler, InitializeHandlerOptions, MetadataBearer, Pluggable } from "@smithy/types";
+import type { AbsoluteLocation, HandlerExecutionContext, InitializeHandler, InitializeHandlerOptions, MetadataBearer, Pluggable } from "@smithy/types";
 export declare const loggerMiddleware: () => <Output extends MetadataBearer = MetadataBearer>(next: InitializeHandler<any, Output>, context: HandlerExecutionContext) => InitializeHandler<any, Output>;
 export declare const loggerMiddlewareOptions: InitializeHandlerOptions & AbsoluteLocation;
 export declare const getLoggerPlugin: (options: any) => Pluggable<any, any>;

package/node_modules/@aws-sdk/middleware-logger/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aws-sdk/middleware-logger",
-  "version": "3.873.0",
+  "version": "3.876.0",
   "scripts": {
     "build": "concurrently 'yarn:build:cjs' 'yarn:build:es' 'yarn:build:types'",
     "build:cjs": "node ../../scripts/compilation/inline middleware-logger",

package/node_modules/@aws-sdk/middleware-user-agent/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aws-sdk/middleware-user-agent",
-  "version": "3.873.0",
+  "version": "3.876.0",
   "scripts": {
     "build": "concurrently 'yarn:build:cjs' 'yarn:build:es' 'yarn:build:types'",
     "build:cjs": "node ../../scripts/compilation/inline middleware-user-agent",
@@ -24,7 +24,7 @@
   },
   "license": "Apache-2.0",
   "dependencies": {
-    "@aws-sdk/core": "3.873.0",
+    "@aws-sdk/core": "3.876.0",
     "@aws-sdk/types": "3.862.0",
     "@aws-sdk/util-endpoints": "3.873.0",
     "@smithy/core": "^3.8.0",

package/node_modules/@aws-sdk/nested-clients/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aws-sdk/nested-clients",
-  "version": "3.873.0",
+  "version": "3.876.0",
   "description": "Nested clients for AWS SDK packages.",
   "main": "./dist-cjs/index.js",
   "module": "./dist-es/index.js",
@@ -28,16 +28,16 @@
   "dependencies": {
     "@aws-crypto/sha256-browser": "5.2.0",
     "@aws-crypto/sha256-js": "5.2.0",
-    "@aws-sdk/core": "3.873.0",
+    "@aws-sdk/core": "3.876.0",
     "@aws-sdk/middleware-host-header": "3.873.0",
-    "@aws-sdk/middleware-logger": "3.873.0",
+    "@aws-sdk/middleware-logger": "3.876.0",
     "@aws-sdk/middleware-recursion-detection": "3.873.0",
-    "@aws-sdk/middleware-user-agent": "3.873.0",
+    "@aws-sdk/middleware-user-agent": "3.876.0",
     "@aws-sdk/region-config-resolver": "3.873.0",
     "@aws-sdk/types": "3.862.0",
     "@aws-sdk/util-endpoints": "3.873.0",
     "@aws-sdk/util-user-agent-browser": "3.873.0",
-    "@aws-sdk/util-user-agent-node": "3.873.0",
+    "@aws-sdk/util-user-agent-node": "3.876.0",
     "@smithy/config-resolver": "^4.1.5",
     "@smithy/core": "^3.8.0",
     "@smithy/fetch-http-handler": "^5.1.1",

package/node_modules/@aws-sdk/token-providers/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aws-sdk/token-providers",
-  "version": "3.873.0",
+  "version": "3.876.0",
   "description": "A collection of token providers",
   "main": "./dist-cjs/index.js",
   "module": "./dist-es/index.js",
@@ -29,8 +29,8 @@
   },
   "license": "Apache-2.0",
   "dependencies": {
-    "@aws-sdk/core": "3.873.0",
-    "@aws-sdk/nested-clients": "3.873.0",
+    "@aws-sdk/core": "3.876.0",
+    "@aws-sdk/nested-clients": "3.876.0",
     "@aws-sdk/types": "3.862.0",
     "@smithy/property-provider": "^4.0.5",
     "@smithy/shared-ini-file-loader": "^4.0.5",

package/node_modules/@aws-sdk/util-user-agent-node/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aws-sdk/util-user-agent-node",
-  "version": "3.873.0",
+  "version": "3.876.0",
   "scripts": {
     "build": "concurrently 'yarn:build:cjs' 'yarn:build:es' 'yarn:build:types'",
     "build:cjs": "node ../../scripts/compilation/inline util-user-agent-node",
@@ -21,7 +21,7 @@
   },
   "license": "Apache-2.0",
   "dependencies": {
-    "@aws-sdk/middleware-user-agent": "3.873.0",
+    "@aws-sdk/middleware-user-agent": "3.876.0",
     "@aws-sdk/types": "3.862.0",
     "@smithy/node-config-provider": "^4.1.4",
     "@smithy/types": "^4.3.2",

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

@@ -895,6 +895,10 @@ var CborShapeDeserializer = class {
     const data2 = cbor.deserialize(bytes);
     return this.readValue(schema, data2);
   }
+  /**
+   * Public because it's called by the protocol implementation to deserialize errors.
+   * @internal
+   */
   readValue(_schema, value) {
     const ns = import_schema.NormalizedSchema.of(_schema);
     if (ns.isTimestampSchema() && typeof value === "number") {
@@ -972,9 +976,9 @@ var SmithyRpcV2CborProtocol = class extends import_protocols2.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 ((0, import_schema2.deref)(operationSchema.input) === "unit") {
       delete request.body;
@@ -1002,25 +1006,50 @@ var SmithyRpcV2CborProtocol = class extends import_protocols2.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,
+      $response: response,
+      $fault: response.statusCode <= 500 ? "client" : "server"
+    };
     const registry = import_schema2.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 baseExceptionSchema = import_schema2.TypeRegistry.for("smithy.ts.sdk.synthetic." + namespace).getBaseException();
+      if (baseExceptionSchema) {
+        const ErrorCtor = baseExceptionSchema.ctor;
+        throw Object.assign(new ErrorCtor({ name: errorName }), errorMetadata, dataObject);
+      }
+      throw Object.assign(new Error(errorName), errorMetadata, dataObject);
     }
+    const ns = import_schema2.NormalizedSchema.of(errorSchema);
     const message = dataObject.message ?? dataObject.Message ?? "Unknown";
     const exception = new errorSchema.ctor(message);
-    Object.assign(exception, {
-      $metadata: metadata,
-      $response: response,
-      message,
-      ...dataObject
-    });
-    throw exception;
+    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
+      },
+      output
+    );
+  }
+  getDefaultContentType() {
+    return "application/cbor";
   }
 };
 // Annotate the CommonJS export names for ESM import in node:

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

@@ -0,0 +1,261 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/submodules/event-streams/index.ts
+var event_streams_exports = {};
+__export(event_streams_exports, {
+  EventStreamSerde: () => EventStreamSerde
+});
+module.exports = __toCommonJS(event_streams_exports);
+
+// src/submodules/event-streams/EventStreamSerde.ts
+var import_schema = require("@smithy/core/schema");
+var import_util_utf8 = require("@smithy/util-utf8");
+var EventStreamSerde = class {
+  /**
+   * Properties are injected by the HttpProtocol.
+   */
+  constructor({
+    marshaller,
+    serializer,
+    deserializer,
+    serdeContext,
+    defaultContentType
+  }) {
+    this.marshaller = marshaller;
+    this.serializer = serializer;
+    this.deserializer = deserializer;
+    this.serdeContext = serdeContext;
+    this.defaultContentType = defaultContentType;
+  }
+  /**
+   * @param eventStream - the iterable provided by the caller.
+   * @param requestSchema - the schema of the event stream container (struct).
+   * @param [initialRequest] - only provided if the initial-request is part of the event stream (RPC).
+   *
+   * @returns a stream suitable for the HTTP body of a request.
+   */
+  async serializeEventStream({
+    eventStream,
+    requestSchema,
+    initialRequest
+  }) {
+    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");
+    const eventStreamIterable = {
+      async *[Symbol.asyncIterator]() {
+        if (initialRequest) {
+          const headers = {
+            ":event-type": { type: "string", value: "initial-request" },
+            ":message-type": { type: "string", value: "event" },
+            ":content-type": { type: "string", value: defaultContentType }
+          };
+          serializer.write(requestSchema, initialRequest);
+          const body = serializer.flush();
+          yield {
+            [initialRequestMarker]: true,
+            headers,
+            body
+          };
+        }
+        for await (const page of eventStream) {
+          yield page;
+        }
+      }
+    };
+    return marshaller.serialize(eventStreamIterable, (event) => {
+      if (event[initialRequestMarker]) {
+        return {
+          headers: event.headers,
+          body: event.body
+        };
+      }
+      const unionMember = Object.keys(event).find((key) => {
+        return key !== "__type";
+      }) ?? "";
+      const { additionalHeaders, body, eventType, explicitPayloadContentType } = this.writeEventBody(
+        unionMember,
+        unionSchema,
+        event
+      );
+      const headers = {
+        ":event-type": { type: "string", value: eventType },
+        ":message-type": { type: "string", value: "event" },
+        ":content-type": { type: "string", value: explicitPayloadContentType ?? defaultContentType },
+        ...additionalHeaders
+      };
+      return {
+        headers,
+        body
+      };
+    });
+  }
+  /**
+   * @param response - http response from which to read the event stream.
+   * @param unionSchema - schema of the event stream container (struct).
+   * @param [initialResponseContainer] - provided and written to only if the initial response is part of the event stream (RPC).
+   *
+   * @returns the asyncIterable of the event stream for the end-user.
+   */
+  async deserializeEventStream({
+    response,
+    responseSchema,
+    initialResponseContainer
+  }) {
+    const marshaller = this.marshaller;
+    const eventStreamMember = responseSchema.getEventStreamMember();
+    const unionSchema = responseSchema.getMemberSchema(eventStreamMember);
+    const memberSchemas = unionSchema.getMemberSchemas();
+    const initialResponseMarker = Symbol("initialResponseMarker");
+    const asyncIterable = marshaller.deserialize(response.body, async (event) => {
+      const unionMember = Object.keys(event).find((key) => {
+        return key !== "__type";
+      }) ?? "";
+      if (unionMember === "initial-response") {
+        const dataObject = await this.deserializer.read(responseSchema, event[unionMember].body);
+        delete dataObject[eventStreamMember];
+        return {
+          [initialResponseMarker]: true,
+          ...dataObject
+        };
+      } else if (unionMember in memberSchemas) {
+        const eventStreamSchema = memberSchemas[unionMember];
+        return {
+          [unionMember]: await this.deserializer.read(eventStreamSchema, event[unionMember].body)
+        };
+      } else {
+        return {
+          $unknown: event
+        };
+      }
+    });
+    const asyncIterator = asyncIterable[Symbol.asyncIterator]();
+    const firstEvent = await asyncIterator.next();
+    if (firstEvent.done) {
+      return asyncIterable;
+    }
+    if (firstEvent.value?.[initialResponseMarker]) {
+      if (!responseSchema) {
+        throw new Error(
+          "@smithy::core/protocols - initial-response event encountered in event stream but no response schema given."
+        );
+      }
+      for (const [key, value] of Object.entries(firstEvent.value)) {
+        initialResponseContainer[key] = value;
+      }
+    }
+    return {
+      async *[Symbol.asyncIterator]() {
+        if (!firstEvent?.value?.[initialResponseMarker]) {
+          yield firstEvent.value;
+        }
+        while (true) {
+          const { done, value } = await asyncIterator.next();
+          if (done) {
+            break;
+          }
+          yield value;
+        }
+      }
+    };
+  }
+  /**
+   * @param unionMember - member name within the structure that contains an event stream union.
+   * @param unionSchema - schema of the union.
+   * @param event
+   *
+   * @returns the event body (bytes) and event type (string).
+   */
+  writeEventBody(unionMember, unionSchema, event) {
+    const serializer = this.serializer;
+    let eventType = unionMember;
+    let explicitPayloadMember = null;
+    let explicitPayloadContentType;
+    const isKnownSchema = unionSchema.hasMemberSchema(unionMember);
+    const additionalHeaders = {};
+    if (!isKnownSchema) {
+      const [type, value] = event[unionMember];
+      eventType = type;
+      serializer.write(import_schema.SCHEMA.DOCUMENT, value);
+    } else {
+      const eventSchema = unionSchema.getMemberSchema(unionMember);
+      if (eventSchema.isStructSchema()) {
+        for (const [memberName, memberSchema] of eventSchema.structIterator()) {
+          const { eventHeader, eventPayload } = memberSchema.getMergedTraits();
+          if (eventPayload) {
+            explicitPayloadMember = memberName;
+            break;
+          } else if (eventHeader) {
+            const value = event[unionMember][memberName];
+            let type = "binary";
+            if (memberSchema.isNumericSchema()) {
+              if ((-2) ** 31 <= value && value <= 2 ** 31 - 1) {
+                type = "integer";
+              } else {
+                type = "long";
+              }
+            } else if (memberSchema.isTimestampSchema()) {
+              type = "timestamp";
+            } else if (memberSchema.isStringSchema()) {
+              type = "string";
+            } else if (memberSchema.isBooleanSchema()) {
+              type = "boolean";
+            }
+            if (value != null) {
+              additionalHeaders[memberName] = {
+                type,
+                value
+              };
+              delete event[unionMember][memberName];
+            }
+          }
+        }
+        if (explicitPayloadMember !== null) {
+          const payloadSchema = eventSchema.getMemberSchema(explicitPayloadMember);
+          if (payloadSchema.isBlobSchema()) {
+            explicitPayloadContentType = "application/octet-stream";
+          } else if (payloadSchema.isStringSchema()) {
+            explicitPayloadContentType = "text/plain";
+          }
+          serializer.write(payloadSchema, event[unionMember][explicitPayloadMember]);
+        } else {
+          serializer.write(eventSchema, event[unionMember]);
+        }
+      } else {
+        throw new Error("@smithy/core/event-streams - non-struct member not supported in event stream union.");
+      }
+    }
+    const messageSerialization = serializer.flush();
+    const body = typeof messageSerialization === "string" ? (this.serdeContext?.utf8Decoder ?? import_util_utf8.fromUtf8)(messageSerialization) : messageSerialization;
+    return {
+      body,
+      eventType,
+      explicitPayloadContentType,
+      additionalHeaders
+    };
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  EventStreamSerde
+});