@granite-js/pulumi-aws 0.1.34 → 1.0.2

package/dist/chunk-3JKQPIJ2.js

@@ -0,0 +1,460 @@
+import {
+  FromStringShapeDeserializer,
+  HttpProtocol,
+  LazyJsonString,
+  NormalizedSchema,
+  SerdeContext,
+  collectBody,
+  determineTimestampFormat,
+  extendedEncodeURIComponent,
+  splitHeader,
+  translateTraits,
+  v4
+} from "./chunk-7NN7DVGK.js";
+import {
+  sdkStreamMixin2
+} from "./chunk-24XYHOWM.js";
+import {
+  dateToUtcString,
+  toBase64
+} from "./chunk-57WYIP4I.js";
+import {
+  HttpRequest
+} from "./chunk-TDZTH7TL.js";
+import {
+  fromUtf8,
+  toUtf8
+} from "./chunk-H4QJ5O4E.js";
+
+// ../deployment-manager/dist/chunk-KIAVDF6V.js
+function quoteHeader(part) {
+  if (part.includes(",") || part.includes('"')) {
+    part = `"${part.replace(/"/g, '\\"')}"`;
+  }
+  return part;
+}
+function splitEvery(value, delimiter, numDelimiters) {
+  if (numDelimiters <= 0 || !Number.isInteger(numDelimiters)) {
+    throw new Error("Invalid number of delimiters (" + numDelimiters + ") for splitEvery.");
+  }
+  const segments = value.split(delimiter);
+  if (numDelimiters === 1) {
+    return segments;
+  }
+  const compoundSegments = [];
+  let currentSegment = "";
+  for (let i = 0; i < segments.length; i++) {
+    if (currentSegment === "") {
+      currentSegment = segments[i];
+    } else {
+      currentSegment += delimiter + segments[i];
+    }
+    if ((i + 1) % numDelimiters === 0) {
+      compoundSegments.push(currentSegment);
+      currentSegment = "";
+    }
+  }
+  if (currentSegment !== "") {
+    compoundSegments.push(currentSegment);
+  }
+  return compoundSegments;
+}
+var HttpBindingProtocol = class extends HttpProtocol {
+  async serializeRequest(operationSchema, _input, context) {
+    const input = {
+      ..._input ?? {}
+    };
+    const serializer = this.serializer;
+    const query = {};
+    const headers = {};
+    const endpoint = await context.endpoint();
+    const ns = NormalizedSchema.of(operationSchema?.input);
+    const schema = ns.getSchema();
+    let hasNonHttpBindingMember = false;
+    let payload;
+    const request = new HttpRequest({
+      protocol: "",
+      hostname: "",
+      port: void 0,
+      path: "",
+      fragment: void 0,
+      query,
+      headers,
+      body: void 0
+    });
+    if (endpoint) {
+      this.updateServiceEndpoint(request, endpoint);
+      this.setHostPrefix(request, operationSchema, input);
+      const opTraits = translateTraits(operationSchema.traits);
+      if (opTraits.http) {
+        request.method = opTraits.http[0];
+        const [path, search] = opTraits.http[1].split("?");
+        if (request.path == "/") {
+          request.path = path;
+        } else {
+          request.path += path;
+        }
+        const traitSearchParams = new URLSearchParams(search ?? "");
+        Object.assign(query, Object.fromEntries(traitSearchParams));
+      }
+    }
+    for (const [memberName, memberNs] of ns.structIterator()) {
+      const memberTraits = memberNs.getMergedTraits() ?? {};
+      const inputMemberValue = input[memberName];
+      if (inputMemberValue == null && !memberNs.isIdempotencyToken()) {
+        continue;
+      }
+      if (memberTraits.httpPayload) {
+        const isStreaming = memberNs.isStreaming();
+        if (isStreaming) {
+          const isEventStream = memberNs.isStructSchema();
+          if (isEventStream) {
+            if (input[memberName]) {
+              payload = await this.serializeEventStream({
+                eventStream: input[memberName],
+                requestSchema: ns
+              });
+            }
+          } else {
+            payload = inputMemberValue;
+          }
+        } else {
+          serializer.write(memberNs, inputMemberValue);
+          payload = serializer.flush();
+        }
+        delete input[memberName];
+      } else if (memberTraits.httpLabel) {
+        serializer.write(memberNs, inputMemberValue);
+        const replacement = serializer.flush();
+        if (request.path.includes(`{${memberName}+}`)) {
+          request.path = request.path.replace(`{${memberName}+}`, replacement.split("/").map(extendedEncodeURIComponent).join("/"));
+        } else if (request.path.includes(`{${memberName}}`)) {
+          request.path = request.path.replace(`{${memberName}}`, extendedEncodeURIComponent(replacement));
+        }
+        delete input[memberName];
+      } else if (memberTraits.httpHeader) {
+        serializer.write(memberNs, inputMemberValue);
+        headers[memberTraits.httpHeader.toLowerCase()] = String(serializer.flush());
+        delete input[memberName];
+      } else if (typeof memberTraits.httpPrefixHeaders === "string") {
+        for (const [key, val] of Object.entries(inputMemberValue)) {
+          const amalgam = memberTraits.httpPrefixHeaders + key;
+          serializer.write([memberNs.getValueSchema(), { httpHeader: amalgam }], val);
+          headers[amalgam.toLowerCase()] = serializer.flush();
+        }
+        delete input[memberName];
+      } else if (memberTraits.httpQuery || memberTraits.httpQueryParams) {
+        this.serializeQuery(memberNs, inputMemberValue, query);
+        delete input[memberName];
+      } else {
+        hasNonHttpBindingMember = true;
+      }
+    }
+    if (hasNonHttpBindingMember && input) {
+      serializer.write(schema, input);
+      payload = serializer.flush();
+    }
+    request.headers = headers;
+    request.query = query;
+    request.body = payload;
+    return request;
+  }
+  serializeQuery(ns, data, query) {
+    const serializer = this.serializer;
+    const traits = ns.getMergedTraits();
+    if (traits.httpQueryParams) {
+      for (const [key, val] of Object.entries(data)) {
+        if (!(key in query)) {
+          const valueSchema = ns.getValueSchema();
+          Object.assign(valueSchema.getMergedTraits(), {
+            ...traits,
+            httpQuery: key,
+            httpQueryParams: void 0
+          });
+          this.serializeQuery(valueSchema, val, query);
+        }
+      }
+      return;
+    }
+    if (ns.isListSchema()) {
+      const sparse = !!ns.getMergedTraits().sparse;
+      const buffer = [];
+      for (const item of data) {
+        serializer.write([ns.getValueSchema(), traits], item);
+        const serializable = serializer.flush();
+        if (sparse || serializable !== void 0) {
+          buffer.push(serializable);
+        }
+      }
+      query[traits.httpQuery] = buffer;
+    } else {
+      serializer.write([ns, traits], data);
+      query[traits.httpQuery] = serializer.flush();
+    }
+  }
+  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(15, bytes));
+      }
+      await this.handleError(operationSchema, context, response, dataObject, this.deserializeMetadata(response));
+      throw new Error("@smithy/core/protocols - HTTP Protocol error handler failed to throw.");
+    }
+    for (const header in response.headers) {
+      const value = response.headers[header];
+      delete response.headers[header];
+      response.headers[header.toLowerCase()] = value;
+    }
+    const nonHttpBindingMembers = await this.deserializeHttpMessage(ns, context, response, dataObject);
+    if (nonHttpBindingMembers.length) {
+      const bytes = await collectBody(response.body, context);
+      if (bytes.byteLength > 0) {
+        const dataFromBody = await deserializer.read(ns, bytes);
+        for (const member of nonHttpBindingMembers) {
+          dataObject[member] = dataFromBody[member];
+        }
+      }
+    } else if (nonHttpBindingMembers.discardResponseBody) {
+      await collectBody(response.body, context);
+    }
+    dataObject.$metadata = this.deserializeMetadata(response);
+    return dataObject;
+  }
+  async deserializeHttpMessage(schema, context, response, arg4, arg5) {
+    let dataObject;
+    if (arg4 instanceof Set) {
+      dataObject = arg5;
+    } else {
+      dataObject = arg4;
+    }
+    let discardResponseBody = true;
+    const deserializer = this.deserializer;
+    const ns = NormalizedSchema.of(schema);
+    const nonHttpBindingMembers = [];
+    for (const [memberName, memberSchema] of ns.structIterator()) {
+      const memberTraits = memberSchema.getMemberTraits();
+      if (memberTraits.httpPayload) {
+        discardResponseBody = false;
+        const isStreaming = memberSchema.isStreaming();
+        if (isStreaming) {
+          const isEventStream = memberSchema.isStructSchema();
+          if (isEventStream) {
+            dataObject[memberName] = await this.deserializeEventStream({
+              response,
+              responseSchema: ns
+            });
+          } else {
+            dataObject[memberName] = sdkStreamMixin2(response.body);
+          }
+        } else if (response.body) {
+          const bytes = await collectBody(response.body, context);
+          if (bytes.byteLength > 0) {
+            dataObject[memberName] = await deserializer.read(memberSchema, bytes);
+          }
+        }
+      } else if (memberTraits.httpHeader) {
+        const key = String(memberTraits.httpHeader).toLowerCase();
+        const value = response.headers[key];
+        if (null != value) {
+          if (memberSchema.isListSchema()) {
+            const headerListValueSchema = memberSchema.getValueSchema();
+            headerListValueSchema.getMergedTraits().httpHeader = key;
+            let sections;
+            if (headerListValueSchema.isTimestampSchema() && headerListValueSchema.getSchema() === 4) {
+              sections = splitEvery(value, ",", 2);
+            } else {
+              sections = splitHeader(value);
+            }
+            const list = [];
+            for (const section of sections) {
+              list.push(await deserializer.read(headerListValueSchema, section.trim()));
+            }
+            dataObject[memberName] = list;
+          } else {
+            dataObject[memberName] = await deserializer.read(memberSchema, value);
+          }
+        }
+      } else if (memberTraits.httpPrefixHeaders !== void 0) {
+        dataObject[memberName] = {};
+        for (const [header, value] of Object.entries(response.headers)) {
+          if (header.startsWith(memberTraits.httpPrefixHeaders)) {
+            const valueSchema = memberSchema.getValueSchema();
+            valueSchema.getMergedTraits().httpHeader = header;
+            dataObject[memberName][header.slice(memberTraits.httpPrefixHeaders.length)] = await deserializer.read(valueSchema, value);
+          }
+        }
+      } else if (memberTraits.httpResponseCode) {
+        dataObject[memberName] = response.statusCode;
+      } else {
+        nonHttpBindingMembers.push(memberName);
+      }
+    }
+    nonHttpBindingMembers.discardResponseBody = discardResponseBody;
+    return nonHttpBindingMembers;
+  }
+};
+var HttpInterceptingShapeDeserializer = class extends SerdeContext {
+  codecDeserializer;
+  stringDeserializer;
+  constructor(codecDeserializer, codecSettings) {
+    super();
+    this.codecDeserializer = codecDeserializer;
+    this.stringDeserializer = new FromStringShapeDeserializer(codecSettings);
+  }
+  setSerdeContext(serdeContext) {
+    this.stringDeserializer.setSerdeContext(serdeContext);
+    this.codecDeserializer.setSerdeContext(serdeContext);
+    this.serdeContext = serdeContext;
+  }
+  read(schema, data) {
+    const ns = NormalizedSchema.of(schema);
+    const traits = ns.getMergedTraits();
+    const toString = this.serdeContext?.utf8Encoder ?? toUtf8;
+    if (traits.httpHeader || traits.httpResponseCode) {
+      return this.stringDeserializer.read(ns, toString(data));
+    }
+    if (traits.httpPayload) {
+      if (ns.isBlobSchema()) {
+        const toBytes = this.serdeContext?.utf8Decoder ?? fromUtf8;
+        if (typeof data === "string") {
+          return toBytes(data);
+        }
+        return data;
+      } else if (ns.isStringSchema()) {
+        if ("byteLength" in data) {
+          return toString(data);
+        }
+        return data;
+      }
+    }
+    return this.codecDeserializer.read(ns, data);
+  }
+};
+var ToStringShapeSerializer = class extends SerdeContext {
+  settings;
+  stringBuffer = "";
+  constructor(settings) {
+    super();
+    this.settings = settings;
+  }
+  write(schema, value) {
+    const ns = NormalizedSchema.of(schema);
+    switch (typeof value) {
+      case "object":
+        if (value === null) {
+          this.stringBuffer = "null";
+          return;
+        }
+        if (ns.isTimestampSchema()) {
+          if (!(value instanceof Date)) {
+            throw new Error(`@smithy/core/protocols - received non-Date value ${value} when schema expected Date in ${ns.getName(true)}`);
+          }
+          const format = determineTimestampFormat(ns, this.settings);
+          switch (format) {
+            case 5:
+              this.stringBuffer = value.toISOString().replace(".000Z", "Z");
+              break;
+            case 6:
+              this.stringBuffer = dateToUtcString(value);
+              break;
+            case 7:
+              this.stringBuffer = String(value.getTime() / 1e3);
+              break;
+            default:
+              console.warn("Missing timestamp format, using epoch seconds", value);
+              this.stringBuffer = String(value.getTime() / 1e3);
+          }
+          return;
+        }
+        if (ns.isBlobSchema() && "byteLength" in value) {
+          this.stringBuffer = (this.serdeContext?.base64Encoder ?? toBase64)(value);
+          return;
+        }
+        if (ns.isListSchema() && Array.isArray(value)) {
+          let buffer = "";
+          for (const item of value) {
+            this.write([ns.getValueSchema(), ns.getMergedTraits()], item);
+            const headerItem = this.flush();
+            const serialized = ns.getValueSchema().isTimestampSchema() ? headerItem : quoteHeader(headerItem);
+            if (buffer !== "") {
+              buffer += ", ";
+            }
+            buffer += serialized;
+          }
+          this.stringBuffer = buffer;
+          return;
+        }
+        this.stringBuffer = JSON.stringify(value, null, 2);
+        break;
+      case "string":
+        const mediaType = ns.getMergedTraits().mediaType;
+        let intermediateValue = value;
+        if (mediaType) {
+          const isJson = mediaType === "application/json" || mediaType.endsWith("+json");
+          if (isJson) {
+            intermediateValue = LazyJsonString.from(intermediateValue);
+          }
+          if (ns.getMergedTraits().httpHeader) {
+            this.stringBuffer = (this.serdeContext?.base64Encoder ?? toBase64)(intermediateValue.toString());
+            return;
+          }
+        }
+        this.stringBuffer = value;
+        break;
+      default:
+        if (ns.isIdempotencyToken()) {
+          this.stringBuffer = v4();
+        } else {
+          this.stringBuffer = String(value);
+        }
+    }
+  }
+  flush() {
+    const buffer = this.stringBuffer;
+    this.stringBuffer = "";
+    return buffer;
+  }
+};
+var HttpInterceptingShapeSerializer = class {
+  codecSerializer;
+  stringSerializer;
+  buffer;
+  constructor(codecSerializer, codecSettings, stringSerializer = new ToStringShapeSerializer(codecSettings)) {
+    this.codecSerializer = codecSerializer;
+    this.stringSerializer = stringSerializer;
+  }
+  setSerdeContext(serdeContext) {
+    this.codecSerializer.setSerdeContext(serdeContext);
+    this.stringSerializer.setSerdeContext(serdeContext);
+  }
+  write(schema, value) {
+    const ns = NormalizedSchema.of(schema);
+    const traits = ns.getMergedTraits();
+    if (traits.httpHeader || traits.httpLabel || traits.httpQuery) {
+      this.stringSerializer.write(ns, value);
+      this.buffer = this.stringSerializer.flush();
+      return;
+    }
+    return this.codecSerializer.write(ns, value);
+  }
+  flush() {
+    if (this.buffer !== void 0) {
+      const buffer = this.buffer;
+      this.buffer = void 0;
+      return buffer;
+    }
+    return this.codecSerializer.flush();
+  }
+};
+var collectBodyString = (streamBody, context) => collectBody(streamBody, context).then((body) => (context?.utf8Encoder ?? toUtf8)(body));
+
+export {
+  HttpBindingProtocol,
+  HttpInterceptingShapeDeserializer,
+  HttpInterceptingShapeSerializer,
+  collectBodyString
+};

