@aws-sdk/middleware-endpoint-discovery 3.183.0 → 3.186.0

package/CHANGELOG.md

@@ -3,6 +3,14 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+# [3.186.0](https://github.com/aws/aws-sdk-js-v3/compare/v3.185.0...v3.186.0) (2022-10-06)
+
+**Note:** Version bump only for package @aws-sdk/middleware-endpoint-discovery
+
+
+
+
+
 # [3.183.0](https://github.com/aws/aws-sdk-js-v3/compare/v3.182.0...v3.183.0) (2022-10-03)
 
 

package/dist-es/configurations.js

@@ -1,24 +1,24 @@
-const ENV_ENDPOINT_DISCOVERY = ["AWS_ENABLE_ENDPOINT_DISCOVERY", "AWS_ENDPOINT_DISCOVERY_ENABLED"];
-const CONFIG_ENDPOINT_DISCOVERY = "endpoint_discovery_enabled";
-const isFalsy = (value) => ["false", "0"].indexOf(value) >= 0;
-export const NODE_ENDPOINT_DISCOVERY_CONFIG_OPTIONS = {
-    environmentVariableSelector: (env) => {
-        for (let i = 0; i < ENV_ENDPOINT_DISCOVERY.length; i++) {
-            const envKey = ENV_ENDPOINT_DISCOVERY[i];
+var ENV_ENDPOINT_DISCOVERY = ["AWS_ENABLE_ENDPOINT_DISCOVERY", "AWS_ENDPOINT_DISCOVERY_ENABLED"];
+var CONFIG_ENDPOINT_DISCOVERY = "endpoint_discovery_enabled";
+var isFalsy = function (value) { return ["false", "0"].indexOf(value) >= 0; };
+export var NODE_ENDPOINT_DISCOVERY_CONFIG_OPTIONS = {
+    environmentVariableSelector: function (env) {
+        for (var i = 0; i < ENV_ENDPOINT_DISCOVERY.length; i++) {
+            var envKey = ENV_ENDPOINT_DISCOVERY[i];
             if (envKey in env) {
-                const value = env[envKey];
+                var value = env[envKey];
                 if (value === "") {
-                    throw Error(`Environment variable ${envKey} can't be empty of undefined, got "${value}"`);
+                    throw Error("Environment variable ".concat(envKey, " can't be empty of undefined, got \"").concat(value, "\""));
                 }
                 return !isFalsy(value);
             }
         }
     },
-    configFileSelector: (profile) => {
+    configFileSelector: function (profile) {
         if (CONFIG_ENDPOINT_DISCOVERY in profile) {
-            const value = profile[CONFIG_ENDPOINT_DISCOVERY];
+            var value = profile[CONFIG_ENDPOINT_DISCOVERY];
             if (value === undefined) {
-                throw Error(`Shared config entry ${CONFIG_ENDPOINT_DISCOVERY} can't be undefined, got "${value}"`);
+                throw Error("Shared config entry ".concat(CONFIG_ENDPOINT_DISCOVERY, " can't be undefined, got \"").concat(value, "\""));
             }
             return !isFalsy(value);
         }

package/dist-es/endpointDiscoveryMiddleware.js

@@ -1,44 +1,54 @@
+import { __assign, __awaiter, __generator } from "tslib";
 import { HttpRequest } from "@aws-sdk/protocol-http";
 import { getCacheKey } from "./getCacheKey";
 import { updateDiscoveredEndpointInCache } from "./updateDiscoveredEndpointInCache";
-export const endpointDiscoveryMiddleware = (config, middlewareConfig) => (next, context) => async (args) => {
-    if (config.isCustomEndpoint) {
-        if (config.isClientEndpointDiscoveryEnabled) {
-            throw new Error(`Custom endpoint is supplied; endpointDiscoveryEnabled must not be true.`);
-        }
-        return next(args);
-    }
-    const { endpointDiscoveryCommandCtor } = config;
-    const { isDiscoveredEndpointRequired, identifiers } = middlewareConfig;
-    const { clientName, commandName } = context;
-    const isEndpointDiscoveryEnabled = await config.endpointDiscoveryEnabled();
-    const cacheKey = await getCacheKey(commandName, config, { identifiers });
-    if (isDiscoveredEndpointRequired) {
-        if (isEndpointDiscoveryEnabled === false) {
-            throw new Error(`Endpoint Discovery is disabled but ${commandName} on ${clientName} requires it.` +
-                ` Please check your configurations.`);
-        }
-        await updateDiscoveredEndpointInCache(config, {
-            ...middlewareConfig,
-            commandName,
-            cacheKey,
-            endpointDiscoveryCommandCtor,
-        });
-    }
-    else if (isEndpointDiscoveryEnabled) {
-        updateDiscoveredEndpointInCache(config, {
-            ...middlewareConfig,
-            commandName,
-            cacheKey,
-            endpointDiscoveryCommandCtor,
-        });
-    }
-    const { request } = args;
-    if (cacheKey && HttpRequest.isInstance(request)) {
-        const endpoint = config.endpointCache.getEndpoint(cacheKey);
-        if (endpoint) {
-            request.hostname = endpoint;
-        }
-    }
-    return next(args);
+export var endpointDiscoveryMiddleware = function (config, middlewareConfig) {
+    return function (next, context) {
+        return function (args) { return __awaiter(void 0, void 0, void 0, function () {
+            var endpointDiscoveryCommandCtor, isDiscoveredEndpointRequired, identifiers, clientName, commandName, isEndpointDiscoveryEnabled, cacheKey, request, endpoint;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (config.isCustomEndpoint) {
+                            if (config.isClientEndpointDiscoveryEnabled) {
+                                throw new Error("Custom endpoint is supplied; endpointDiscoveryEnabled must not be true.");
+                            }
+                            return [2, next(args)];
+                        }
+                        endpointDiscoveryCommandCtor = config.endpointDiscoveryCommandCtor;
+                        isDiscoveredEndpointRequired = middlewareConfig.isDiscoveredEndpointRequired, identifiers = middlewareConfig.identifiers;
+                        clientName = context.clientName, commandName = context.commandName;
+                        return [4, config.endpointDiscoveryEnabled()];
+                    case 1:
+                        isEndpointDiscoveryEnabled = _a.sent();
+                        return [4, getCacheKey(commandName, config, { identifiers: identifiers })];
+                    case 2:
+                        cacheKey = _a.sent();
+                        if (!isDiscoveredEndpointRequired) return [3, 4];
+                        if (isEndpointDiscoveryEnabled === false) {
+                            throw new Error("Endpoint Discovery is disabled but ".concat(commandName, " on ").concat(clientName, " requires it.") +
+                                " Please check your configurations.");
+                        }
+                        return [4, updateDiscoveredEndpointInCache(config, __assign(__assign({}, middlewareConfig), { commandName: commandName, cacheKey: cacheKey, endpointDiscoveryCommandCtor: endpointDiscoveryCommandCtor }))];
+                    case 3:
+                        _a.sent();
+                        return [3, 5];
+                    case 4:
+                        if (isEndpointDiscoveryEnabled) {
+                            updateDiscoveredEndpointInCache(config, __assign(__assign({}, middlewareConfig), { commandName: commandName, cacheKey: cacheKey, endpointDiscoveryCommandCtor: endpointDiscoveryCommandCtor }));
+                        }
+                        _a.label = 5;
+                    case 5:
+                        request = args.request;
+                        if (cacheKey && HttpRequest.isInstance(request)) {
+                            endpoint = config.endpointCache.getEndpoint(cacheKey);
+                            if (endpoint) {
+                                request.hostname = endpoint;
+                            }
+                        }
+                        return [2, next(args)];
+                }
+            });
+        }); };
+    };
 };

package/dist-es/getCacheKey.js

@@ -1,13 +1,22 @@
-export const getCacheKey = async (commandName, config, options) => {
-    const { accessKeyId } = await config.credentials();
-    const { identifiers } = options;
-    return JSON.stringify({
-        ...(accessKeyId && { accessKeyId }),
-        ...(identifiers && {
-            commandName,
-            identifiers: Object.entries(identifiers)
-                .sort()
-                .reduce((acc, [key, value]) => ({ ...acc, [key]: value }), {}),
-        }),
+import { __assign, __awaiter, __generator, __read } from "tslib";
+export var getCacheKey = function (commandName, config, options) { return __awaiter(void 0, void 0, void 0, function () {
+    var accessKeyId, identifiers;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0: return [4, config.credentials()];
+            case 1:
+                accessKeyId = (_a.sent()).accessKeyId;
+                identifiers = options.identifiers;
+                return [2, JSON.stringify(__assign(__assign({}, (accessKeyId && { accessKeyId: accessKeyId })), (identifiers && {
+                        commandName: commandName,
+                        identifiers: Object.entries(identifiers)
+                            .sort()
+                            .reduce(function (acc, _a) {
+                            var _b;
+                            var _c = __read(_a, 2), key = _c[0], value = _c[1];
+                            return (__assign(__assign({}, acc), (_b = {}, _b[key] = value, _b)));
+                        }, {}),
+                    })))];
+        }
     });
-};
+}); };

package/dist-es/getEndpointDiscoveryPlugin.js

@@ -1,22 +1,23 @@
+import { __assign } from "tslib";
 import { endpointDiscoveryMiddleware } from "./endpointDiscoveryMiddleware";
-export const endpointDiscoveryMiddlewareOptions = {
+export var endpointDiscoveryMiddlewareOptions = {
     name: "endpointDiscoveryMiddleware",
     step: "build",
     tags: ["ENDPOINT_DISCOVERY"],
     override: true,
 };
-export const getEndpointDiscoveryPlugin = (pluginConfig, middlewareConfig) => ({
-    applyToStack: (commandStack) => {
+export var getEndpointDiscoveryPlugin = function (pluginConfig, middlewareConfig) { return ({
+    applyToStack: function (commandStack) {
         commandStack.add(endpointDiscoveryMiddleware(pluginConfig, middlewareConfig), endpointDiscoveryMiddlewareOptions);
     },
-});
-export const getEndpointDiscoveryRequiredPlugin = (pluginConfig, middlewareConfig) => ({
-    applyToStack: (commandStack) => {
-        commandStack.add(endpointDiscoveryMiddleware(pluginConfig, { ...middlewareConfig, isDiscoveredEndpointRequired: true }), endpointDiscoveryMiddlewareOptions);
+}); };
+export var getEndpointDiscoveryRequiredPlugin = function (pluginConfig, middlewareConfig) { return ({
+    applyToStack: function (commandStack) {
+        commandStack.add(endpointDiscoveryMiddleware(pluginConfig, __assign(__assign({}, middlewareConfig), { isDiscoveredEndpointRequired: true })), endpointDiscoveryMiddlewareOptions);
     },
-});
-export const getEndpointDiscoveryOptionalPlugin = (pluginConfig, middlewareConfig) => ({
-    applyToStack: (commandStack) => {
-        commandStack.add(endpointDiscoveryMiddleware(pluginConfig, { ...middlewareConfig, isDiscoveredEndpointRequired: false }), endpointDiscoveryMiddlewareOptions);
+}); };
+export var getEndpointDiscoveryOptionalPlugin = function (pluginConfig, middlewareConfig) { return ({
+    applyToStack: function (commandStack) {
+        commandStack.add(endpointDiscoveryMiddleware(pluginConfig, __assign(__assign({}, middlewareConfig), { isDiscoveredEndpointRequired: false })), endpointDiscoveryMiddlewareOptions);
     },
-});
+}); };

package/dist-es/resolveEndpointDiscoveryConfig.js

@@ -1,10 +1,9 @@
+import { __assign } from "tslib";
 import { EndpointCache } from "@aws-sdk/endpoint-cache";
-export const resolveEndpointDiscoveryConfig = (input, { endpointDiscoveryCommandCtor }) => ({
-    ...input,
-    endpointDiscoveryCommandCtor,
-    endpointCache: new EndpointCache(input.endpointCacheSize ?? 1000),
-    endpointDiscoveryEnabled: input.endpointDiscoveryEnabled !== undefined
-        ? () => Promise.resolve(input.endpointDiscoveryEnabled)
-        : input.endpointDiscoveryEnabledProvider,
-    isClientEndpointDiscoveryEnabled: input.endpointDiscoveryEnabled !== undefined,
-});
+export var resolveEndpointDiscoveryConfig = function (input, _a) {
+    var _b;
+    var endpointDiscoveryCommandCtor = _a.endpointDiscoveryCommandCtor;
+    return (__assign(__assign({}, input), { endpointDiscoveryCommandCtor: endpointDiscoveryCommandCtor, endpointCache: new EndpointCache((_b = input.endpointCacheSize) !== null && _b !== void 0 ? _b : 1000), endpointDiscoveryEnabled: input.endpointDiscoveryEnabled !== undefined
+            ? function () { return Promise.resolve(input.endpointDiscoveryEnabled); }
+            : input.endpointDiscoveryEnabledProvider, isClientEndpointDiscoveryEnabled: input.endpointDiscoveryEnabled !== undefined }));
+};

package/dist-es/updateDiscoveredEndpointInCache.js

@@ -1,57 +1,64 @@
-const requestQueue = {};
-export const updateDiscoveredEndpointInCache = async (config, options) => new Promise((resolve, reject) => {
-    const { endpointCache } = config;
-    const { cacheKey, commandName, identifiers } = options;
-    const endpoints = endpointCache.get(cacheKey);
-    if (endpoints && endpoints.length === 1 && endpoints[0].Address === "") {
-        if (options.isDiscoveredEndpointRequired) {
-            if (!requestQueue[cacheKey])
-                requestQueue[cacheKey] = [];
-            requestQueue[cacheKey].push({ resolve, reject });
-        }
-        else {
-            resolve();
-        }
-    }
-    else if (endpoints && endpoints.length > 0) {
-        resolve();
-    }
-    else {
-        const placeholderEndpoints = [{ Address: "", CachePeriodInMinutes: 1 }];
-        endpointCache.set(cacheKey, placeholderEndpoints);
-        const command = new options.endpointDiscoveryCommandCtor({
-            Operation: commandName.slice(0, -7),
-            Identifiers: identifiers,
-        });
-        const handler = command.resolveMiddleware(options.clientStack, config, options.options);
-        handler(command)
-            .then((result) => {
-            endpointCache.set(cacheKey, result.output.Endpoints);
-            if (requestQueue[cacheKey]) {
-                requestQueue[cacheKey].forEach(({ resolve }) => {
+import { __awaiter, __generator } from "tslib";
+var requestQueue = {};
+export var updateDiscoveredEndpointInCache = function (config, options) { return __awaiter(void 0, void 0, void 0, function () {
+    return __generator(this, function (_a) {
+        return [2, new Promise(function (resolve, reject) {
+                var endpointCache = config.endpointCache;
+                var cacheKey = options.cacheKey, commandName = options.commandName, identifiers = options.identifiers;
+                var endpoints = endpointCache.get(cacheKey);
+                if (endpoints && endpoints.length === 1 && endpoints[0].Address === "") {
+                    if (options.isDiscoveredEndpointRequired) {
+                        if (!requestQueue[cacheKey])
+                            requestQueue[cacheKey] = [];
+                        requestQueue[cacheKey].push({ resolve: resolve, reject: reject });
+                    }
+                    else {
+                        resolve();
+                    }
+                }
+                else if (endpoints && endpoints.length > 0) {
                     resolve();
-                });
-                delete requestQueue[cacheKey];
-            }
-            resolve();
-        })
-            .catch((error) => {
-            endpointCache.delete(cacheKey);
-            const errorToThrow = Object.assign(new Error(`The operation to discover endpoint failed.` +
-                ` Please retry, or provide a custom endpoint and disable endpoint discovery to proceed.`), { reason: error });
-            if (requestQueue[cacheKey]) {
-                requestQueue[cacheKey].forEach(({ reject }) => {
-                    reject(errorToThrow);
-                });
-                delete requestQueue[cacheKey];
-            }
-            if (options.isDiscoveredEndpointRequired) {
-                reject(errorToThrow);
-            }
-            else {
-                endpointCache.set(cacheKey, placeholderEndpoints);
-                resolve();
-            }
-        });
-    }
-});
+                }
+                else {
+                    var placeholderEndpoints_1 = [{ Address: "", CachePeriodInMinutes: 1 }];
+                    endpointCache.set(cacheKey, placeholderEndpoints_1);
+                    var command = new options.endpointDiscoveryCommandCtor({
+                        Operation: commandName.slice(0, -7),
+                        Identifiers: identifiers,
+                    });
+                    var handler = command.resolveMiddleware(options.clientStack, config, options.options);
+                    handler(command)
+                        .then(function (result) {
+                        endpointCache.set(cacheKey, result.output.Endpoints);
+                        if (requestQueue[cacheKey]) {
+                            requestQueue[cacheKey].forEach(function (_a) {
+                                var resolve = _a.resolve;
+                                resolve();
+                            });
+                            delete requestQueue[cacheKey];
+                        }
+                        resolve();
+                    })
+                        .catch(function (error) {
+                        endpointCache.delete(cacheKey);
+                        var errorToThrow = Object.assign(new Error("The operation to discover endpoint failed." +
+                            " Please retry, or provide a custom endpoint and disable endpoint discovery to proceed."), { reason: error });
+                        if (requestQueue[cacheKey]) {
+                            requestQueue[cacheKey].forEach(function (_a) {
+                                var reject = _a.reject;
+                                reject(errorToThrow);
+                            });
+                            delete requestQueue[cacheKey];
+                        }
+                        if (options.isDiscoveredEndpointRequired) {
+                            reject(errorToThrow);
+                        }
+                        else {
+                            endpointCache.set(cacheKey, placeholderEndpoints_1);
+                            resolve();
+                        }
+                    });
+                }
+            })];
+    });
+}); };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aws-sdk/middleware-endpoint-discovery",
-  "version": "3.183.0",
+  "version": "3.186.0",
   "scripts": {
     "build": "concurrently 'yarn:build:cjs' 'yarn:build:es' 'yarn:build:types'",
     "build:cjs": "tsc -p tsconfig.cjs.json",
@@ -20,7 +20,7 @@
   },
   "license": "Apache-2.0",
   "devDependencies": {
-    "@aws-sdk/node-config-provider": "3.183.0",
+    "@aws-sdk/node-config-provider": "3.186.0",
     "@tsconfig/recommended": "1.0.1",
     "concurrently": "7.0.0",
     "downlevel-dts": "0.10.1",
@@ -29,10 +29,10 @@
     "typescript": "~4.6.2"
   },
   "dependencies": {
-    "@aws-sdk/config-resolver": "3.183.0",
-    "@aws-sdk/endpoint-cache": "3.183.0",
-    "@aws-sdk/protocol-http": "3.183.0",
-    "@aws-sdk/types": "3.183.0",
+    "@aws-sdk/config-resolver": "3.186.0",
+    "@aws-sdk/endpoint-cache": "3.186.0",
+    "@aws-sdk/protocol-http": "3.186.0",
+    "@aws-sdk/types": "3.186.0",
     "tslib": "^2.3.1"
   },
   "engines": {