chore: rename maxRetries to maxAttempts

Author: trivikr

packages/middleware-retry/src/configurations.ts

@@ -5,24 +5,24 @@ export interface RetryInputConfig {
   /**
    * The maximum number of times requests that encounter potentially transient failures should be retried
    */
-  maxRetries?: number;
+  maxAttempts?: number;
   /**
    * The strategy to retry the request. Using built-in exponential backoff strategy by default.
    */
   retryStrategy?: RetryStrategy;
 }
 export interface RetryResolvedConfig {
-  maxRetries: number;
+  maxAttempts: number;
   retryStrategy: RetryStrategy;
 }
 export function resolveRetryConfig<T>(
   input: T & RetryInputConfig
 ): T & RetryResolvedConfig {
-  const maxRetries = input.maxRetries === undefined ? 3 : input.maxRetries;
+  const maxAttempts = input.maxAttempts === undefined ? 3 : input.maxAttempts;
   return {
     ...input,
-    maxRetries,
+    maxAttempts,
     retryStrategy:
-      input.retryStrategy || new ExponentialBackOffStrategy(maxRetries)
+      input.retryStrategy || new ExponentialBackOffStrategy(maxAttempts)
   };
 }

packages/middleware-retry/src/defaultStrategy.ts

@@ -40,7 +40,7 @@ export class ExponentialBackOffStrategy implements RetryStrategy {
     private delayDecider: DelayDecider = defaultDelayDecider
   ) {}
   private shouldRetry(error: SdkError, retryAttempted: number) {
-    return retryAttempted < this.maxRetries && this.retryDecider(error);
+    return retryAttempted < this.maxAttempts && this.retryDecider(error);
   }
 
   async retry<Input extends object, Ouput extends MetadataBearer>(

packages/middleware-retry/src/index.spec.ts

@@ -12,9 +12,9 @@ import { SdkError } from "@aws-sdk/smithy-client";
 describe("retryMiddleware", () => {
   it("should not retry when the handler completes successfully", async () => {
     const next = jest.fn().mockResolvedValue({ output: { $metadata: {} } });
-    const retryHandler = retryMiddleware(resolveRetryConfig({ maxRetries: 0 }))(
-      next
-    );
+    const retryHandler = retryMiddleware(
+      resolveRetryConfig({ maxAttempts: 0 })
+    )(next);
 
     const {
       output: { $metadata }
@@ -26,28 +26,28 @@ describe("retryMiddleware", () => {
   });
 
   it("should stop retrying when the the maximum number of retries is reached", async () => {
-    const maxRetries = 3;
+    const maxAttempts = 3;
     const error = new Error();
     error.name = "ProvisionedThroughputExceededException";
     const next = jest.fn().mockRejectedValue(error);
-    const retryHandler = retryMiddleware(resolveRetryConfig({ maxRetries }))(
+    const retryHandler = retryMiddleware(resolveRetryConfig({ maxAttempts }))(
       next
     );
 
     await expect(
       retryHandler({ input: {}, request: new HttpRequest({}) })
     ).rejects.toMatchObject(error);
 
-    expect(next.mock.calls.length).toBe(maxRetries + 1);
+    expect(next.mock.calls.length).toBe(maxAttempts + 1);
   });
 
   it("should not retry if the error is not transient", async () => {
     const error = new Error();
     error.name = "ValidationException";
     const next = jest.fn().mockRejectedValue(error);
-    const retryHandler = retryMiddleware(resolveRetryConfig({ maxRetries: 3 }))(
-      next
-    );
+    const retryHandler = retryMiddleware(
+      resolveRetryConfig({ maxAttempts: 3 })
+    )(next);
 
     await expect(
       retryHandler({ input: {}, request: new HttpRequest({}) })
@@ -69,15 +69,17 @@ describe("retryMiddleware", () => {
 
     jest.mock("./delayDecider");
 
-    const maxRetries = 3;
+    const maxAttempts = 3;
     const delayDeciderMock = jest.spyOn(
       delayDeciderModule,
       "defaultDelayDecider"
     );
     const retryDecider: RetryDecider = (error: SdkError) => true;
-    const strategy = new ExponentialBackOffStrategy(maxRetries, retryDecider);
+    const strategy = new ExponentialBackOffStrategy(maxAttempts, {
+      retryDecider
+    });
     const retryHandler = retryMiddleware({
-      maxRetries,
+      maxAttempts: maxAttempts,
       retryStrategy: strategy
     })(next);
 

packages/middleware-retry/src/retryMiddleware.ts

@@ -9,15 +9,14 @@ import {
 } from "@aws-sdk/types";
 import { RetryResolvedConfig } from "./configurations";
 
-export function retryMiddleware(options: RetryResolvedConfig) {
-  return <Output extends MetadataBearer = MetadataBearer>(
-    next: FinalizeHandler<any, Output>
-  ): FinalizeHandler<any, Output> => async (
-    args: FinalizeHandlerArguments<any>
-  ): Promise<FinalizeHandlerOutput<Output>> => {
-    return options.retryStrategy.retry(next, args);
-  };
-}
+export const retryMiddleware = (options: RetryResolvedConfig) => <
+  Output extends MetadataBearer = MetadataBearer
+>(
+  next: FinalizeHandler<any, Output>
+): FinalizeHandler<any, Output> => async (
+  args: FinalizeHandlerArguments<any>
+): Promise<FinalizeHandlerOutput<Output>> =>
+  options.retryStrategy.retry(next, args);
 
 export const retryMiddlewareOptions: FinalizeRequestHandlerOptions &
   AbsoluteLocation = {
@@ -31,7 +30,7 @@ export const getRetryPlugin = (
   options: RetryResolvedConfig
 ): Pluggable<any, any> => ({
   applyToStack: clientStack => {
-    if (options.maxRetries > 0) {
+    if (options.maxAttempts > 0) {
       clientStack.add(retryMiddleware(options), retryMiddlewareOptions);
     }
   }

packages/types/src/util.ts

@@ -61,7 +61,7 @@ export interface RetryStrategy {
    * the maximum number of times requests that encounter potentially
    * transient failures should be retried
    */
-  maxRetries: number;
+  maxAttempts: number;
   /**
    * the retry behavior the will invoke the next handler and handle the retry accordingly.
    * This function should also update the $metadata from the response accordingly.