@smithy/middleware-retry 1.0.3 → 1.0.4

package/dist-types/ts3.4/AdaptiveRetryStrategy.d.ts

@@ -0,0 +1,20 @@
+import { FinalizeHandler, FinalizeHandlerArguments, MetadataBearer, Provider } from "@smithy/types";
+import { RateLimiter } from "@smithy/util-retry";
+import { StandardRetryStrategy, StandardRetryStrategyOptions } from "./StandardRetryStrategy";
+/**
+ * Strategy options to be passed to AdaptiveRetryStrategy
+ */
+export interface AdaptiveRetryStrategyOptions extends StandardRetryStrategyOptions {
+    rateLimiter?: RateLimiter;
+}
+/**
+ * @deprecated use AdaptiveRetryStrategy from @smithy/util-retry
+ */
+export declare class AdaptiveRetryStrategy extends StandardRetryStrategy {
+    private rateLimiter;
+    constructor(maxAttemptsProvider: Provider<number>, options?: AdaptiveRetryStrategyOptions);
+    retry<Input extends object, Ouput extends MetadataBearer>(next: FinalizeHandler<Input, Ouput>, args: FinalizeHandlerArguments<Input>): Promise<{
+        response: unknown;
+        output: Ouput;
+    }>;
+}

package/dist-types/ts3.4/StandardRetryStrategy.d.ts

@@ -0,0 +1,30 @@
+import { FinalizeHandler, FinalizeHandlerArguments, MetadataBearer, Provider, RetryStrategy } from "@smithy/types";
+import { DelayDecider, RetryDecider, RetryQuota } from "./types";
+/**
+ * Strategy options to be passed to StandardRetryStrategy
+ */
+export interface StandardRetryStrategyOptions {
+    retryDecider?: RetryDecider;
+    delayDecider?: DelayDecider;
+    retryQuota?: RetryQuota;
+}
+/**
+ * @deprecated use StandardRetryStrategy from @smithy/util-retry
+ */
+export declare class StandardRetryStrategy implements RetryStrategy {
+    private readonly maxAttemptsProvider;
+    private retryDecider;
+    private delayDecider;
+    private retryQuota;
+    mode: string;
+    constructor(maxAttemptsProvider: Provider<number>, options?: StandardRetryStrategyOptions);
+    private shouldRetry;
+    private getMaxAttempts;
+    retry<Input extends object, Ouput extends MetadataBearer>(next: FinalizeHandler<Input, Ouput>, args: FinalizeHandlerArguments<Input>, options?: {
+        beforeRequest: Function;
+        afterRequest: Function;
+    }): Promise<{
+        response: unknown;
+        output: Ouput;
+    }>;
+}

package/dist-types/ts3.4/configurations.d.ts

@@ -0,0 +1,37 @@
+import { LoadedConfigSelectors } from "@smithy/node-config-provider";
+import { Provider, RetryStrategy, RetryStrategyV2 } from "@smithy/types";
+export declare const ENV_MAX_ATTEMPTS = "AWS_MAX_ATTEMPTS";
+export declare const CONFIG_MAX_ATTEMPTS = "max_attempts";
+export declare const NODE_MAX_ATTEMPT_CONFIG_OPTIONS: LoadedConfigSelectors<number>;
+export interface RetryInputConfig {
+    /**
+     * The maximum number of times requests that encounter retryable failures should be attempted.
+     */
+    maxAttempts?: number | Provider<number>;
+    /**
+     * The strategy to retry the request. Using built-in exponential backoff strategy by default.
+     */
+    retryStrategy?: RetryStrategy | RetryStrategyV2;
+}
+interface PreviouslyResolved {
+    /**
+     * Specifies provider for retry algorithm to use.
+     * @internal
+     */
+    retryMode: string | Provider<string>;
+}
+export interface RetryResolvedConfig {
+    /**
+     * Resolved value for input config {@link RetryInputConfig.maxAttempts}
+     */
+    maxAttempts: Provider<number>;
+    /**
+     * Resolved value for input config {@link RetryInputConfig.retryStrategy}
+     */
+    retryStrategy: Provider<RetryStrategyV2 | RetryStrategy>;
+}
+export declare const resolveRetryConfig: <T>(input: T & PreviouslyResolved & RetryInputConfig) => T & RetryResolvedConfig;
+export declare const ENV_RETRY_MODE = "AWS_RETRY_MODE";
+export declare const CONFIG_RETRY_MODE = "retry_mode";
+export declare const NODE_RETRY_MODE_CONFIG_OPTIONS: LoadedConfigSelectors<string>;
+export {};

package/dist-types/ts3.4/defaultRetryQuota.d.ts

@@ -0,0 +1,18 @@
+import { RetryQuota } from "./types";
+export interface DefaultRetryQuotaOptions {
+    /**
+     * The total amount of retry token to be incremented from retry token balance
+     * if an SDK operation invocation succeeds without requiring a retry request.
+     */
+    noRetryIncrement?: number;
+    /**
+     * The total amount of retry tokens to be decremented from retry token balance.
+     */
+    retryCost?: number;
+    /**
+     * The total amount of retry tokens to be decremented from retry token balance
+     * when a throttling error is encountered.
+     */
+    timeoutRetryCost?: number;
+}
+export declare const getDefaultRetryQuota: (initialRetryTokens: number, options?: DefaultRetryQuotaOptions) => RetryQuota;

package/dist-types/ts3.4/delayDecider.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Calculate a capped, fully-jittered exponential backoff time.
+ */
+export declare const defaultDelayDecider: (delayBase: number, attempts: number) => number;

package/dist-types/ts3.4/index.d.ts

