ssecMiddleware migration (#544)

* feat: rename package

* feat: migrate middleware-ssec

* feat: apply ssec middleware plugin

Author: Chase Coalwell

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

@@ -19,18 +19,26 @@
 import static software.amazon.smithy.typescript.codegen.integration.RuntimeClientPlugin.Convention.HAS_MIDDLEWARE;
 
 import java.util.List;
+import java.util.Set;
+
 import software.amazon.smithy.aws.traits.ServiceTrait;
+import software.amazon.smithy.model.Model;
+import software.amazon.smithy.model.knowledge.OperationIndex;
+import software.amazon.smithy.model.shapes.OperationShape;
 import software.amazon.smithy.model.shapes.Shape;
 import software.amazon.smithy.typescript.codegen.TypeScriptDependency;
 import software.amazon.smithy.typescript.codegen.integration.RuntimeClientPlugin;
 import software.amazon.smithy.typescript.codegen.integration.TypeScriptIntegration;
 import software.amazon.smithy.utils.ListUtils;
+import software.amazon.smithy.utils.SetUtils;
 
 /**
  * Adds all built-in runtime client plugins to clients.
  */
 public class AddBuiltinPlugins implements TypeScriptIntegration {
 
+    private static final Set<String> SSEC_OPERATIONS = SetUtils.of("SSECustomerKey", "CopySourceSSECustomerKey");
+
     @Override
     public List<RuntimeClientPlugin> getClientPlugins() {
         // Note that order is significant because configurations might
@@ -74,10 +82,22 @@ public List<RuntimeClientPlugin> getClientPlugins() {
                         .withConventions(AwsDependency.ADD_GLACIER_API_VERSION.dependency,
                                          "AddGlacierApiVersion", HAS_MIDDLEWARE)
                         .servicePredicate((m, s) -> testServiceId(s, "Glacier"))
+                        .build(),
+                RuntimeClientPlugin.builder()
+                        .withConventions(AwsDependency.SSEC_MIDDLEWARE.dependency, "Ssec", HAS_MIDDLEWARE)
+                        .servicePredicate((m, s) -> testServiceId(s, "S3"))
+                        .operationPredicate((m, s, o) -> testContainsMember(m, o, SSEC_OPERATIONS))
                         .build()
         );
     }
 
+    private static boolean testContainsMember(Model model, OperationShape operationShape, Set<String> expectedMemberNames) {
+        OperationIndex operationIndex = model.getKnowledge(OperationIndex.class);
+        return operationIndex.getInput(operationShape)
+                .filter(input -> input.getMemberNames().stream().anyMatch(expectedMemberNames::contains))
+                .isPresent();
+    }
+
     private static boolean testServiceId(Shape serviceShape, String expectedId) {
         return serviceShape.getTrait(ServiceTrait.class).map(ServiceTrait::getSdkId).orElse("").equals(expectedId);
     }

Diff for: codegen/smithy-aws-typescript-codegen/src/main/java/software/amazon/smithy/aws/typescript/codegen/AwsDependency.java

@@ -34,7 +34,8 @@ public enum AwsDependency implements SymbolDependencyContainer {
     ACCEPTS_HEADER(NORMAL_DEPENDENCY, "@aws-sdk/middleware-sdk-api-gateway", "^0.1.0-preview.5"),
     VALIDATE_BUCKET_NAME(NORMAL_DEPENDENCY, "@aws-sdk/middleware-sdk-s3", "^0.1.0-preview.2"),
     ADD_EXPECT_CONTINUE(NORMAL_DEPENDENCY, "@aws-sdk/middleware-expect-continue", "^0.1.0-preview.5"),
-    ADD_GLACIER_API_VERSION(NORMAL_DEPENDENCY, "@aws-sdk/middleware-sdk-glacier", "^0.1.0-preview.7");
+    ADD_GLACIER_API_VERSION(NORMAL_DEPENDENCY, "@aws-sdk/middleware-sdk-glacier", "^0.1.0-preview.7"),
+    SSEC_MIDDLEWARE(NORMAL_DEPENDENCY, "@aws-sdk/middleware-ssec", "^0.1.0-preview.5");
 
     public final String packageName;
     public final String version;

Diff for: packages/ssec-middleware/.gitignore renamed to packages/middleware-ssec/.gitignore

@@ -0,0 +1,4 @@
+# @aws-sdk/middleware-ssec
+
+[![NPM version](https://img.shields.io/npm/v/@aws-sdk/middleware-ssec/preview.svg)](https://www.npmjs.com/package/@aws-sdk/middleware-ssec)
+[![NPM downloads](https://img.shields.io/npm/dm/@aws-sdk/middleware-ssec.svg)](https://www.npmjs.com/package/@aws-sdk/middleware-ssec)

Diff for: packages/ssec-middleware/.npmignore renamed to packages/middleware-ssec/.npmignore

@@ -1,6 +1,6 @@
 {
-  "name": "@aws-sdk/ssec-middleware",
-  "version": "0.1.0-preview.8",
+  "name": "@aws-sdk/middleware-ssec",
+  "version": "0.1.0-preview.5",
   "scripts": {
     "prepublishOnly": "tsc",
     "pretest": "tsc -p tsconfig.test.json",
@@ -22,4 +22,4 @@
     "jest": "^24.7.1",
     "typescript": "~3.4.0"
   }
-}
+}

Diff for: packages/ssec-middleware/CHANGELOG.md renamed to packages/middleware-ssec/CHANGELOG.md

@@ -0,0 +1,23 @@
+import { Decoder, Encoder, Hash } from "@aws-sdk/types";
+
+export interface SsecMiddlewareInputConfig {}
+
+interface PreviouslyResolved {
+  base64Encoder: Encoder;
+  md5: { new (): Hash };
+  utf8Decoder: Decoder;
+}
+
+export interface ResolvedSsecMiddlewareConfig {
+  base64Encoder: Encoder;
+  md5: { new (): Hash };
+  utf8Decoder: Decoder;
+}
+
+export function resolveSsecMiddlewareConfig<T>(
+  input: T & PreviouslyResolved & SsecMiddlewareInputConfig
+): T & ResolvedSsecMiddlewareConfig {
+  return {
+    ...input
+  };
+}

Diff for: packages/ssec-middleware/LICENSE renamed to packages/middleware-ssec/LICENSE

@@ -0,0 +1,52 @@
+import { ssecMiddleware } from "./";
+import { HashConstructor } from "@aws-sdk/types";
+
+describe("ssecMiddleware", () => {
+  const next = jest.fn();
+  const decoder = jest.fn().mockResolvedValue(new Uint8Array(0));
+  const encoder = jest.fn().mockReturnValue("base64");
+  const mockHashUpdate = jest.fn();
+  const mockHashDigest = jest.fn().mockReturnValue(new Uint8Array(0));
+  const MockHash: HashConstructor = class {} as any;
+  MockHash.prototype.update = mockHashUpdate;
+  MockHash.prototype.digest = mockHashDigest;
+
+  beforeEach(() => {
+    next.mockClear();
+    decoder.mockClear();
+    encoder.mockClear();
+    mockHashUpdate.mockClear();
+    mockHashDigest.mockClear();
+  });
+
+  it("should base64 encode input keys and set respective MD5 inputs", async () => {
+    const args = {
+      input: {
+        SSECustomerKey: "foo",
+        CopySourceSSECustomerKey: "bar"
+      }
+    };
+
+    const handler = ssecMiddleware({
+      base64Encoder: encoder,
+      utf8Decoder: decoder,
+      md5: MockHash
+    })(next, {} as any);
+
+    await handler(args);
+
+    expect(next.mock.calls.length).toBe(1);
+    expect(next).toHaveBeenCalledWith({
+      input: {
+        SSECustomerKey: "base64",
+        SSECustomerKeyMD5: "base64",
+        CopySourceSSECustomerKey: "base64",
+        CopySourceSSECustomerKeyMD5: "base64"
+      }
+    });
+    expect(decoder.mock.calls.length).toBe(2);
+    expect(encoder.mock.calls.length).toBe(4);
+    expect(mockHashUpdate.mock.calls.length).toBe(2);
+    expect(mockHashDigest.mock.calls.length).toBe(2);
+  });
+});

Diff for: packages/middleware-ssec/README.md

@@ -0,0 +1,71 @@
+import {
+  InitializeHandler,
+  InitializeHandlerArguments,
+  InitializeHandlerOptions,
+  InitializeHandlerOutput,
+  MetadataBearer,
+  Pluggable,
+  InitializeMiddleware,
+  SourceData
+} from "@aws-sdk/types";
+import { ResolvedSsecMiddlewareConfig } from "./configuration";
+
+export function ssecMiddleware(
+  options: ResolvedSsecMiddlewareConfig
+): InitializeMiddleware<any, any> {
+  return <Output extends MetadataBearer>(
+    next: InitializeHandler<any, Output>
+  ): InitializeHandler<any, Output> => async (
+    args: InitializeHandlerArguments<any>
+  ): Promise<InitializeHandlerOutput<Output>> => {
+    let input = { ...args.input };
+    const properties = [
+      {
+        target: "SSECustomerKey",
+        hash: "SSECustomerKeyMD5"
+      },
+      {
+        target: "CopySourceSSECustomerKey",
+        hash: "CopySourceSSECustomerKeyMD5"
+      }
+    ];
+
+    for (const prop of properties) {
+      const value: SourceData | undefined = (input as any)[prop.target];
+      if (value) {
+        const valueView = ArrayBuffer.isView(value)
+          ? new Uint8Array(value.buffer, value.byteOffset, value.byteLength)
+          : typeof value === "string"
+          ? options.utf8Decoder(value)
+          : new Uint8Array(value);
+        const encoded = options.base64Encoder(valueView);
+        const hash = new options.md5();
+        hash.update(valueView);
+        input = {
+          ...(input as any),
+          [prop.target]: encoded,
+          [prop.hash]: options.base64Encoder(await hash.digest())
+        };
+      }
+    }
+
+    return next({
+      ...args,
+      input
+    });
+  };
+}
+
+export const ssecMiddlewareOptions: InitializeHandlerOptions = {
+  name: "ssecMiddleware",
+  step: "initialize",
+  tags: ["SSE"]
+};
+
+export const getSsecPlugin = (
+  config: ResolvedSsecMiddlewareConfig
+): Pluggable<any, any> => ({
+  applyToStack: clientStack => {
+    clientStack.add(ssecMiddleware(config), ssecMiddlewareOptions);
+  }
+});