Add retry middleware

Author: jeskew

packages/middleware-content-length/src/index.ts

@@ -3,19 +3,16 @@ import {
     BuildHandlerArguments,
     BuildMiddleware,
     BodyLengthCalculator,
+    MetadataBearer,
 } from '@aws/types';
 
-export function contentLengthMiddleware<
-    Input extends object,
-    Output extends object,
-    Stream
->(
+export function contentLengthMiddleware(
     bodyLengthCalculator: BodyLengthCalculator
-): BuildMiddleware<Input, Output, Stream> {
-    return (
-        next: BuildHandler<Input, Output, Stream>
-    ): BuildHandler<Input, Output, Stream> => async (
-        args: BuildHandlerArguments<Input, Stream>
+): BuildMiddleware<any, any, any> {
+    return <Output extends MetadataBearer>(
+        next: BuildHandler<any, Output, any>
+    ): BuildHandler<any, Output, any> => async (
+        args: BuildHandlerArguments<any, any>
     ): Promise<Output> => {
         const {request} = args;
         if (!request) {
@@ -29,7 +26,10 @@ export function contentLengthMiddleware<
                 .map(str => str.toLowerCase())
                 .indexOf('content-length') === -1
         ) {
-            headers['Content-Length'] = String(bodyLengthCalculator(body));
+            const length = bodyLengthCalculator(body);
+            if (length !== undefined) {
+                headers['Content-Length'] = String(length);
+            }
         }
 
         return next({

packages/service-error-classification/LICENSE

@@ -1,4 +1,4 @@
-Apache License
+                                Apache License
                            Version 2.0, January 2004
                         http://www.apache.org/licenses/
 
@@ -198,4 +198,4 @@ Apache License
    distributed under the License is distributed on an "AS IS" BASIS,
    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    See the License for the specific language governing permissions and
-   limitations under the License.
+   limitations under the License.

packages/service-error-classification/src/constants.ts

@@ -1,49 +1,42 @@
+export type ErrorCodeSet = {[errorCode: string]: true};
+
 /**
  * Errors encountered when the client clock and server clock cannot agree on the
  * current time.
  *
  * These errors are retryable, assuming the SDK has enabled clock skew
  * correction.
  */
-export const CLOCK_SKEW_ERROR_CODES = new Set<string>();
+export const CLOCK_SKEW_ERROR_CODES: ErrorCodeSet = {
+    AuthFailure: true,
+    InvalidSignatureException: true,
+    RequestExpired: true,
+    RequestInTheFuture: true,
+    RequestTimeTooSkewed: true,
+    SignatureDoesNotMatch: true,
+};
 
 /**
- * Errors encountered when the state an operation presumes is not yet ready.
+ * Errors encountered when the state presumed by an operation is not yet ready.
  */
-export const STILL_PROCESSING_ERROR_CODES = new Set<string>();
+export const STILL_PROCESSING_ERROR_CODES: ErrorCodeSet = {
+    PriorRequestNotComplete: true,
+}
 
 /**
  * Errors that indicate the SDK is being throttled.
  *
  * These errors are always retryable.
  */
-export const THROTTLING_ERROR_CODES = new Set<string>();
-
-// Populate the error code sets. This is not done in the Set constructor to
-// maintain compatibility with IE 11.
-
-[
-    'PriorRequestNotComplete',
-].forEach(code => STILL_PROCESSING_ERROR_CODES.add(code));
-
-[
-    'AuthFailure',
-    'InvalidSignatureException',
-    'RequestExpired',
-    'RequestInTheFuture',
-    'RequestTimeTooSkewed',
-    'SignatureDoesNotMatch',
-].forEach(code => CLOCK_SKEW_ERROR_CODES.add(code));
-
-[
-    'BandwidthLimitExceeded',
-    'ProvisionedThroughputExceededException',
-    'RequestLimitExceeded',
-    'RequestThrottled',
-    'RequestThrottledException',
-    'SlowDown',
-    'ThrottledException',
-    'Throttling',
-    'ThrottlingException',
-    'TooManyRequestsException',
-].forEach(code => THROTTLING_ERROR_CODES.add(code));
+export const THROTTLING_ERROR_CODES: ErrorCodeSet = {
+    BandwidthLimitExceeded: true,
+    ProvisionedThroughputExceededException: true,
+    RequestLimitExceeded: true,
+    RequestThrottled: true,
+    RequestThrottledException: true,
+    SlowDown: true,
+    ThrottledException: true,
+    Throttling: true,
+    ThrottlingException: true,
+    TooManyRequestsException: true,
+};

packages/service-error-classification/src/index.spec.ts

@@ -10,7 +10,7 @@ import {
  } from "./index";
 
 describe('isClockSkewError', () => {
-    for (const name of CLOCK_SKEW_ERROR_CODES) {
+    for (const name of Object.keys(CLOCK_SKEW_ERROR_CODES)) {
         it(
             `should declare errors with the name ${name} to be throttling errors`,
             () => {
@@ -23,7 +23,7 @@ describe('isClockSkewError', () => {
 });
 
 describe('isStillProcessingError', () => {
-    for (const name of STILL_PROCESSING_ERROR_CODES) {
+    for (const name of Object.keys(STILL_PROCESSING_ERROR_CODES)) {
         it(
             `should declare errors with the name ${name} to be throttling errors`,
             () => {
@@ -36,7 +36,7 @@ describe('isStillProcessingError', () => {
 });
 
 describe('isThrottlingError', () => {
-    for (const name of THROTTLING_ERROR_CODES) {
+    for (const name of Object.keys(THROTTLING_ERROR_CODES)) {
         it(
             `should declare errors with the name ${name} to be throttling errors`,
             () => {

packages/service-error-classification/src/index.ts

@@ -5,13 +5,13 @@ import {
 } from './constants';
 
 export function isClockSkewError(error: Error) {
-    return CLOCK_SKEW_ERROR_CODES.has(error.name);
+    return error.name in CLOCK_SKEW_ERROR_CODES;
 }
 
 export function isStillProcessingError(error: Error): boolean {
-    return STILL_PROCESSING_ERROR_CODES.has(error.name);
+    return error.name in STILL_PROCESSING_ERROR_CODES;
 }
 
 export function isThrottlingError(error: Error): boolean {
-    return THROTTLING_ERROR_CODES.has(error.name);
+    return error.name in THROTTLING_ERROR_CODES;
 }

packages/util-body-length-browser/src/index.ts

@@ -1,5 +1,5 @@
 
-export function calculateBodyLength(body: any): number {
+export function calculateBodyLength(body: any): number|undefined {
     if (typeof body === 'string') {
         return body.length;
     } else if (typeof body.byteLength === 'number') {
@@ -9,6 +9,4 @@ export function calculateBodyLength(body: any): number {
         // handles browser File object
         return body.size;
     }
-
-    throw new Error(`Could not determine size of ${body}`);
-}
+}

packages/util-body-length-node/src/index.ts

@@ -1,6 +1,6 @@
 import {lstatSync} from 'fs';
 
-export function calculateBodyLength(body: any): number {
+export function calculateBodyLength(body: any): number|undefined {
     if (!body) {
         return 0;
     }
@@ -15,6 +15,4 @@ export function calculateBodyLength(body: any): number {
         // handles fs readable streams
         return lstatSync(body.path).size;
     }
-
-    throw new Error(`Could not determine size of ${body}`);
-}
+}