package/dist/{chunk-ITI6QA2Q.js → chunk-3OYGHA4S.js}

@@ -1,4 +1,4 @@
-// ../../.yarn/cache/@aws-sdk-core-npm-3.816.0-71722eb284-f11ab1da51.zip/node_modules/@aws-sdk/core/dist-es/submodules/client/setCredentialFeature.js
+// ../../.yarn/cache/@aws-sdk-core-npm-3.940.0-0d32a8e8d2-090b960007.zip/node_modules/@aws-sdk/core/dist-es/submodules/client/setCredentialFeature.js
 function setCredentialFeature(credentials, feature, value) {
   if (!credentials.$source) {
     credentials.$source = {};

package/dist/{chunk-IEZY5C3G.js → chunk-46DIC54Q.js}

@@ -1,7 +1,7 @@
-// ../deployment-manager/dist/chunk-UNXXS5FM.js
+// ../deployment-manager/dist/chunk-NKYOPFVJ.js
 var package_default = {
   name: "@aws-sdk/nested-clients",
-  version: "3.817.0",
+  version: "3.940.0",
   description: "Nested clients for AWS SDK packages.",
   main: "./dist-cjs/index.js",
   module: "./dist-es/index.js",
@@ -21,6 +21,7 @@ var package_default = {
   engines: {
     node: ">=18.0.0"
   },
+  sideEffects: false,
   author: {
     name: "AWS SDK for JavaScript Team",
     url: "https://aws.amazon.com/javascript/"
@@ -29,41 +30,41 @@ var package_default = {
   dependencies: {
     "@aws-crypto/sha256-browser": "5.2.0",
     "@aws-crypto/sha256-js": "5.2.0",
-    "@aws-sdk/core": "3.816.0",
-    "@aws-sdk/middleware-host-header": "3.804.0",
-    "@aws-sdk/middleware-logger": "3.804.0",
-    "@aws-sdk/middleware-recursion-detection": "3.804.0",
-    "@aws-sdk/middleware-user-agent": "3.816.0",
-    "@aws-sdk/region-config-resolver": "3.808.0",
-    "@aws-sdk/types": "3.804.0",
-    "@aws-sdk/util-endpoints": "3.808.0",
-    "@aws-sdk/util-user-agent-browser": "3.804.0",
-    "@aws-sdk/util-user-agent-node": "3.816.0",
-    "@smithy/config-resolver": "^4.1.2",
-    "@smithy/core": "^3.3.3",
-    "@smithy/fetch-http-handler": "^5.0.2",
-    "@smithy/hash-node": "^4.0.2",
-    "@smithy/invalid-dependency": "^4.0.2",
-    "@smithy/middleware-content-length": "^4.0.2",
-    "@smithy/middleware-endpoint": "^4.1.6",
-    "@smithy/middleware-retry": "^4.1.7",
-    "@smithy/middleware-serde": "^4.0.5",
-    "@smithy/middleware-stack": "^4.0.2",
-    "@smithy/node-config-provider": "^4.1.1",
-    "@smithy/node-http-handler": "^4.0.4",
-    "@smithy/protocol-http": "^5.1.0",
-    "@smithy/smithy-client": "^4.2.6",
-    "@smithy/types": "^4.2.0",
-    "@smithy/url-parser": "^4.0.2",
-    "@smithy/util-base64": "^4.0.0",
-    "@smithy/util-body-length-browser": "^4.0.0",
-    "@smithy/util-body-length-node": "^4.0.0",
-    "@smithy/util-defaults-mode-browser": "^4.0.14",
-    "@smithy/util-defaults-mode-node": "^4.0.14",
-    "@smithy/util-endpoints": "^3.0.4",
-    "@smithy/util-middleware": "^4.0.2",
-    "@smithy/util-retry": "^4.0.3",
-    "@smithy/util-utf8": "^4.0.0",
+    "@aws-sdk/core": "3.940.0",
+    "@aws-sdk/middleware-host-header": "3.936.0",
+    "@aws-sdk/middleware-logger": "3.936.0",
+    "@aws-sdk/middleware-recursion-detection": "3.936.0",
+    "@aws-sdk/middleware-user-agent": "3.940.0",
+    "@aws-sdk/region-config-resolver": "3.936.0",
+    "@aws-sdk/types": "3.936.0",
+    "@aws-sdk/util-endpoints": "3.936.0",
+    "@aws-sdk/util-user-agent-browser": "3.936.0",
+    "@aws-sdk/util-user-agent-node": "3.940.0",
+    "@smithy/config-resolver": "^4.4.3",
+    "@smithy/core": "^3.18.5",
+    "@smithy/fetch-http-handler": "^5.3.6",
+    "@smithy/hash-node": "^4.2.5",
+    "@smithy/invalid-dependency": "^4.2.5",
+    "@smithy/middleware-content-length": "^4.2.5",
+    "@smithy/middleware-endpoint": "^4.3.12",
+    "@smithy/middleware-retry": "^4.4.12",
+    "@smithy/middleware-serde": "^4.2.6",
+    "@smithy/middleware-stack": "^4.2.5",
+    "@smithy/node-config-provider": "^4.3.5",
+    "@smithy/node-http-handler": "^4.4.5",
+    "@smithy/protocol-http": "^5.3.5",
+    "@smithy/smithy-client": "^4.9.8",
+    "@smithy/types": "^4.9.0",
+    "@smithy/url-parser": "^4.2.5",
+    "@smithy/util-base64": "^4.3.0",
+    "@smithy/util-body-length-browser": "^4.2.0",
+    "@smithy/util-body-length-node": "^4.2.1",
+    "@smithy/util-defaults-mode-browser": "^4.3.11",
+    "@smithy/util-defaults-mode-node": "^4.2.14",
+    "@smithy/util-endpoints": "^3.2.5",
+    "@smithy/util-middleware": "^4.2.5",
+    "@smithy/util-retry": "^4.2.5",
+    "@smithy/util-utf8": "^4.2.0",
     tslib: "^2.6.2"
   },
   devDependencies: {
@@ -80,6 +81,8 @@ var package_default = {
     }
   },
   files: [
+    "./signin.d.ts",
+    "./signin.js",
     "./sso-oidc.d.ts",
     "./sso-oidc.js",
     "./sts.d.ts",
@@ -87,6 +90,7 @@ var package_default = {
     "dist-*/**"
   ],
   browser: {
+    "./dist-es/submodules/signin/runtimeConfig": "./dist-es/submodules/signin/runtimeConfig.browser",
     "./dist-es/submodules/sso-oidc/runtimeConfig": "./dist-es/submodules/sso-oidc/runtimeConfig.browser",
     "./dist-es/submodules/sts/runtimeConfig": "./dist-es/submodules/sts/runtimeConfig.browser"
   },
@@ -98,6 +102,7 @@ var package_default = {
     directory: "packages/nested-clients"
   },
   exports: {
+    "./package.json": "./package.json",
     "./sso-oidc": {
       types: "./dist-types/submodules/sso-oidc/index.d.ts",
       module: "./dist-es/submodules/sso-oidc/index.js",
@@ -111,6 +116,13 @@ var package_default = {
       node: "./dist-cjs/submodules/sts/index.js",
       import: "./dist-es/submodules/sts/index.js",
       require: "./dist-cjs/submodules/sts/index.js"
+    },
+    "./signin": {
+      types: "./dist-types/submodules/signin/index.d.ts",
+      module: "./dist-es/submodules/signin/index.js",
+      node: "./dist-cjs/submodules/signin/index.js",
+      import: "./dist-es/submodules/signin/index.js",
+      require: "./dist-cjs/submodules/signin/index.js"
     }
   }
 };