@aws-sdk/middleware-retry - npm Package Compare versions

Comparing version 3.178.0 to 3.183.0

CHANGELOG.md

@@ -6,2 +6,10 @@ # Change Log
 
+# [3.183.0](https://github.com/aws/aws-sdk-js-v3/compare/v3.182.0...v3.183.0) (2022-10-03)
+
+**Note:** Version bump only for package @aws-sdk/middleware-retry
+
+
+
+
+
 # [3.178.0](https://github.com/aws/aws-sdk-js-v3/compare/v3.177.0...v3.178.0) (2022-09-23)
@@ -8,0 +16,0 @@

dist-es/AdaptiveRetryStrategy.js

@@ -1,34 +0,21 @@
-import { __awaiter, __extends, __generator, __rest } from "tslib";
 import { RETRY_MODES } from "./config";
 import { DefaultRateLimiter } from "./DefaultRateLimiter";
 import { StandardRetryStrategy } from "./StandardRetryStrategy";
-var AdaptiveRetryStrategy = (function (_super) {
-    __extends(AdaptiveRetryStrategy, _super);
-    function AdaptiveRetryStrategy(maxAttemptsProvider, options) {
-        var _this = this;
-        var _a = options !== null && options !== void 0 ? options : {}, rateLimiter = _a.rateLimiter, superOptions = __rest(_a, ["rateLimiter"]);
-        _this = _super.call(this, maxAttemptsProvider, superOptions) || this;
-        _this.rateLimiter = rateLimiter !== null && rateLimiter !== void 0 ? rateLimiter : new DefaultRateLimiter();
-        _this.mode = RETRY_MODES.ADAPTIVE;
-        return _this;
+export class AdaptiveRetryStrategy extends StandardRetryStrategy {
+    constructor(maxAttemptsProvider, options) {
+        const { rateLimiter, ...superOptions } = options ?? {};
+        super(maxAttemptsProvider, superOptions);
+        this.rateLimiter = rateLimiter ?? new DefaultRateLimiter();
+        this.mode = RETRY_MODES.ADAPTIVE;
     }
-    AdaptiveRetryStrategy.prototype.retry = function (next, args) {
-        return __awaiter(this, void 0, void 0, function () {
-            var _this = this;
-            return __generator(this, function (_a) {
-                return [2, _super.prototype.retry.call(this, next, args, {
-                        beforeRequest: function () { return __awaiter(_this, void 0, void 0, function () {
-                            return __generator(this, function (_a) {
-                                return [2, this.rateLimiter.getSendToken()];
-                            });
-                        }); },
-                        afterRequest: function (response) {
-                            _this.rateLimiter.updateClientSendingRate(response);
-                        },
-                    })];
-            });
+    async retry(next, args) {
+        return super.retry(next, args, {
+            beforeRequest: async () => {
+                return this.rateLimiter.getSendToken();
+            },
+            afterRequest: (response) => {
+                this.rateLimiter.updateClientSendingRate(response);
+            },
         });
-    };
-    return AdaptiveRetryStrategy;
-}(StandardRetryStrategy));
-export { AdaptiveRetryStrategy };
+    }
+}

dist-es/config.js

@@ -6,3 +6,3 @@ export var RETRY_MODES;
 })(RETRY_MODES || (RETRY_MODES = {}));
-export var DEFAULT_MAX_ATTEMPTS = 3;
-export var DEFAULT_RETRY_MODE = RETRY_MODES.STANDARD;
+export const DEFAULT_MAX_ATTEMPTS = 3;
+export const DEFAULT_RETRY_MODE = RETRY_MODES.STANDARD;

dist-es/configurations.js

@@ -1,2 +0,1 @@
-import { __assign, __awaiter, __generator } from "tslib";
 import { normalizeProvider } from "@aws-sdk/util-middleware";
@@ -6,22 +5,22 @@ import { AdaptiveRetryStrategy } from "./AdaptiveRetryStrategy";
 import { StandardRetryStrategy } from "./StandardRetryStrategy";
-export var ENV_MAX_ATTEMPTS = "AWS_MAX_ATTEMPTS";
-export var CONFIG_MAX_ATTEMPTS = "max_attempts";
-export var NODE_MAX_ATTEMPT_CONFIG_OPTIONS = {
-    environmentVariableSelector: function (env) {
-        var value = env[ENV_MAX_ATTEMPTS];
+export const ENV_MAX_ATTEMPTS = "AWS_MAX_ATTEMPTS";
+export const CONFIG_MAX_ATTEMPTS = "max_attempts";
+export const NODE_MAX_ATTEMPT_CONFIG_OPTIONS = {
+    environmentVariableSelector: (env) => {
+        const value = env[ENV_MAX_ATTEMPTS];
         if (!value)
             return undefined;
-        var maxAttempt = parseInt(value);
+        const maxAttempt = parseInt(value);
         if (Number.isNaN(maxAttempt)) {
-            throw new Error("Environment variable ".concat(ENV_MAX_ATTEMPTS, " mast be a number, got \"").concat(value, "\""));
+            throw new Error(`Environment variable ${ENV_MAX_ATTEMPTS} mast be a number, got "${value}"`);
         }
         return maxAttempt;
     },
-    configFileSelector: function (profile) {
-        var value = profile[CONFIG_MAX_ATTEMPTS];
+    configFileSelector: (profile) => {
+        const value = profile[CONFIG_MAX_ATTEMPTS];
         if (!value)
             return undefined;
-        var maxAttempt = parseInt(value);
+        const maxAttempt = parseInt(value);
         if (Number.isNaN(maxAttempt)) {
-            throw new Error("Shared config file entry ".concat(CONFIG_MAX_ATTEMPTS, " mast be a number, got \"").concat(value, "\""));
+            throw new Error(`Shared config file entry ${CONFIG_MAX_ATTEMPTS} mast be a number, got "${value}"`);
         }
@@ -32,30 +31,25 @@ return maxAttempt;
 };
-export var resolveRetryConfig = function (input) {
-    var _a;
-    var maxAttempts = normalizeProvider((_a = input.maxAttempts) !== null && _a !== void 0 ? _a : DEFAULT_MAX_ATTEMPTS);
-    return __assign(__assign({}, input), { maxAttempts: maxAttempts, retryStrategy: function () { return __awaiter(void 0, void 0, void 0, function () {
-            var retryMode;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        if (input.retryStrategy) {
-                            return [2, input.retryStrategy];
-                        }
-                        return [4, normalizeProvider(input.retryMode)()];
-                    case 1:
-                        retryMode = _a.sent();
-                        if (retryMode === RETRY_MODES.ADAPTIVE) {
-                            return [2, new AdaptiveRetryStrategy(maxAttempts)];
-                        }
-                        return [2, new StandardRetryStrategy(maxAttempts)];
-                }
-            });
-        }); } });
+export const resolveRetryConfig = (input) => {
+    const maxAttempts = normalizeProvider(input.maxAttempts ?? DEFAULT_MAX_ATTEMPTS);
+    return {
+        ...input,
+        maxAttempts,
+        retryStrategy: async () => {
+            if (input.retryStrategy) {
+                return input.retryStrategy;
+            }
+            const retryMode = await normalizeProvider(input.retryMode)();
+            if (retryMode === RETRY_MODES.ADAPTIVE) {
+                return new AdaptiveRetryStrategy(maxAttempts);
+            }
+            return new StandardRetryStrategy(maxAttempts);
+        },
+    };
 };
-export var ENV_RETRY_MODE = "AWS_RETRY_MODE";
-export var CONFIG_RETRY_MODE = "retry_mode";
-export var NODE_RETRY_MODE_CONFIG_OPTIONS = {
-    environmentVariableSelector: function (env) { return env[ENV_RETRY_MODE]; },
-    configFileSelector: function (profile) { return profile[CONFIG_RETRY_MODE]; },
+export const ENV_RETRY_MODE = "AWS_RETRY_MODE";
+export const CONFIG_RETRY_MODE = "retry_mode";
+export const NODE_RETRY_MODE_CONFIG_OPTIONS = {
+    environmentVariableSelector: (env) => env[ENV_RETRY_MODE],
+    configFileSelector: (profile) => profile[CONFIG_RETRY_MODE],
     default: DEFAULT_RETRY_MODE,
 };

dist-es/constants.js

@@ -1,9 +0,9 @@
-export var DEFAULT_RETRY_DELAY_BASE = 100;
-export var MAXIMUM_RETRY_DELAY = 20 * 1000;
-export var THROTTLING_RETRY_DELAY_BASE = 500;
-export var INITIAL_RETRY_TOKENS = 500;
-export var RETRY_COST = 5;
-export var TIMEOUT_RETRY_COST = 10;
-export var NO_RETRY_INCREMENT = 1;
-export var INVOCATION_ID_HEADER = "amz-sdk-invocation-id";
-export var REQUEST_HEADER = "amz-sdk-request";
+export const DEFAULT_RETRY_DELAY_BASE = 100;
+export const MAXIMUM_RETRY_DELAY = 20 * 1000;
+export const THROTTLING_RETRY_DELAY_BASE = 500;
+export const INITIAL_RETRY_TOKENS = 500;
+export const RETRY_COST = 5;
+export const TIMEOUT_RETRY_COST = 10;
+export const NO_RETRY_INCREMENT = 1;
+export const INVOCATION_ID_HEADER = "amz-sdk-invocation-id";
+export const REQUEST_HEADER = "amz-sdk-request";

dist-es/DefaultRateLimiter.js

@@ -1,6 +0,4 @@
-import { __awaiter, __generator } from "tslib";
 import { isThrottlingError } from "@aws-sdk/service-error-classification";
-var DefaultRateLimiter = (function () {
-    function DefaultRateLimiter(options) {
-        var _a, _b, _c, _d, _e;
+export class DefaultRateLimiter {
+    constructor(options) {
         this.currentCapacity = 0;
@@ -13,8 +11,8 @@ this.enabled = false;
         this.timeWindow = 0;
-        this.beta = (_a = options === null || options === void 0 ? void 0 : options.beta) !== null && _a !== void 0 ? _a : 0.7;
-        this.minCapacity = (_b = options === null || options === void 0 ? void 0 : options.minCapacity) !== null && _b !== void 0 ? _b : 1;
-        this.minFillRate = (_c = options === null || options === void 0 ? void 0 : options.minFillRate) !== null && _c !== void 0 ? _c : 0.5;
-        this.scaleConstant = (_d = options === null || options === void 0 ? void 0 : options.scaleConstant) !== null && _d !== void 0 ? _d : 0.4;
-        this.smooth = (_e = options === null || options === void 0 ? void 0 : options.smooth) !== null && _e !== void 0 ? _e : 0.8;
-        var currentTimeInSeconds = this.getCurrentTimeInSeconds();
+        this.beta = options?.beta ?? 0.7;
+        this.minCapacity = options?.minCapacity ?? 1;
+        this.minFillRate = options?.minFillRate ?? 0.5;
+        this.scaleConstant = options?.scaleConstant ?? 0.4;
+        this.smooth = options?.smooth ?? 0.8;
+        const currentTimeInSeconds = this.getCurrentTimeInSeconds();
         this.lastThrottleTime = currentTimeInSeconds;
@@ -25,37 +23,21 @@ this.lastTxRateBucket = Math.floor(this.getCurrentTimeInSeconds());
     }
-    DefaultRateLimiter.prototype.getCurrentTimeInSeconds = function () {
+    getCurrentTimeInSeconds() {
         return Date.now() / 1000;
-    };
-    DefaultRateLimiter.prototype.getSendToken = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                return [2, this.acquireTokenBucket(1)];
-            });
-        });
-    };
-    DefaultRateLimiter.prototype.acquireTokenBucket = function (amount) {
-        return __awaiter(this, void 0, void 0, function () {
-            var delay_1;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        if (!this.enabled) {
-                            return [2];
-                        }
-                        this.refillTokenBucket();
-                        if (!(amount > this.currentCapacity)) return [3, 2];
-                        delay_1 = ((amount - this.currentCapacity) / this.fillRate) * 1000;
-                        return [4, new Promise(function (resolve) { return setTimeout(resolve, delay_1); })];
-                    case 1:
-                        _a.sent();
-                        _a.label = 2;
-                    case 2:
-                        this.currentCapacity = this.currentCapacity - amount;
-                        return [2];
-                }
-            });
-        });
-    };
-    DefaultRateLimiter.prototype.refillTokenBucket = function () {
-        var timestamp = this.getCurrentTimeInSeconds();
+    }
+    async getSendToken() {
+        return this.acquireTokenBucket(1);
+    }
+    async acquireTokenBucket(amount) {
+        if (!this.enabled) {
+            return;
+        }
+        this.refillTokenBucket();
+        if (amount > this.currentCapacity) {
+            const delay = ((amount - this.currentCapacity) / this.fillRate) * 1000;
+            await new Promise((resolve) => setTimeout(resolve, delay));
+        }
+        this.currentCapacity = this.currentCapacity - amount;
+    }
+    refillTokenBucket() {
+        const timestamp = this.getCurrentTimeInSeconds();
         if (!this.lastTimestamp) {
@@ -65,11 +47,11 @@ this.lastTimestamp = timestamp;
         }
-        var fillAmount = (timestamp - this.lastTimestamp) * this.fillRate;
+        const fillAmount = (timestamp - this.lastTimestamp) * this.fillRate;
         this.currentCapacity = Math.min(this.maxCapacity, this.currentCapacity + fillAmount);
         this.lastTimestamp = timestamp;
-    };
-    DefaultRateLimiter.prototype.updateClientSendingRate = function (response) {
-        var calculatedRate;
+    }
+    updateClientSendingRate(response) {
+        let calculatedRate;
         this.updateMeasuredRate();
         if (isThrottlingError(response)) {
-            var rateToUse = !this.enabled ? this.measuredTxRate : Math.min(this.measuredTxRate, this.fillRate);
+            const rateToUse = !this.enabled ? this.measuredTxRate : Math.min(this.measuredTxRate, this.fillRate);
             this.lastMaxRate = rateToUse;
@@ -85,18 +67,18 @@ this.calculateTimeWindow();
         }
-        var newRate = Math.min(calculatedRate, 2 * this.measuredTxRate);
+        const newRate = Math.min(calculatedRate, 2 * this.measuredTxRate);
         this.updateTokenBucketRate(newRate);
-    };
-    DefaultRateLimiter.prototype.calculateTimeWindow = function () {
+    }
+    calculateTimeWindow() {
         this.timeWindow = this.getPrecise(Math.pow((this.lastMaxRate * (1 - this.beta)) / this.scaleConstant, 1 / 3));
-    };
-    DefaultRateLimiter.prototype.cubicThrottle = function (rateToUse) {
+    }
+    cubicThrottle(rateToUse) {
         return this.getPrecise(rateToUse * this.beta);
-    };
-    DefaultRateLimiter.prototype.cubicSuccess = function (timestamp) {
+    }
+    cubicSuccess(timestamp) {
         return this.getPrecise(this.scaleConstant * Math.pow(timestamp - this.lastThrottleTime - this.timeWindow, 3) + this.lastMaxRate);
-    };
-    DefaultRateLimiter.prototype.enableTokenBucket = function () {
+    }
+    enableTokenBucket() {
         this.enabled = true;
-    };
-    DefaultRateLimiter.prototype.updateTokenBucketRate = function (newRate) {
+    }
+    updateTokenBucketRate(newRate) {
         this.refillTokenBucket();
@@ -106,9 +88,9 @@ this.fillRate = Math.max(newRate, this.minFillRate);
         this.currentCapacity = Math.min(this.currentCapacity, this.maxCapacity);
-    };
-    DefaultRateLimiter.prototype.updateMeasuredRate = function () {
-        var t = this.getCurrentTimeInSeconds();
-        var timeBucket = Math.floor(t * 2) / 2;
+    }
+    updateMeasuredRate() {
+        const t = this.getCurrentTimeInSeconds();
+        const timeBucket = Math.floor(t * 2) / 2;
         this.requestCount++;
         if (timeBucket > this.lastTxRateBucket) {
-            var currentRate = this.requestCount / (timeBucket - this.lastTxRateBucket);
+            const currentRate = this.requestCount / (timeBucket - this.lastTxRateBucket);
             this.measuredTxRate = this.getPrecise(currentRate * this.smooth + this.measuredTxRate * (1 - this.smooth));
@@ -118,8 +100,6 @@ this.requestCount = 0;
         }
-    };
-    DefaultRateLimiter.prototype.getPrecise = function (num) {
+    }
+    getPrecise(num) {
         return parseFloat(num.toFixed(8));
-    };
-    return DefaultRateLimiter;
-}());
-export { DefaultRateLimiter };
+    }
+}

