@cdk8s/awscdk-resolver 0.0.374 → 0.0.376

package/node_modules/@smithy/middleware-endpoint/dist-cjs/index.js

@@ -1,298 +1,240 @@
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-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/index.ts
-var index_exports = {};
-__export(index_exports, {
-  endpointMiddleware: () => endpointMiddleware,
-  endpointMiddlewareOptions: () => endpointMiddlewareOptions,
-  getEndpointFromInstructions: () => getEndpointFromInstructions,
-  getEndpointPlugin: () => getEndpointPlugin,
-  resolveEndpointConfig: () => resolveEndpointConfig,
-  resolveEndpointRequiredConfig: () => resolveEndpointRequiredConfig,
-  resolveParams: () => resolveParams,
-  toEndpointV1: () => toEndpointV1
-});
-module.exports = __toCommonJS(index_exports);
+'use strict';
 
-// src/service-customizations/s3.ts
-var resolveParamsForS3 = /* @__PURE__ */ __name(async (endpointParams) => {
-  const bucket = endpointParams?.Bucket || "";
-  if (typeof endpointParams.Bucket === "string") {
-    endpointParams.Bucket = bucket.replace(/#/g, encodeURIComponent("#")).replace(/\?/g, encodeURIComponent("?"));
-  }
-  if (isArnBucketName(bucket)) {
-    if (endpointParams.ForcePathStyle === true) {
-      throw new Error("Path-style addressing cannot be used with ARN buckets");
-    }
-  } else if (!isDnsCompatibleBucketName(bucket) || bucket.indexOf(".") !== -1 && !String(endpointParams.Endpoint).startsWith("http:") || bucket.toLowerCase() !== bucket || bucket.length < 3) {
-    endpointParams.ForcePathStyle = true;
-  }
-  if (endpointParams.DisableMultiRegionAccessPoints) {
-    endpointParams.disableMultiRegionAccessPoints = true;
-    endpointParams.DisableMRAP = true;
-  }
-  return endpointParams;
-}, "resolveParamsForS3");
-var DOMAIN_PATTERN = /^[a-z0-9][a-z0-9\.\-]{1,61}[a-z0-9]$/;
-var IP_ADDRESS_PATTERN = /(\d+\.){3}\d+/;
-var DOTS_PATTERN = /\.\./;
-var isDnsCompatibleBucketName = /* @__PURE__ */ __name((bucketName) => DOMAIN_PATTERN.test(bucketName) && !IP_ADDRESS_PATTERN.test(bucketName) && !DOTS_PATTERN.test(bucketName), "isDnsCompatibleBucketName");
-var isArnBucketName = /* @__PURE__ */ __name((bucketName) => {
-  const [arn, partition, service, , , bucket] = bucketName.split(":");
-  const isArn = arn === "arn" && bucketName.split(":").length >= 6;
-  const isValidArn = Boolean(isArn && partition && service && bucket);
-  if (isArn && !isValidArn) {
-    throw new Error(`Invalid ARN: ${bucketName} was an invalid ARN.`);
-  }
-  return isValidArn;
-}, "isArnBucketName");
+var getEndpointFromConfig = require('./adaptors/getEndpointFromConfig');
+var urlParser = require('@smithy/url-parser');
+var core = require('@smithy/core');
+var utilMiddleware = require('@smithy/util-middleware');
+var middlewareSerde = require('@smithy/middleware-serde');
 
-// src/adaptors/createConfigValueProvider.ts
-var createConfigValueProvider = /* @__PURE__ */ __name((configKey, canonicalEndpointParamKey, config) => {
-  const configProvider = /* @__PURE__ */ __name(async () => {
-    const configValue = config[configKey] ?? config[canonicalEndpointParamKey];
-    if (typeof configValue === "function") {
-      return configValue();
+const resolveParamsForS3 = async (endpointParams) => {
+    const bucket = endpointParams?.Bucket || "";
+    if (typeof endpointParams.Bucket === "string") {
+        endpointParams.Bucket = bucket.replace(/#/g, encodeURIComponent("#")).replace(/\?/g, encodeURIComponent("?"));
     }
-    return configValue;
-  }, "configProvider");
-  if (configKey === "credentialScope" || canonicalEndpointParamKey === "CredentialScope") {
-    return async () => {
-      const credentials = typeof config.credentials === "function" ? await config.credentials() : config.credentials;
-      const configValue = credentials?.credentialScope ?? credentials?.CredentialScope;
-      return configValue;
-    };
-  }
-  if (configKey === "accountId" || canonicalEndpointParamKey === "AccountId") {
-    return async () => {
-      const credentials = typeof config.credentials === "function" ? await config.credentials() : config.credentials;
-      const configValue = credentials?.accountId ?? credentials?.AccountId;
-      return configValue;
-    };
-  }
-  if (configKey === "endpoint" || canonicalEndpointParamKey === "endpoint") {
-    return async () => {
-      if (config.isCustomEndpoint === false) {
-        return void 0;
-      }
-      const endpoint = await configProvider();
-      if (endpoint && typeof endpoint === "object") {
-        if ("url" in endpoint) {
-          return endpoint.url.href;
+    if (isArnBucketName(bucket)) {
+        if (endpointParams.ForcePathStyle === true) {
+            throw new Error("Path-style addressing cannot be used with ARN buckets");
         }
-        if ("hostname" in endpoint) {
-          const { protocol, hostname, port, path } = endpoint;
-          return `${protocol}//${hostname}${port ? ":" + port : ""}${path}`;
+    }
+    else if (!isDnsCompatibleBucketName(bucket) ||
+        (bucket.indexOf(".") !== -1 && !String(endpointParams.Endpoint).startsWith("http:")) ||
+        bucket.toLowerCase() !== bucket ||
+        bucket.length < 3) {
+        endpointParams.ForcePathStyle = true;
+    }
+    if (endpointParams.DisableMultiRegionAccessPoints) {
+        endpointParams.disableMultiRegionAccessPoints = true;
+        endpointParams.DisableMRAP = true;
+    }
+    return endpointParams;
+};
+const DOMAIN_PATTERN = /^[a-z0-9][a-z0-9\.\-]{1,61}[a-z0-9]$/;
+const IP_ADDRESS_PATTERN = /(\d+\.){3}\d+/;
+const DOTS_PATTERN = /\.\./;
+const isDnsCompatibleBucketName = (bucketName) => DOMAIN_PATTERN.test(bucketName) && !IP_ADDRESS_PATTERN.test(bucketName) && !DOTS_PATTERN.test(bucketName);
+const isArnBucketName = (bucketName) => {
+    const [arn, partition, service, , , bucket] = bucketName.split(":");
+    const isArn = arn === "arn" && bucketName.split(":").length >= 6;
+    const isValidArn = Boolean(isArn && partition && service && bucket);
+    if (isArn && !isValidArn) {
+        throw new Error(`Invalid ARN: ${bucketName} was an invalid ARN.`);
+    }
+    return isValidArn;
+};
+
+const createConfigValueProvider = (configKey, canonicalEndpointParamKey, config) => {
+    const configProvider = async () => {
+        const configValue = config[configKey] ?? config[canonicalEndpointParamKey];
+        if (typeof configValue === "function") {
+            return configValue();
         }
-      }
-      return endpoint;
+        return configValue;
     };
-  }
-  return configProvider;
-}, "createConfigValueProvider");
-
-// src/adaptors/getEndpointFromInstructions.ts
-var import_getEndpointFromConfig = require("./adaptors/getEndpointFromConfig");
-
-// src/adaptors/toEndpointV1.ts
-var import_url_parser = require("@smithy/url-parser");
-var toEndpointV1 = /* @__PURE__ */ __name((endpoint) => {
-  if (typeof endpoint === "object") {
-    if ("url" in endpoint) {
-      return (0, import_url_parser.parseUrl)(endpoint.url);
+    if (configKey === "credentialScope" || canonicalEndpointParamKey === "CredentialScope") {
+        return async () => {
+            const credentials = typeof config.credentials === "function" ? await config.credentials() : config.credentials;
+            const configValue = credentials?.credentialScope ?? credentials?.CredentialScope;
+            return configValue;
+        };
     }
-    return endpoint;
-  }
-  return (0, import_url_parser.parseUrl)(endpoint);
-}, "toEndpointV1");
-
-// src/adaptors/getEndpointFromInstructions.ts
-var getEndpointFromInstructions = /* @__PURE__ */ __name(async (commandInput, instructionsSupplier, clientConfig, context) => {
-  if (!clientConfig.isCustomEndpoint) {
-    let endpointFromConfig;
-    if (clientConfig.serviceConfiguredEndpoint) {
-      endpointFromConfig = await clientConfig.serviceConfiguredEndpoint();
-    } else {
-      endpointFromConfig = await (0, import_getEndpointFromConfig.getEndpointFromConfig)(clientConfig.serviceId);
+    if (configKey === "accountId" || canonicalEndpointParamKey === "AccountId") {
+        return async () => {
+            const credentials = typeof config.credentials === "function" ? await config.credentials() : config.credentials;
+            const configValue = credentials?.accountId ?? credentials?.AccountId;
+            return configValue;
+        };
     }
-    if (endpointFromConfig) {
-      clientConfig.endpoint = () => Promise.resolve(toEndpointV1(endpointFromConfig));
-      clientConfig.isCustomEndpoint = true;
+    if (configKey === "endpoint" || canonicalEndpointParamKey === "endpoint") {
+        return async () => {
+            if (config.isCustomEndpoint === false) {
+                return undefined;
+            }
+            const endpoint = await configProvider();
+            if (endpoint && typeof endpoint === "object") {
+                if ("url" in endpoint) {
+                    return endpoint.url.href;
+                }
+                if ("hostname" in endpoint) {
+                    const { protocol, hostname, port, path } = endpoint;
+                    return `${protocol}//${hostname}${port ? ":" + port : ""}${path}`;
+                }
+            }
+            return endpoint;
+        };
     }
-  }
-  const endpointParams = await resolveParams(commandInput, instructionsSupplier, clientConfig);
-  if (typeof clientConfig.endpointProvider !== "function") {
-    throw new Error("config.endpointProvider is not set.");
-  }
-  const endpoint = clientConfig.endpointProvider(endpointParams, context);
-  return endpoint;
-}, "getEndpointFromInstructions");
-var resolveParams = /* @__PURE__ */ __name(async (commandInput, instructionsSupplier, clientConfig) => {
-  const endpointParams = {};
-  const instructions = instructionsSupplier?.getEndpointParameterInstructions?.() || {};
-  for (const [name, instruction] of Object.entries(instructions)) {
-    switch (instruction.type) {
-      case "staticContextParams":
-        endpointParams[name] = instruction.value;
-        break;
-      case "contextParams":
-        endpointParams[name] = commandInput[instruction.name];
-        break;
-      case "clientContextParams":
-      case "builtInParams":
-        endpointParams[name] = await createConfigValueProvider(instruction.name, name, clientConfig)();
-        break;
-      case "operationContextParams":
-        endpointParams[name] = instruction.get(commandInput);
-        break;
-      default:
-        throw new Error("Unrecognized endpoint parameter instruction: " + JSON.stringify(instruction));
+    return configProvider;
+};
+
+const toEndpointV1 = (endpoint) => {
+    if (typeof endpoint === "object") {
+        if ("url" in endpoint) {
+            return urlParser.parseUrl(endpoint.url);
+        }
+        return endpoint;
     }
-  }
-  if (Object.keys(instructions).length === 0) {
-    Object.assign(endpointParams, clientConfig);
-  }
-  if (String(clientConfig.serviceId).toLowerCase() === "s3") {
-    await resolveParamsForS3(endpointParams);
-  }
-  return endpointParams;
-}, "resolveParams");
+    return urlParser.parseUrl(endpoint);
+};
 
-// src/endpointMiddleware.ts
-var import_core = require("@smithy/core");
-var import_util_middleware = require("@smithy/util-middleware");
-var endpointMiddleware = /* @__PURE__ */ __name(({
-  config,
-  instructions
-}) => {
-  return (next, context) => async (args) => {
-    if (config.isCustomEndpoint) {
-      (0, import_core.setFeature)(context, "ENDPOINT_OVERRIDE", "N");
+const getEndpointFromInstructions = async (commandInput, instructionsSupplier, clientConfig, context) => {
+    if (!clientConfig.isCustomEndpoint) {
+        let endpointFromConfig;
+        if (clientConfig.serviceConfiguredEndpoint) {
+            endpointFromConfig = await clientConfig.serviceConfiguredEndpoint();
+        }
+        else {
+            endpointFromConfig = await getEndpointFromConfig.getEndpointFromConfig(clientConfig.serviceId);
+        }
+        if (endpointFromConfig) {
+            clientConfig.endpoint = () => Promise.resolve(toEndpointV1(endpointFromConfig));
+            clientConfig.isCustomEndpoint = true;
+        }
     }
-    const endpoint = await getEndpointFromInstructions(
-      args.input,
-      {
-        getEndpointParameterInstructions() {
-          return instructions;
+    const endpointParams = await resolveParams(commandInput, instructionsSupplier, clientConfig);
+    if (typeof clientConfig.endpointProvider !== "function") {
+        throw new Error("config.endpointProvider is not set.");
+    }
+    const endpoint = clientConfig.endpointProvider(endpointParams, context);
+    return endpoint;
+};
+const resolveParams = async (commandInput, instructionsSupplier, clientConfig) => {
+    const endpointParams = {};
+    const instructions = instructionsSupplier?.getEndpointParameterInstructions?.() || {};
+    for (const [name, instruction] of Object.entries(instructions)) {
+        switch (instruction.type) {
+            case "staticContextParams":
+                endpointParams[name] = instruction.value;
+                break;
+            case "contextParams":
+                endpointParams[name] = commandInput[instruction.name];
+                break;
+            case "clientContextParams":
+            case "builtInParams":
+                endpointParams[name] = await createConfigValueProvider(instruction.name, name, clientConfig)();
+                break;
+            case "operationContextParams":
+                endpointParams[name] = instruction.get(commandInput);
+                break;
+            default:
+                throw new Error("Unrecognized endpoint parameter instruction: " + JSON.stringify(instruction));
         }
-      },
-      { ...config },
-      context
-    );
-    context.endpointV2 = endpoint;
-    context.authSchemes = endpoint.properties?.authSchemes;
-    const authScheme = context.authSchemes?.[0];
-    if (authScheme) {
-      context["signing_region"] = authScheme.signingRegion;
-      context["signing_service"] = authScheme.signingName;
-      const smithyContext = (0, import_util_middleware.getSmithyContext)(context);
-      const httpAuthOption = smithyContext?.selectedHttpAuthScheme?.httpAuthOption;
-      if (httpAuthOption) {
-        httpAuthOption.signingProperties = Object.assign(
-          httpAuthOption.signingProperties || {},
-          {
-            signing_region: authScheme.signingRegion,
-            signingRegion: authScheme.signingRegion,
-            signing_service: authScheme.signingName,
-            signingName: authScheme.signingName,
-            signingRegionSet: authScheme.signingRegionSet
-          },
-          authScheme.properties
-        );
-      }
     }
-    return next({
-      ...args
-    });
-  };
-}, "endpointMiddleware");
-
-// src/getEndpointPlugin.ts
-var import_middleware_serde = require("@smithy/middleware-serde");
-var endpointMiddlewareOptions = {
-  step: "serialize",
-  tags: ["ENDPOINT_PARAMETERS", "ENDPOINT_V2", "ENDPOINT"],
-  name: "endpointV2Middleware",
-  override: true,
-  relation: "before",
-  toMiddleware: import_middleware_serde.serializerMiddlewareOption.name
+    if (Object.keys(instructions).length === 0) {
+        Object.assign(endpointParams, clientConfig);
+    }
+    if (String(clientConfig.serviceId).toLowerCase() === "s3") {
+        await resolveParamsForS3(endpointParams);
+    }
+    return endpointParams;
 };
-var getEndpointPlugin = /* @__PURE__ */ __name((config, instructions) => ({
-  applyToStack: /* @__PURE__ */ __name((clientStack) => {
-    clientStack.addRelativeTo(
-      endpointMiddleware({
-        config,
-        instructions
-      }),
-      endpointMiddlewareOptions
-    );
-  }, "applyToStack")
-}), "getEndpointPlugin");
 
-// src/resolveEndpointConfig.ts
+const endpointMiddleware = ({ config, instructions, }) => {
+    return (next, context) => async (args) => {
+        if (config.isCustomEndpoint) {
+            core.setFeature(context, "ENDPOINT_OVERRIDE", "N");
+        }
+        const endpoint = await getEndpointFromInstructions(args.input, {
+            getEndpointParameterInstructions() {
+                return instructions;
+            },
+        }, { ...config }, context);
+        context.endpointV2 = endpoint;
+        context.authSchemes = endpoint.properties?.authSchemes;
+        const authScheme = context.authSchemes?.[0];
+        if (authScheme) {
+            context["signing_region"] = authScheme.signingRegion;
+            context["signing_service"] = authScheme.signingName;
+            const smithyContext = utilMiddleware.getSmithyContext(context);
+            const httpAuthOption = smithyContext?.selectedHttpAuthScheme?.httpAuthOption;
+            if (httpAuthOption) {
+                httpAuthOption.signingProperties = Object.assign(httpAuthOption.signingProperties || {}, {
+                    signing_region: authScheme.signingRegion,
+                    signingRegion: authScheme.signingRegion,
+                    signing_service: authScheme.signingName,
+                    signingName: authScheme.signingName,
+                    signingRegionSet: authScheme.signingRegionSet,
+                }, authScheme.properties);
+            }
+        }
+        return next({
+            ...args,
+        });
+    };
+};
 
-var import_getEndpointFromConfig2 = require("./adaptors/getEndpointFromConfig");
-var resolveEndpointConfig = /* @__PURE__ */ __name((input) => {
-  const tls = input.tls ?? true;
-  const { endpoint, useDualstackEndpoint, useFipsEndpoint } = input;
-  const customEndpointProvider = endpoint != null ? async () => toEndpointV1(await (0, import_util_middleware.normalizeProvider)(endpoint)()) : void 0;
-  const isCustomEndpoint = !!endpoint;
-  const resolvedConfig = Object.assign(input, {
-    endpoint: customEndpointProvider,
-    tls,
-    isCustomEndpoint,
-    useDualstackEndpoint: (0, import_util_middleware.normalizeProvider)(useDualstackEndpoint ?? false),
-    useFipsEndpoint: (0, import_util_middleware.normalizeProvider)(useFipsEndpoint ?? false)
-  });
-  let configuredEndpointPromise = void 0;
-  resolvedConfig.serviceConfiguredEndpoint = async () => {
-    if (input.serviceId && !configuredEndpointPromise) {
-      configuredEndpointPromise = (0, import_getEndpointFromConfig2.getEndpointFromConfig)(input.serviceId);
-    }
-    return configuredEndpointPromise;
-  };
-  return resolvedConfig;
-}, "resolveEndpointConfig");
+const endpointMiddlewareOptions = {
+    step: "serialize",
+    tags: ["ENDPOINT_PARAMETERS", "ENDPOINT_V2", "ENDPOINT"],
+    name: "endpointV2Middleware",
+    override: true,
+    relation: "before",
+    toMiddleware: middlewareSerde.serializerMiddlewareOption.name,
+};
+const getEndpointPlugin = (config, instructions) => ({
+    applyToStack: (clientStack) => {
+        clientStack.addRelativeTo(endpointMiddleware({
+            config,
+            instructions,
+        }), endpointMiddlewareOptions);
+    },
+});
 
-// src/resolveEndpointRequiredConfig.ts
-var resolveEndpointRequiredConfig = /* @__PURE__ */ __name((input) => {
-  const { endpoint } = input;
-  if (endpoint === void 0) {
-    input.endpoint = async () => {
-      throw new Error(
-        "@smithy/middleware-endpoint: (default endpointRuleSet) endpoint is not set - you must configure an endpoint."
-      );
+const resolveEndpointConfig = (input) => {
+    const tls = input.tls ?? true;
+    const { endpoint, useDualstackEndpoint, useFipsEndpoint } = input;
+    const customEndpointProvider = endpoint != null ? async () => toEndpointV1(await utilMiddleware.normalizeProvider(endpoint)()) : undefined;
+    const isCustomEndpoint = !!endpoint;
+    const resolvedConfig = Object.assign(input, {
+        endpoint: customEndpointProvider,
+        tls,
+        isCustomEndpoint,
+        useDualstackEndpoint: utilMiddleware.normalizeProvider(useDualstackEndpoint ?? false),
+        useFipsEndpoint: utilMiddleware.normalizeProvider(useFipsEndpoint ?? false),
+    });
+    let configuredEndpointPromise = undefined;
+    resolvedConfig.serviceConfiguredEndpoint = async () => {
+        if (input.serviceId && !configuredEndpointPromise) {
+            configuredEndpointPromise = getEndpointFromConfig.getEndpointFromConfig(input.serviceId);
+        }
+        return configuredEndpointPromise;
     };
-  }
-  return input;
-}, "resolveEndpointRequiredConfig");
-// Annotate the CommonJS export names for ESM import in node:
+    return resolvedConfig;
+};
 
-0 && (module.exports = {
-  getEndpointFromInstructions,
-  resolveParams,
-  toEndpointV1,
-  endpointMiddleware,
-  endpointMiddlewareOptions,
-  getEndpointPlugin,
-  resolveEndpointConfig,
-  resolveEndpointRequiredConfig
-});
+const resolveEndpointRequiredConfig = (input) => {
+    const { endpoint } = input;
+    if (endpoint === undefined) {
+        input.endpoint = async () => {
+            throw new Error("@smithy/middleware-endpoint: (default endpointRuleSet) endpoint is not set - you must configure an endpoint.");
+        };
+    }
+    return input;
+};
 
+exports.endpointMiddleware = endpointMiddleware;
+exports.endpointMiddlewareOptions = endpointMiddlewareOptions;
+exports.getEndpointFromInstructions = getEndpointFromInstructions;
+exports.getEndpointPlugin = getEndpointPlugin;
+exports.resolveEndpointConfig = resolveEndpointConfig;
+exports.resolveEndpointRequiredConfig = resolveEndpointRequiredConfig;
+exports.resolveParams = resolveParams;
+exports.toEndpointV1 = toEndpointV1;

package/node_modules/@smithy/middleware-endpoint/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@smithy/middleware-endpoint",
-  "version": "4.2.5",
+  "version": "4.3.0",
   "scripts": {
     "build": "concurrently 'yarn:build:cjs' 'yarn:build:es' 'yarn:build:types && yarn build:types:downlevel'",
     "build:cjs": "node ../../scripts/inline middleware-endpoint",
@@ -25,13 +25,13 @@
   "license": "Apache-2.0",
   "sideEffects": false,
   "dependencies": {
-    "@smithy/core": "^3.13.0",
-    "@smithy/middleware-serde": "^4.1.1",
-    "@smithy/node-config-provider": "^4.2.2",
-    "@smithy/shared-ini-file-loader": "^4.2.0",
-    "@smithy/types": "^4.5.0",
-    "@smithy/url-parser": "^4.1.1",
-    "@smithy/util-middleware": "^4.1.1",
+    "@smithy/core": "^3.14.0",
+    "@smithy/middleware-serde": "^4.2.0",
+    "@smithy/node-config-provider": "^4.3.0",
+    "@smithy/shared-ini-file-loader": "^4.3.0",
+    "@smithy/types": "^4.6.0",
+    "@smithy/url-parser": "^4.2.0",
+    "@smithy/util-middleware": "^4.2.0",
     "tslib": "^2.6.2"
   },
   "devDependencies": {