Feat: update and apply S3 middleware (#478)

* feat: migrate s3 middleware

* feat: apply validate-bucket-name plugin

Author: Chase Coalwell

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

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

packages/middleware-sdk-s3/src/validate-bucket-name.spec.ts

@@ -1,21 +1,18 @@
-import { validateBucketName } from "./validate-bucket-name";
-import { SerializeHandler } from "@aws-sdk/types";
+import { validateBucketNameMiddleware } from "./validate-bucket-name";
 
-describe("validateBucketName", () => {
+describe("validateBucketNameMiddleware", () => {
   const mockNextHandler = jest.fn();
-  const composedHandler: SerializeHandler<any, any> = validateBucketName(
-    mockNextHandler
-  );
 
   beforeEach(() => {
     jest.clearAllMocks();
   });
 
   it("throws error if Bucket parameter contains '/'", async () => {
+    const handler = validateBucketNameMiddleware()(mockNextHandler, {} as any);
     const bucket = "bucket/part/of/key";
     let error;
     try {
-      await composedHandler({
+      await handler({
         input: {
           Bucket: bucket
         }
@@ -31,12 +28,13 @@ describe("validateBucketName", () => {
   });
 
   it("doesn't throw error if Bucket parameter has no '/'", async () => {
+    const handler = validateBucketNameMiddleware()(mockNextHandler, {} as any);
     const args = {
       input: {
         Bucket: "bucket"
       }
     };
-    await composedHandler(args);
+    await handler(args);
     expect(mockNextHandler.mock.calls.length).toBe(1);
     expect(mockNextHandler.mock.calls[0][0]).toEqual(args);
   });

packages/middleware-sdk-s3/src/validate-bucket-name.ts

@@ -1,15 +1,42 @@
-import { Handler, SerializeHandlerArguments } from "@aws-sdk/types";
+import {
+  InitializeHandler,
+  InitializeHandlerArguments,
+  InitializeHandlerOptions,
+  InitializeHandlerOutput,
+  InitializeMiddleware,
+  MetadataBearer,
+  Pluggable
+} from "@aws-sdk/types";
 
-export const validateBucketName = (
-  next: Handler<any, any>
-): Handler<any, any> => async (args: SerializeHandlerArguments<any, any>) => {
-  const { input } = args;
-  if (typeof input.Bucket === "string" && input.Bucket.indexOf("/") >= 0) {
-    const err = new Error(
-      `Bucket name shouldn't contain '/', received '${input.Bucket}'`
+export function validateBucketNameMiddleware(): InitializeMiddleware<any, any> {
+  return <Output extends MetadataBearer>(
+    next: InitializeHandler<any, Output>
+  ): InitializeHandler<any, Output> => async (
+    args: InitializeHandlerArguments<any>
+  ): Promise<InitializeHandlerOutput<Output>> => {
+    const { input } = args;
+    if (typeof input.Bucket === "string" && input.Bucket.indexOf("/") >= 0) {
+      const err = new Error(
+        `Bucket name shouldn't contain '/', received '${input.Bucket}'`
+      );
+      err.name = "InvalidBucketName";
+      throw err;
+    }
+    return next({ ...args });
+  };
+}
+
+export const validateBucketNameMiddlewareOptions: InitializeHandlerOptions = {
+  step: "initialize",
+  tags: ["SET_EXPECT_HEADER", "EXPECT_HEADER"],
+  name: "addExpectContinueMiddleware"
+};
+
+export const getValidateBucketNamePlugin = (): Pluggable<any, any> => ({
+  applyToStack: clientStack => {
+    clientStack.add(
+      validateBucketNameMiddleware(),
+      validateBucketNameMiddlewareOptions
     );
-    err.name = "InvalidBucketName";
-    throw err;
   }
-  return next({ ...args });
-};
+});