@@ -0,0 +1,7 @@
+export * from "./AdaptiveRetryStrategy";
+export * from "./StandardRetryStrategy";
+export * from "./configurations";
+export * from "./delayDecider";
+export * from "./omitRetryHeadersMiddleware";
+export * from "./retryDecider";
+export * from "./retryMiddleware";

package/dist-types/ts3.4/omitRetryHeadersMiddleware.d.ts

@@ -0,0 +1,4 @@
+import { FinalizeHandler, MetadataBearer, Pluggable, RelativeMiddlewareOptions } from "@smithy/types";
+export declare const omitRetryHeadersMiddleware: () => <Output extends MetadataBearer = MetadataBearer>(next: FinalizeHandler<any, Output>) => FinalizeHandler<any, Output>;
+export declare const omitRetryHeadersMiddlewareOptions: RelativeMiddlewareOptions;
+export declare const getOmitRetryHeadersPlugin: (options: unknown) => Pluggable<any, any>;

package/dist-types/ts3.4/retryDecider.d.ts

@@ -0,0 +1,2 @@
+import { SdkError } from "@smithy/types";
+export declare const defaultRetryDecider: (error: SdkError) => boolean;

package/dist-types/ts3.4/retryMiddleware.d.ts

@@ -0,0 +1,6 @@
+import { AbsoluteLocation, FinalizeHandler, FinalizeRequestHandlerOptions, HandlerExecutionContext, MetadataBearer, Pluggable } from "@smithy/types";
+import { RetryResolvedConfig } from "./configurations";
+export declare const retryMiddleware: (options: RetryResolvedConfig) => <Output extends MetadataBearer = MetadataBearer>(next: FinalizeHandler<any, Output>, context: HandlerExecutionContext) => FinalizeHandler<any, Output>;
+export declare const retryMiddlewareOptions: FinalizeRequestHandlerOptions & AbsoluteLocation;
+export declare const getRetryPlugin: (options: RetryResolvedConfig) => Pluggable<any, any>;
+export declare const getRetryAfterHint: (response: unknown) => Date | undefined;

package/dist-types/ts3.4/types.d.ts

@@ -0,0 +1,53 @@
+import { SdkError } from "@smithy/types";
+/**
+ * Determines whether an error is retryable based on the number of retries
+ * already attempted, the HTTP status code, and the error received (if any).
+ *
+ * @param error - The error encountered.
+ */
+export interface RetryDecider {
+    (error: SdkError): boolean;
+}
+/**
+ * Determines the number of milliseconds to wait before retrying an action.
+ *
+ * @param delayBase - The base delay (in milliseconds).
+ * @param attempts - The number of times the action has already been tried.
+ */
+export interface DelayDecider {
+    (delayBase: number, attempts: number): number;
+}
+/**
+ * Interface that specifies the retry quota behavior.
+ */
+export interface RetryQuota {
+    /**
+     * returns true if retry tokens are available from the retry quota bucket.
+     */
+    hasRetryTokens: (error: SdkError) => boolean;
+    /**
+     * returns token amount from the retry quota bucket.
+     * throws error is retry tokens are not available.
+     */
+    retrieveRetryTokens: (error: SdkError) => number;
+    /**
+     * releases tokens back to the retry quota.
+     */
+    releaseRetryTokens: (releaseCapacityAmount?: number) => void;
+}
+export interface RateLimiter {
+    /**
+     * If there is sufficient capacity (tokens) available, it immediately returns.
+     * If there is not sufficient capacity, it will either sleep a certain amount
+     * of time until the rate limiter can retrieve a token from its token bucket
+     * or raise an exception indicating there is insufficient capacity.
+     */
+    getSendToken: () => Promise<void>;
+    /**
+     * Updates the client sending rate based on response.
+     * If the response was successful, the capacity and fill rate are increased.
+     * If the response was a throttling response, the capacity and fill rate are
+     * decreased. Transient errors do not affect the rate limiter.
+     */
+    updateClientSendingRate: (response: any) => void;
+}

package/dist-types/ts3.4/util.d.ts

@@ -0,0 +1,2 @@
+import { SdkError } from "@smithy/types";
+export declare const asSdkError: (error: unknown) => SdkError;

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@smithy/middleware-retry",
-  "version": "1.0.3",
+  "version": "1.0.4",
   "scripts": {
-    "build": "concurrently 'yarn:build:cjs' 'yarn:build:es' 'yarn:build:types'",
+    "build": "concurrently 'yarn:build:cjs' 'yarn:build:es' 'yarn:build:types && yarn build:types:downlevel'",
     "build:cjs": "tsc -p tsconfig.cjs.json",
     "build:es": "tsc -p tsconfig.es.json",
     "build:types": "tsc -p tsconfig.types.json",
@@ -23,16 +23,16 @@
   },
   "license": "Apache-2.0",
   "dependencies": {
-    "@smithy/protocol-http": "^1.1.0",
-    "@smithy/service-error-classification": "^1.0.2",
-    "@smithy/types": "^1.1.0",
-    "@smithy/util-middleware": "^1.0.1",
-    "@smithy/util-retry": "^1.0.3",
+    "@smithy/protocol-http": "^1.1.1",
+    "@smithy/service-error-classification": "^1.0.3",
+    "@smithy/types": "^1.1.1",
+    "@smithy/util-middleware": "^1.0.2",
+    "@smithy/util-retry": "^1.0.4",
     "tslib": "^2.5.0",
     "uuid": "^8.3.2"
   },
   "devDependencies": {
-    "@smithy/node-config-provider": "^1.0.1",
+    "@smithy/node-config-provider": "^1.0.2",
     "@tsconfig/recommended": "1.0.1",
     "@types/uuid": "^8.3.0",
     "concurrently": "7.0.0",