Feat: update and apply expect continue middleware (#477)

* feat: migrate expect-continue middleware

* feat: apply expect-continue plugin

Author: Chase Coalwell

codegen/smithy-aws-typescript-codegen/src/main/java/software/amazon/smithy/aws/typescript/codegen/AddBuiltinPlugins.java

@@ -62,6 +62,11 @@ public List<RuntimeClientPlugin> getClientPlugins() {
                         .withConventions("@aws-sdk/middleware-sdk-s3", "^0.1.0-preview.2",
                                         "validateBucketNameMiddleware", HAS_MIDDLEWARE)
                         .servicePredicate((m,s) -> s.getId().getName().equals("AmazonS3"))
+                        .build(),
+                RuntimeClientPlugin.builder()
+                        .withConventions("@aws-sdk/middleware-expect-continue", "^0.1.0-preview.5",
+                                        "AddExpectContinue", HAS_MIDDLEWARE)
+                        .servicePredicate((m,s) -> s.getId().getName().equals("AmazonS3"))
                         .build()
         );
     }

packages/middleware-expect-continue/src/index.spec.ts

@@ -1,56 +1,40 @@
-import { BuildHandlerArguments } from "@aws-sdk/types";
-import { addExpectContinue } from "./index";
-import { PutObject } from "./operation.mock";
+import { addExpectContinueMiddleware } from "./index";
+import { HttpRequest } from "@aws-sdk/protocol-http";
 
-describe("addExpectContinue", () => {
+describe("addExpectContinueMiddleware", () => {
   const mockNextHandler = jest.fn();
-  const mockExecutionContext = {
-    model: PutObject,
-    logger: {} as any
-  };
-  const mockHandlerArgs: Partial<BuildHandlerArguments<any>> = {
-    request: {
-      headers: {},
-      method: "PUT",
-      path: "/",
-      protocol: "https:",
-      hostname: "foo.amazonaws.com"
-    }
-  };
 
   beforeEach(() => {
     jest.clearAllMocks();
   });
 
   it("sets the Expect header to 100-continue if there is a request body", async () => {
-    const handler = addExpectContinue(mockNextHandler, mockExecutionContext);
-    const handlerArgs = {
-      request: {
-        ...mockHandlerArgs.request,
-        body: "test"
-      }
-    };
-
-    await handler(handlerArgs as any);
-
-    // ensure the next handler was called
-    expect(mockNextHandler.mock.calls.length).toBe(1);
+    const handler = addExpectContinueMiddleware()(mockNextHandler, {} as any);
+    await handler({
+      input: {},
+      request: new HttpRequest({
+        body: "foo",
+        headers: {}
+      })
+    });
+
+    const { calls } = (mockNextHandler as any).mock;
+    expect(calls.length).toBe(1);
     const { request } = mockNextHandler.mock.calls[0][0];
     expect(request.headers["Expect"]).toBe("100-continue");
   });
 
   it("does not set the Expect header to 100-continue if there is no request body", async () => {
-    const handler = addExpectContinue(mockNextHandler, mockExecutionContext);
-    const handlerArgs = {
-      request: {
-        ...mockHandlerArgs.request
-      }
-    };
-
-    await handler(handlerArgs as any);
-
-    // ensure the next handler was called
-    expect(mockNextHandler.mock.calls.length).toBe(1);
+    const handler = addExpectContinueMiddleware()(mockNextHandler, {} as any);
+    await handler({
+      input: {},
+      request: new HttpRequest({
+        headers: {}
+      })
+    });
+
+    const { calls } = (mockNextHandler as any).mock;
+    expect(calls.length).toBe(1);
     const { request } = mockNextHandler.mock.calls[0][0];
     expect(request.headers["Expect"]).toBeUndefined();
   });

packages/middleware-expect-continue/src/index.ts

@@ -1,25 +1,45 @@
 import {
   BuildHandler,
   BuildHandlerArguments,
-  HandlerExecutionContext
+  BuildHandlerOptions,
+  BuildHandlerOutput,
+  BuildMiddleware,
+  MetadataBearer,
+  Pluggable
 } from "@aws-sdk/types";
-import { headerDefault } from "@aws-sdk/middleware-header-default";
 import { HttpRequest } from "@aws-sdk/protocol-http";
 
-export function addExpectContinue(
-  next: BuildHandler<any, any>,
-  context: HandlerExecutionContext
-) {
-  return (args: BuildHandlerArguments<any>) => {
-    if (HttpRequest.isInstance(args.request) && args.request.body) {
-      return headerDefault({
+export function addExpectContinueMiddleware(): BuildMiddleware<any, any> {
+  return <Output extends MetadataBearer>(
+    next: BuildHandler<any, Output>
+  ): BuildHandler<any, Output> => async (
+    args: BuildHandlerArguments<any>
+  ): Promise<BuildHandlerOutput<Output>> => {
+    let request = { ...args.request };
+    if (HttpRequest.isInstance(request) && request.body) {
+      request.headers = {
+        ...request.headers,
         Expect: "100-continue"
-      })(
-        next,
-        context
-      )(args);
-    } else {
-      return next(args);
+      };
     }
+    return next({
+      ...args,
+      request
+    });
   };
 }
+
+export const addExpectContinueMiddlewareOptions: BuildHandlerOptions = {
+  step: "build",
+  tags: ["SET_EXPECT_HEADER", "EXPECT_HEADER"],
+  name: "addExpectContinueMiddleware"
+};
+
+export const getAddExpectContinuePlugin = (): Pluggable<any, any> => ({
+  applyToStack: clientStack => {
+    clientStack.add(
+      addExpectContinueMiddleware(),
+      addExpectContinueMiddlewareOptions
+    );
+  }
+});