@aws-sdk/config-resolver - npm Package Compare versions

Comparing version 3.186.0 to 3.188.0

dist-es/endpointsConfig/NodeUseDualstackEndpointConfigOptions.js

 import { booleanSelector, SelectorType } from "@aws-sdk/util-config-provider";
-export var ENV_USE_DUALSTACK_ENDPOINT = "AWS_USE_DUALSTACK_ENDPOINT";
-export var CONFIG_USE_DUALSTACK_ENDPOINT = "use_dualstack_endpoint";
-export var DEFAULT_USE_DUALSTACK_ENDPOINT = false;
-export var NODE_USE_DUALSTACK_ENDPOINT_CONFIG_OPTIONS = {
-    environmentVariableSelector: function (env) {
-        return booleanSelector(env, ENV_USE_DUALSTACK_ENDPOINT, SelectorType.ENV);
-    },
-    configFileSelector: function (profile) { return booleanSelector(profile, CONFIG_USE_DUALSTACK_ENDPOINT, SelectorType.CONFIG); },
+export const ENV_USE_DUALSTACK_ENDPOINT = "AWS_USE_DUALSTACK_ENDPOINT";
+export const CONFIG_USE_DUALSTACK_ENDPOINT = "use_dualstack_endpoint";
+export const DEFAULT_USE_DUALSTACK_ENDPOINT = false;
+export const NODE_USE_DUALSTACK_ENDPOINT_CONFIG_OPTIONS = {
+    environmentVariableSelector: (env) => booleanSelector(env, ENV_USE_DUALSTACK_ENDPOINT, SelectorType.ENV),
+    configFileSelector: (profile) => booleanSelector(profile, CONFIG_USE_DUALSTACK_ENDPOINT, SelectorType.CONFIG),
     default: false,
 };

dist-es/endpointsConfig/NodeUseFipsEndpointConfigOptions.js

 import { booleanSelector, SelectorType } from "@aws-sdk/util-config-provider";
-export var ENV_USE_FIPS_ENDPOINT = "AWS_USE_FIPS_ENDPOINT";
-export var CONFIG_USE_FIPS_ENDPOINT = "use_fips_endpoint";
-export var DEFAULT_USE_FIPS_ENDPOINT = false;
-export var NODE_USE_FIPS_ENDPOINT_CONFIG_OPTIONS = {
-    environmentVariableSelector: function (env) {
-        return booleanSelector(env, ENV_USE_FIPS_ENDPOINT, SelectorType.ENV);
-    },
-    configFileSelector: function (profile) { return booleanSelector(profile, CONFIG_USE_FIPS_ENDPOINT, SelectorType.CONFIG); },
+export const ENV_USE_FIPS_ENDPOINT = "AWS_USE_FIPS_ENDPOINT";
+export const CONFIG_USE_FIPS_ENDPOINT = "use_fips_endpoint";
+export const DEFAULT_USE_FIPS_ENDPOINT = false;
+export const NODE_USE_FIPS_ENDPOINT_CONFIG_OPTIONS = {
+    environmentVariableSelector: (env) => booleanSelector(env, ENV_USE_FIPS_ENDPOINT, SelectorType.ENV),
+    configFileSelector: (profile) => booleanSelector(profile, CONFIG_USE_FIPS_ENDPOINT, SelectorType.CONFIG),
     default: false,
 };

dist-es/endpointsConfig/resolveCustomEndpointsConfig.js

@@ -1,7 +0,11 @@
-import { __assign } from "tslib";
 import { normalizeProvider } from "@aws-sdk/util-middleware";
-export var resolveCustomEndpointsConfig = function (input) {
-    var _a;
-    var endpoint = input.endpoint, urlParser = input.urlParser;
-    return __assign(__assign({}, input), { tls: (_a = input.tls) !== null && _a !== void 0 ? _a : true, endpoint: normalizeProvider(typeof endpoint === "string" ? urlParser(endpoint) : endpoint), isCustomEndpoint: true, useDualstackEndpoint: normalizeProvider(input.useDualstackEndpoint) });
+export const resolveCustomEndpointsConfig = (input) => {
+    const { endpoint, urlParser } = input;
+    return {
+        ...input,
+        tls: input.tls ?? true,
+        endpoint: normalizeProvider(typeof endpoint === "string" ? urlParser(endpoint) : endpoint),
+        isCustomEndpoint: true,
+        useDualstackEndpoint: normalizeProvider(input.useDualstackEndpoint),
+    };
 };

dist-es/endpointsConfig/resolveEndpointsConfig.js

@@ -1,11 +0,15 @@
-import { __assign } from "tslib";
 import { normalizeProvider } from "@aws-sdk/util-middleware";
 import { getEndpointFromRegion } from "./utils/getEndpointFromRegion";
-export var resolveEndpointsConfig = function (input) {
-    var _a;
-    var useDualstackEndpoint = normalizeProvider(input.useDualstackEndpoint);
-    var endpoint = input.endpoint, useFipsEndpoint = input.useFipsEndpoint, urlParser = input.urlParser;
-    return __assign(__assign({}, input), { tls: (_a = input.tls) !== null && _a !== void 0 ? _a : true, endpoint: endpoint
+export const resolveEndpointsConfig = (input) => {
+    const useDualstackEndpoint = normalizeProvider(input.useDualstackEndpoint);
+    const { endpoint, useFipsEndpoint, urlParser } = input;
+    return {
+        ...input,
+        tls: input.tls ?? true,
+        endpoint: endpoint
             ? normalizeProvider(typeof endpoint === "string" ? urlParser(endpoint) : endpoint)
-            : function () { return getEndpointFromRegion(__assign(__assign({}, input), { useDualstackEndpoint: useDualstackEndpoint, useFipsEndpoint: useFipsEndpoint })); }, isCustomEndpoint: !!endpoint, useDualstackEndpoint: useDualstackEndpoint });
+            : () => getEndpointFromRegion({ ...input, useDualstackEndpoint, useFipsEndpoint }),
+        isCustomEndpoint: !!endpoint,
+        useDualstackEndpoint,
+    };
 };

dist-es/endpointsConfig/utils/getEndpointFromRegion.js

@@ -1,31 +0,15 @@
-import { __awaiter, __generator } from "tslib";
-export var getEndpointFromRegion = function (input) { return __awaiter(void 0, void 0, void 0, function () {
-    var _a, tls, region, dnsHostRegex, useDualstackEndpoint, useFipsEndpoint, hostname;
-    var _b;
-    return __generator(this, function (_c) {
-        switch (_c.label) {
-            case 0:
-                _a = input.tls, tls = _a === void 0 ? true : _a;
-                return [4, input.region()];
-            case 1:
-                region = _c.sent();
-                dnsHostRegex = new RegExp(/^([a-zA-Z0-9]|[a-zA-Z0-9][a-zA-Z0-9-]{0,61}[a-zA-Z0-9])$/);
-                if (!dnsHostRegex.test(region)) {
-                    throw new Error("Invalid region in client config");
-                }
-                return [4, input.useDualstackEndpoint()];
-            case 2:
-                useDualstackEndpoint = _c.sent();
-                return [4, input.useFipsEndpoint()];
-            case 3:
-                useFipsEndpoint = _c.sent();
-                return [4, input.regionInfoProvider(region, { useDualstackEndpoint: useDualstackEndpoint, useFipsEndpoint: useFipsEndpoint })];
-            case 4:
-                hostname = ((_b = (_c.sent())) !== null && _b !== void 0 ? _b : {}).hostname;
-                if (!hostname) {
-                    throw new Error("Cannot resolve hostname from client config");
-                }
-                return [2, input.urlParser("".concat(tls ? "https:" : "http:", "//").concat(hostname))];
-        }
-    });
-}); };
+export const getEndpointFromRegion = async (input) => {
+    const { tls = true } = input;
+    const region = await input.region();
+    const dnsHostRegex = new RegExp(/^([a-zA-Z0-9]|[a-zA-Z0-9][a-zA-Z0-9-]{0,61}[a-zA-Z0-9])$/);
+    if (!dnsHostRegex.test(region)) {
+        throw new Error("Invalid region in client config");
+    }
+    const useDualstackEndpoint = await input.useDualstackEndpoint();
+    const useFipsEndpoint = await input.useFipsEndpoint();
+    const { hostname } = (await input.regionInfoProvider(region, { useDualstackEndpoint, useFipsEndpoint })) ?? {};
+    if (!hostname) {
+        throw new Error("Cannot resolve hostname from client config");
+    }
+    return input.urlParser(`${tls ? "https:" : "http:"}//${hostname}`);
+};

dist-es/regionConfig/config.js

@@ -1,12 +0,12 @@
-export var REGION_ENV_NAME = "AWS_REGION";
-export var REGION_INI_NAME = "region";
-export var NODE_REGION_CONFIG_OPTIONS = {
-    environmentVariableSelector: function (env) { return env[REGION_ENV_NAME]; },
-    configFileSelector: function (profile) { return profile[REGION_INI_NAME]; },
-    default: function () {
+export const REGION_ENV_NAME = "AWS_REGION";
+export const REGION_INI_NAME = "region";
+export const NODE_REGION_CONFIG_OPTIONS = {
+    environmentVariableSelector: (env) => env[REGION_ENV_NAME],
+    configFileSelector: (profile) => profile[REGION_INI_NAME],
+    default: () => {
         throw new Error("Region is missing");
     },
 };
-export var NODE_REGION_CONFIG_FILE_OPTIONS = {
+export const NODE_REGION_CONFIG_FILE_OPTIONS = {
     preferredFile: "credentials",
 };

dist-es/regionConfig/getRealRegion.js

 import { isFipsRegion } from "./isFipsRegion";
-export var getRealRegion = function (region) {
-    return isFipsRegion(region)
-        ? ["fips-aws-global", "aws-fips"].includes(region)
-            ? "us-east-1"
-            : region.replace(/fips-(dkr-|prod-)?|-fips/, "")
-        : region;
-};
+export const getRealRegion = (region) => isFipsRegion(region)
+    ? ["fips-aws-global", "aws-fips"].includes(region)
+        ? "us-east-1"
+        : region.replace(/fips-(dkr-|prod-)?|-fips/, "")
+    : region;

dist-es/regionConfig/isFipsRegion.js

@@ -1,3 +0,1 @@
-export var isFipsRegion = function (region) {
-    return typeof region === "string" && (region.startsWith("fips-") || region.endsWith("-fips"));
-};
+export const isFipsRegion = (region) => typeof region === "string" && (region.startsWith("fips-") || region.endsWith("-fips"));

dist-es/regionConfig/resolveRegionConfig.js

@@ -1,44 +0,25 @@
-import { __assign, __awaiter, __generator } from "tslib";
 import { getRealRegion } from "./getRealRegion";
 import { isFipsRegion } from "./isFipsRegion";
-export var resolveRegionConfig = function (input) {
-    var region = input.region, useFipsEndpoint = input.useFipsEndpoint;
+export const resolveRegionConfig = (input) => {
+    const { region, useFipsEndpoint } = input;
     if (!region) {
         throw new Error("Region is missing");
     }
-    return __assign(__assign({}, input), { region: function () { return __awaiter(void 0, void 0, void 0, function () {
-            var providedRegion;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        if (typeof region === "string") {
-                            return [2, getRealRegion(region)];
-                        }
-                        return [4, region()];
-                    case 1:
-                        providedRegion = _a.sent();
-                        return [2, getRealRegion(providedRegion)];
-                }
-            });
-        }); }, useFipsEndpoint: function () { return __awaiter(void 0, void 0, void 0, function () {
-            var providedRegion, _a;
-            return __generator(this, function (_b) {
-                switch (_b.label) {
-                    case 0:
-                        if (!(typeof region === "string")) return [3, 1];
-                        _a = region;
-                        return [3, 3];
-                    case 1: return [4, region()];
-                    case 2:
-                        _a = _b.sent();
-                        _b.label = 3;
-                    case 3:
-                        providedRegion = _a;
-                        if (isFipsRegion(providedRegion)) {
-                            return [2, true];
-                        }
-                        return [2, typeof useFipsEndpoint === "boolean" ? Promise.resolve(useFipsEndpoint) : useFipsEndpoint()];
-                }
-            });
-        }); } });
+    return {
+        ...input,
+        region: async () => {
+            if (typeof region === "string") {
+                return getRealRegion(region);
+            }
+            const providedRegion = await region();
+            return getRealRegion(providedRegion);
+        },
+        useFipsEndpoint: async () => {
+            const providedRegion = typeof region === "string" ? region : await region();
+            if (isFipsRegion(providedRegion)) {
+                return true;
+            }
+            return typeof useFipsEndpoint === "boolean" ? Promise.resolve(useFipsEndpoint) : useFipsEndpoint();
+        },
+    };
 };

dist-es/regionInfo/getHostnameFromVariants.js

@@ -1,9 +0,1 @@
-export var getHostnameFromVariants = function (variants, _a) {
-    var _b;
-    if (variants === void 0) { variants = []; }
-    var useFipsEndpoint = _a.useFipsEndpoint, useDualstackEndpoint = _a.useDualstackEndpoint;
-    return (_b = variants.find(function (_a) {
-        var tags = _a.tags;
-        return useFipsEndpoint === tags.includes("fips") && useDualstackEndpoint === tags.includes("dualstack");
-    })) === null || _b === void 0 ? void 0 : _b.hostname;
-};
+export const getHostnameFromVariants = (variants = [], { useFipsEndpoint, useDualstackEndpoint }) => variants.find(({ tags }) => useFipsEndpoint === tags.includes("fips") && useDualstackEndpoint === tags.includes("dualstack"))?.hostname;

dist-es/regionInfo/getRegionInfo.js

@@ -1,2 +0,1 @@
-import { __assign } from "tslib";
 import { getHostnameFromVariants } from "./getHostnameFromVariants";
@@ -6,22 +5,26 @@ import { getResolvedHostname } from "./getResolvedHostname";
 import { getResolvedSigningRegion } from "./getResolvedSigningRegion";
-export var getRegionInfo = function (region, _a) {
-    var _b, _c, _d, _e, _f, _g;
-    var _h = _a.useFipsEndpoint, useFipsEndpoint = _h === void 0 ? false : _h, _j = _a.useDualstackEndpoint, useDualstackEndpoint = _j === void 0 ? false : _j, signingService = _a.signingService, regionHash = _a.regionHash, partitionHash = _a.partitionHash;
-    var partition = getResolvedPartition(region, { partitionHash: partitionHash });
-    var resolvedRegion = region in regionHash ? region : (_c = (_b = partitionHash[partition]) === null || _b === void 0 ? void 0 : _b.endpoint) !== null && _c !== void 0 ? _c : region;
-    var hostnameOptions = { useFipsEndpoint: useFipsEndpoint, useDualstackEndpoint: useDualstackEndpoint };
-    var regionHostname = getHostnameFromVariants((_d = regionHash[resolvedRegion]) === null || _d === void 0 ? void 0 : _d.variants, hostnameOptions);
-    var partitionHostname = getHostnameFromVariants((_e = partitionHash[partition]) === null || _e === void 0 ? void 0 : _e.variants, hostnameOptions);
-    var hostname = getResolvedHostname(resolvedRegion, { regionHostname: regionHostname, partitionHostname: partitionHostname });
+export const getRegionInfo = (region, { useFipsEndpoint = false, useDualstackEndpoint = false, signingService, regionHash, partitionHash, }) => {
+    const partition = getResolvedPartition(region, { partitionHash });
+    const resolvedRegion = region in regionHash ? region : partitionHash[partition]?.endpoint ?? region;
+    const hostnameOptions = { useFipsEndpoint, useDualstackEndpoint };
+    const regionHostname = getHostnameFromVariants(regionHash[resolvedRegion]?.variants, hostnameOptions);
+    const partitionHostname = getHostnameFromVariants(partitionHash[partition]?.variants, hostnameOptions);
+    const hostname = getResolvedHostname(resolvedRegion, { regionHostname, partitionHostname });
     if (hostname === undefined) {
-        throw new Error("Endpoint resolution failed for: ".concat({ resolvedRegion: resolvedRegion, useFipsEndpoint: useFipsEndpoint, useDualstackEndpoint: useDualstackEndpoint }));
+        throw new Error(`Endpoint resolution failed for: ${{ resolvedRegion, useFipsEndpoint, useDualstackEndpoint }}`);
     }
-    var signingRegion = getResolvedSigningRegion(hostname, {
-        signingRegion: (_f = regionHash[resolvedRegion]) === null || _f === void 0 ? void 0 : _f.signingRegion,
+    const signingRegion = getResolvedSigningRegion(hostname, {
+        signingRegion: regionHash[resolvedRegion]?.signingRegion,
         regionRegex: partitionHash[partition].regionRegex,
-        useFipsEndpoint: useFipsEndpoint,
+        useFipsEndpoint,
     });
-    return __assign(__assign({ partition: partition, signingService: signingService, hostname: hostname }, (signingRegion && { signingRegion: signingRegion })), (((_g = regionHash[resolvedRegion]) === null || _g === void 0 ? void 0 : _g.signingService) && {
-        signingService: regionHash[resolvedRegion].signingService,
-    }));
+    return {
+        partition,
+        signingService,
+        hostname,
+        ...(signingRegion && { signingRegion }),
+        ...(regionHash[resolvedRegion]?.signingService && {
+            signingService: regionHash[resolvedRegion].signingService,
+        }),
+    };
 };

dist-es/regionInfo/getResolvedHostname.js

@@ -1,8 +0,5 @@
-export var getResolvedHostname = function (resolvedRegion, _a) {
-    var regionHostname = _a.regionHostname, partitionHostname = _a.partitionHostname;
-    return regionHostname
-        ? regionHostname
-        : partitionHostname
-            ? partitionHostname.replace("{region}", resolvedRegion)
-            : undefined;
-};
+export const getResolvedHostname = (resolvedRegion, { regionHostname, partitionHostname }) => regionHostname
+    ? regionHostname
+    : partitionHostname
+        ? partitionHostname.replace("{region}", resolvedRegion)
+        : undefined;

dist-es/regionInfo/getResolvedPartition.js

@@ -1,5 +0,1 @@
-export var getResolvedPartition = function (region, _a) {
-    var _b;
-    var partitionHash = _a.partitionHash;
-    return (_b = Object.keys(partitionHash || {}).find(function (key) { return partitionHash[key].regions.includes(region); })) !== null && _b !== void 0 ? _b : "aws";
-};
+export const getResolvedPartition = (region, { partitionHash }) => Object.keys(partitionHash || {}).find((key) => partitionHash[key].regions.includes(region)) ?? "aws";

dist-es/regionInfo/getResolvedSigningRegion.js

@@ -1,3 +0,2 @@
-export var getResolvedSigningRegion = function (hostname, _a) {
-    var signingRegion = _a.signingRegion, regionRegex = _a.regionRegex, useFipsEndpoint = _a.useFipsEndpoint;
+export const getResolvedSigningRegion = (hostname, { signingRegion, regionRegex, useFipsEndpoint }) => {
     if (signingRegion) {
@@ -7,4 +6,4 @@ return signingRegion;
     else if (useFipsEndpoint) {
-        var regionRegexJs = regionRegex.replace("\\\\", "\\").replace(/^\^/g, "\\.").replace(/\$$/g, "\\.");
-        var regionRegexmatchArray = hostname.match(regionRegexJs);
+        const regionRegexJs = regionRegex.replace("\\\\", "\\").replace(/^\^/g, "\\.").replace(/\$$/g, "\\.");
+        const regionRegexmatchArray = hostname.match(regionRegexJs);
         if (regionRegexmatchArray) {
@@ -11,0 +10,0 @@ return regionRegexmatchArray[0].slice(1, -1);

package.json

 {
   "name": "@aws-sdk/config-resolver",
-  "version": "3.186.0",
+  "version": "3.188.0",
   "scripts": {
@@ -23,10 +23,10 @@ "build": "concurrently 'yarn:build:cjs' 'yarn:build:es' 'yarn:build:types'",
   "dependencies": {
-    "@aws-sdk/signature-v4": "3.186.0",
-    "@aws-sdk/types": "3.186.0",
-    "@aws-sdk/util-config-provider": "3.186.0",
-    "@aws-sdk/util-middleware": "3.186.0",
+    "@aws-sdk/signature-v4": "3.188.0",
+    "@aws-sdk/types": "3.188.0",
+    "@aws-sdk/util-config-provider": "3.188.0",
+    "@aws-sdk/util-middleware": "3.188.0",
     "tslib": "^2.3.1"
   },
   "devDependencies": {
-    "@aws-sdk/node-config-provider": "3.186.0",
+    "@aws-sdk/node-config-provider": "3.188.0",
     "@tsconfig/recommended": "1.0.1",
@@ -33,0 +33,0 @@ "concurrently": "7.0.0",

New alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Fixed alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Worsened metrics

Total package byte prevSize

116542

decreased by-2.74%

Lines of code

789

decreased by-5.73%

Dependency changes

• + Added@aws-sdk/is-array-buffer@3.188.0(transitive)

• + Added@aws-sdk/signature-v4@3.188.0(transitive)

• + Added@aws-sdk/types@3.188.0(transitive)

• + Added@aws-sdk/util-config-provider@3.188.0(transitive)

• + Added@aws-sdk/util-hex-encoding@3.188.0(transitive)

• + Added@aws-sdk/util-middleware@3.188.0(transitive)

• + Added@aws-sdk/util-uri-escape@3.188.0(transitive)

• - Removed@aws-sdk/is-array-buffer@3.186.0(transitive)

• - Removed@aws-sdk/signature-v4@3.186.0(transitive)

• - Removed@aws-sdk/types@3.186.0(transitive)

• - Removed@aws-sdk/util-config-provider@3.186.0(transitive)

• - Removed@aws-sdk/util-hex-encoding@3.186.0(transitive)

• - Removed@aws-sdk/util-middleware@3.186.0(transitive)

• - Removed@aws-sdk/util-uri-escape@3.186.0(transitive)

• Updated@aws-sdk/signature-v4@3.188.0

• Updated@aws-sdk/types@3.188.0

• Updated@aws-sdk/util-config-provider@3.188.0

• Updated@aws-sdk/util-middleware@3.188.0