dist-es/defaultRetryQuota.js

 import { NO_RETRY_INCREMENT, RETRY_COST, TIMEOUT_RETRY_COST } from "./constants";
-export var getDefaultRetryQuota = function (initialRetryTokens, options) {
-    var _a, _b, _c;
-    var MAX_CAPACITY = initialRetryTokens;
-    var noRetryIncrement = (_a = options === null || options === void 0 ? void 0 : options.noRetryIncrement) !== null && _a !== void 0 ? _a : NO_RETRY_INCREMENT;
-    var retryCost = (_b = options === null || options === void 0 ? void 0 : options.retryCost) !== null && _b !== void 0 ? _b : RETRY_COST;
-    var timeoutRetryCost = (_c = options === null || options === void 0 ? void 0 : options.timeoutRetryCost) !== null && _c !== void 0 ? _c : TIMEOUT_RETRY_COST;
-    var availableCapacity = initialRetryTokens;
-    var getCapacityAmount = function (error) { return (error.name === "TimeoutError" ? timeoutRetryCost : retryCost); };
-    var hasRetryTokens = function (error) { return getCapacityAmount(error) <= availableCapacity; };
-    var retrieveRetryTokens = function (error) {
+export const getDefaultRetryQuota = (initialRetryTokens, options) => {
+    const MAX_CAPACITY = initialRetryTokens;
+    const noRetryIncrement = options?.noRetryIncrement ?? NO_RETRY_INCREMENT;
+    const retryCost = options?.retryCost ?? RETRY_COST;
+    const timeoutRetryCost = options?.timeoutRetryCost ?? TIMEOUT_RETRY_COST;
+    let availableCapacity = initialRetryTokens;
+    const getCapacityAmount = (error) => (error.name === "TimeoutError" ? timeoutRetryCost : retryCost);
+    const hasRetryTokens = (error) => getCapacityAmount(error) <= availableCapacity;
+    const retrieveRetryTokens = (error) => {
         if (!hasRetryTokens(error)) {
             throw new Error("No retry token available");
         }
-        var capacityAmount = getCapacityAmount(error);
+        const capacityAmount = getCapacityAmount(error);
         availableCapacity -= capacityAmount;
         return capacityAmount;
     };
-    var releaseRetryTokens = function (capacityReleaseAmount) {
-        availableCapacity += capacityReleaseAmount !== null && capacityReleaseAmount !== void 0 ? capacityReleaseAmount : noRetryIncrement;
+    const releaseRetryTokens = (capacityReleaseAmount) => {
+        availableCapacity += capacityReleaseAmount ?? noRetryIncrement;
         availableCapacity = Math.min(availableCapacity, MAX_CAPACITY);
     };
     return Object.freeze({
-        hasRetryTokens: hasRetryTokens,
-        retrieveRetryTokens: retrieveRetryTokens,
-        releaseRetryTokens: releaseRetryTokens,
+        hasRetryTokens,
+        retrieveRetryTokens,
+        releaseRetryTokens,
     });
 };

dist-es/delayDecider.js

 import { MAXIMUM_RETRY_DELAY } from "./constants";
-export var defaultDelayDecider = function (delayBase, attempts) {
-    return Math.floor(Math.min(MAXIMUM_RETRY_DELAY, Math.random() * Math.pow(2, attempts) * delayBase));
-};
+export const defaultDelayDecider = (delayBase, attempts) => Math.floor(Math.min(MAXIMUM_RETRY_DELAY, Math.random() * 2 ** attempts * delayBase));

dist-es/omitRetryHeadersMiddleware.js

@@ -1,20 +0,12 @@
-import { __awaiter, __generator } from "tslib";
 import { HttpRequest } from "@aws-sdk/protocol-http";
 import { INVOCATION_ID_HEADER, REQUEST_HEADER } from "./constants";
-export var omitRetryHeadersMiddleware = function () {
-    return function (next) {
-        return function (args) { return __awaiter(void 0, void 0, void 0, function () {
-            var request;
-            return __generator(this, function (_a) {
-                request = args.request;
-                if (HttpRequest.isInstance(request)) {
-                    delete request.headers[INVOCATION_ID_HEADER];
-                    delete request.headers[REQUEST_HEADER];
-                }
-                return [2, next(args)];
-            });
-        }); };
-    };
+export const omitRetryHeadersMiddleware = () => (next) => async (args) => {
+    const { request } = args;
+    if (HttpRequest.isInstance(request)) {
+        delete request.headers[INVOCATION_ID_HEADER];
+        delete request.headers[REQUEST_HEADER];
+    }
+    return next(args);
 };
-export var omitRetryHeadersMiddlewareOptions = {
+export const omitRetryHeadersMiddlewareOptions = {
     name: "omitRetryHeadersMiddleware",
@@ -26,6 +18,6 @@ tags: ["RETRY", "HEADERS", "OMIT_RETRY_HEADERS"],
 };
-export var getOmitRetryHeadersPlugin = function (options) { return ({
-    applyToStack: function (clientStack) {
+export const getOmitRetryHeadersPlugin = (options) => ({
+    applyToStack: (clientStack) => {
         clientStack.addRelativeTo(omitRetryHeadersMiddleware(), omitRetryHeadersMiddlewareOptions);
     },
-}); };
+});

dist-es/retryDecider.js

 import { isClockSkewError, isRetryableByTrait, isThrottlingError, isTransientError, } from "@aws-sdk/service-error-classification";
-export var defaultRetryDecider = function (error) {
+export const defaultRetryDecider = (error) => {
     if (!error) {
@@ -4,0 +4,0 @@ return false;

dist-es/retryMiddleware.js

@@ -1,20 +0,8 @@
-import { __awaiter, __generator, __read, __spreadArray } from "tslib";
-export var retryMiddleware = function (options) {
-    return function (next, context) {
-        return function (args) { return __awaiter(void 0, void 0, void 0, function () {
-            var retryStrategy;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4, options.retryStrategy()];
-                    case 1:
-                        retryStrategy = _a.sent();
-                        if (retryStrategy === null || retryStrategy === void 0 ? void 0 : retryStrategy.mode)
-                            context.userAgent = __spreadArray(__spreadArray([], __read((context.userAgent || [])), false), [["cfg/retry-mode", retryStrategy.mode]], false);
-                        return [2, retryStrategy.retry(next, args)];
-                }
-            });
-        }); };
-    };
+export const retryMiddleware = (options) => (next, context) => async (args) => {
+    const retryStrategy = await options.retryStrategy();
+    if (retryStrategy?.mode)
+        context.userAgent = [...(context.userAgent || []), ["cfg/retry-mode", retryStrategy.mode]];
+    return retryStrategy.retry(next, args);
 };
-export var retryMiddlewareOptions = {
+export const retryMiddlewareOptions = {
     name: "retryMiddleware",
@@ -26,6 +14,6 @@ tags: ["RETRY"],
 };
-export var getRetryPlugin = function (options) { return ({
-    applyToStack: function (clientStack) {
+export const getRetryPlugin = (options) => ({
+    applyToStack: (clientStack) => {
         clientStack.add(retryMiddleware(options), retryMiddlewareOptions);
     },
-}); };
+});

dist-es/StandardRetryStrategy.js

@@ -1,2 +0,1 @@
-import { __awaiter, __generator } from "tslib";
 import { HttpRequest, HttpResponse } from "@aws-sdk/protocol-http";
@@ -10,130 +9,85 @@ import { isThrottlingError } from "@aws-sdk/service-error-classification";
 import { defaultRetryDecider } from "./retryDecider";
-var StandardRetryStrategy = (function () {
-    function StandardRetryStrategy(maxAttemptsProvider, options) {
-        var _a, _b, _c;
+export class StandardRetryStrategy {
+    constructor(maxAttemptsProvider, options) {
         this.maxAttemptsProvider = maxAttemptsProvider;
         this.mode = RETRY_MODES.STANDARD;
-        this.retryDecider = (_a = options === null || options === void 0 ? void 0 : options.retryDecider) !== null && _a !== void 0 ? _a : defaultRetryDecider;
-        this.delayDecider = (_b = options === null || options === void 0 ? void 0 : options.delayDecider) !== null && _b !== void 0 ? _b : defaultDelayDecider;
-        this.retryQuota = (_c = options === null || options === void 0 ? void 0 : options.retryQuota) !== null && _c !== void 0 ? _c : getDefaultRetryQuota(INITIAL_RETRY_TOKENS);
+        this.retryDecider = options?.retryDecider ?? defaultRetryDecider;
+        this.delayDecider = options?.delayDecider ?? defaultDelayDecider;
+        this.retryQuota = options?.retryQuota ?? getDefaultRetryQuota(INITIAL_RETRY_TOKENS);
     }
-    StandardRetryStrategy.prototype.shouldRetry = function (error, attempts, maxAttempts) {
+    shouldRetry(error, attempts, maxAttempts) {
         return attempts < maxAttempts && this.retryDecider(error) && this.retryQuota.hasRetryTokens(error);
-    };
-    StandardRetryStrategy.prototype.getMaxAttempts = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            var maxAttempts, error_1;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        _a.trys.push([0, 2, , 3]);
-                        return [4, this.maxAttemptsProvider()];
-                    case 1:
-                        maxAttempts = _a.sent();
-                        return [3, 3];
-                    case 2:
-                        error_1 = _a.sent();
-                        maxAttempts = DEFAULT_MAX_ATTEMPTS;
-                        return [3, 3];
-                    case 3: return [2, maxAttempts];
+    }
+    async getMaxAttempts() {
+        let maxAttempts;
+        try {
+            maxAttempts = await this.maxAttemptsProvider();
+        }
+        catch (error) {
+            maxAttempts = DEFAULT_MAX_ATTEMPTS;
+        }
+        return maxAttempts;
+    }
+    async retry(next, args, options) {
+        let retryTokenAmount;
+        let attempts = 0;
+        let totalDelay = 0;
+        const maxAttempts = await this.getMaxAttempts();
+        const { request } = args;
+        if (HttpRequest.isInstance(request)) {
+            request.headers[INVOCATION_ID_HEADER] = v4();
+        }
+        while (true) {
+            try {
+                if (HttpRequest.isInstance(request)) {
+                    request.headers[REQUEST_HEADER] = `attempt=${attempts + 1}; max=${maxAttempts}`;
                 }
-            });
-        });
-    };
-    StandardRetryStrategy.prototype.retry = function (next, args, options) {
-        return __awaiter(this, void 0, void 0, function () {
-            var retryTokenAmount, attempts, totalDelay, maxAttempts, request, _loop_1, this_1, state_1;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        attempts = 0;
-                        totalDelay = 0;
-                        return [4, this.getMaxAttempts()];
-                    case 1:
-                        maxAttempts = _a.sent();
-                        request = args.request;
-                        if (HttpRequest.isInstance(request)) {
-                            request.headers[INVOCATION_ID_HEADER] = v4();
-                        }
-                        _loop_1 = function () {
-                            var _b, response, output, e_1, err, delayFromDecider, delayFromResponse, delay_1;
-                            return __generator(this, function (_c) {
-                                switch (_c.label) {
-                                    case 0:
-                                        _c.trys.push([0, 4, , 7]);
-                                        if (HttpRequest.isInstance(request)) {
-                                            request.headers[REQUEST_HEADER] = "attempt=".concat(attempts + 1, "; max=").concat(maxAttempts);
-                                        }
-                                        if (!(options === null || options === void 0 ? void 0 : options.beforeRequest)) return [3, 2];
-                                        return [4, options.beforeRequest()];
-                                    case 1:
-                                        _c.sent();
-                                        _c.label = 2;
-                                    case 2: return [4, next(args)];
-                                    case 3:
-                                        _b = _c.sent(), response = _b.response, output = _b.output;
-                                        if (options === null || options === void 0 ? void 0 : options.afterRequest) {
-                                            options.afterRequest(response);
-                                        }
-                                        this_1.retryQuota.releaseRetryTokens(retryTokenAmount);
-                                        output.$metadata.attempts = attempts + 1;
-                                        output.$metadata.totalRetryDelay = totalDelay;
-                                        return [2, { value: { response: response, output: output } }];
-                                    case 4:
-                                        e_1 = _c.sent();
-                                        err = asSdkError(e_1);
-                                        attempts++;
-                                        if (!this_1.shouldRetry(err, attempts, maxAttempts)) return [3, 6];
-                                        retryTokenAmount = this_1.retryQuota.retrieveRetryTokens(err);
-                                        delayFromDecider = this_1.delayDecider(isThrottlingError(err) ? THROTTLING_RETRY_DELAY_BASE : DEFAULT_RETRY_DELAY_BASE, attempts);
-                                        delayFromResponse = getDelayFromRetryAfterHeader(err.$response);
-                                        delay_1 = Math.max(delayFromResponse || 0, delayFromDecider);
-                                        totalDelay += delay_1;
-                                        return [4, new Promise(function (resolve) { return setTimeout(resolve, delay_1); })];
-                                    case 5:
-                                        _c.sent();
-                                        return [2, "continue"];
-                                    case 6:
-                                        if (!err.$metadata) {
-                                            err.$metadata = {};
-                                        }
-                                        err.$metadata.attempts = attempts;
-                                        err.$metadata.totalRetryDelay = totalDelay;
-                                        throw err;
-                                    case 7: return [2];
-                                }
-                            });
-                        };
-                        this_1 = this;
-                        _a.label = 2;
-                    case 2:
-                        if (!true) return [3, 4];
-                        return [5, _loop_1()];
-                    case 3:
-                        state_1 = _a.sent();
-                        if (typeof state_1 === "object")
-                            return [2, state_1.value];
-                        return [3, 2];
-                    case 4: return [2];
+                if (options?.beforeRequest) {
+                    await options.beforeRequest();
                 }
-            });
-        });
-    };
-    return StandardRetryStrategy;
-}());
-export { StandardRetryStrategy };
-var getDelayFromRetryAfterHeader = function (response) {
+                const { response, output } = await next(args);
+                if (options?.afterRequest) {
+                    options.afterRequest(response);
+                }
+                this.retryQuota.releaseRetryTokens(retryTokenAmount);
+                output.$metadata.attempts = attempts + 1;
+                output.$metadata.totalRetryDelay = totalDelay;
+                return { response, output };
+            }
+            catch (e) {
+                const err = asSdkError(e);
+                attempts++;
+                if (this.shouldRetry(err, attempts, maxAttempts)) {
+                    retryTokenAmount = this.retryQuota.retrieveRetryTokens(err);
+                    const delayFromDecider = this.delayDecider(isThrottlingError(err) ? THROTTLING_RETRY_DELAY_BASE : DEFAULT_RETRY_DELAY_BASE, attempts);
+                    const delayFromResponse = getDelayFromRetryAfterHeader(err.$response);
+                    const delay = Math.max(delayFromResponse || 0, delayFromDecider);
+                    totalDelay += delay;
+                    await new Promise((resolve) => setTimeout(resolve, delay));
+                    continue;
+                }
+                if (!err.$metadata) {
+                    err.$metadata = {};
+                }
+                err.$metadata.attempts = attempts;
+                err.$metadata.totalRetryDelay = totalDelay;
+                throw err;
+            }
+        }
+    }
+}
+const getDelayFromRetryAfterHeader = (response) => {
     if (!HttpResponse.isInstance(response))
         return;
-    var retryAfterHeaderName = Object.keys(response.headers).find(function (key) { return key.toLowerCase() === "retry-after"; });
+    const retryAfterHeaderName = Object.keys(response.headers).find((key) => key.toLowerCase() === "retry-after");
     if (!retryAfterHeaderName)
         return;
-    var retryAfter = response.headers[retryAfterHeaderName];
-    var retryAfterSeconds = Number(retryAfter);
+    const retryAfter = response.headers[retryAfterHeaderName];
+    const retryAfterSeconds = Number(retryAfter);
     if (!Number.isNaN(retryAfterSeconds))
         return retryAfterSeconds * 1000;
-    var retryAfterDate = new Date(retryAfter);
+    const retryAfterDate = new Date(retryAfter);
     return retryAfterDate.getTime() - Date.now();
 };
-var asSdkError = function (error) {
+const asSdkError = (error) => {
     if (error instanceof Error)
@@ -145,3 +99,3 @@ return error;
         return new Error(error);
-    return new Error("AWS SDK error wrapper for ".concat(error));
+    return new Error(`AWS SDK error wrapper for ${error}`);
 };

package.json

 {
   "name": "@aws-sdk/middleware-retry",
-  "version": "3.178.0",
+  "version": "3.183.0",
   "scripts": {
@@ -23,6 +23,6 @@ "build": "concurrently 'yarn:build:cjs' 'yarn:build:es' 'yarn:build:types'",
   "dependencies": {
-    "@aws-sdk/protocol-http": "3.178.0",
-    "@aws-sdk/service-error-classification": "3.178.0",
-    "@aws-sdk/types": "3.178.0",
-    "@aws-sdk/util-middleware": "3.178.0",
+    "@aws-sdk/protocol-http": "3.183.0",
+    "@aws-sdk/service-error-classification": "3.183.0",
+    "@aws-sdk/types": "3.183.0",
+    "@aws-sdk/util-middleware": "3.183.0",
     "tslib": "^2.3.1",
@@ -32,3 +32,3 @@ "uuid": "^8.3.2"
   "devDependencies": {
-    "@aws-sdk/node-config-provider": "3.178.0",
+    "@aws-sdk/node-config-provider": "3.183.0",
     "@tsconfig/recommended": "1.0.1",
@@ -35,0 +35,0 @@ "@types/uuid": "^8.3.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

102515

decreased by-7.55%

Lines of code

1293

decreased by-7.71%

Dependency changes

• + Added@aws-sdk/protocol-http@3.183.0(transitive)

• + Added@aws-sdk/service-error-classification@3.183.0(transitive)

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

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

• - Removed@aws-sdk/protocol-http@3.178.0(transitive)

• - Removed@aws-sdk/service-error-classification@3.178.0(transitive)

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

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

• Updated@aws-sdk/protocol-http@3.183.0

• Updated@aws-sdk/service-error-classification@3.183.0

• Updated@aws-sdk/types@3.183.0

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