feat: update according to new mw stack & smithy client interface

Author: AllanZhengYP

packages/util-create-request/jest.config.js

@@ -0,0 +1,5 @@
+const base = require("../../jest.config.base.js");
+
+module.exports = {
+  ...base
+};

packages/util-create-request/package.json

@@ -15,10 +15,13 @@
   "license": "Apache-2.0",
   "dependencies": {
     "@aws-sdk/types": "^0.1.0-preview.7",
+    "@aws-sdk/smithy-client": "^0.1.0-preview.1",
+    "@aws-sdk/middleware-stack": "^0.1.0-preview.9",
     "tslib": "^1.8.0"
   },
   "devDependencies": {
     "@aws-sdk/middleware-stack": "^0.1.0-preview.9",
+    "@aws-sdk/protocol-http": "^0.1.0-preview.1",
     "@types/jest": "^24.0.12",
     "@types/node": "^10.0.3",
     "jest": "^24.7.1",

packages/util-create-request/src/foo.fixture.ts

@@ -1,15 +1,9 @@
-import {
-  AWSClient,
-  MetadataBearer,
-  ClientResolvedConfigurationBase,
-  Command,
-  CommandInput,
-  HttpRequest
-} from "@aws-sdk/types";
-import { Readable } from "stream";
+import { MetadataBearer } from "@aws-sdk/types";
 import { MiddlewareStack } from "@aws-sdk/middleware-stack";
+import { Client, Command } from "@aws-sdk/smithy-client";
+import { HttpRequest } from "@aws-sdk/protocol-http";
 
-export interface OperationInput extends CommandInput {
+export interface OperationInput {
   String: string;
 }
 
@@ -26,52 +20,48 @@ const output: OperationOutput = { Data: "data", $metadata: {} };
 
 const input: OperationInput = { String: "input" };
 
-export const fooClient: AWSClient<
-  InputTypesUnion,
-  OutputTypesUnion,
-  Readable
-> = {
+export const fooClient: Client<any, InputTypesUnion, OutputTypesUnion, any> = {
   config: {},
-  middlewareStack: new MiddlewareStack<
-    InputTypesUnion,
-    OutputTypesUnion,
-    Readable
-  >(),
+  middlewareStack: new MiddlewareStack<InputTypesUnion, OutputTypesUnion>(),
   send: (
     command: Command<
       InputTypesUnion,
-      OperationInput,
       OutputTypesUnion,
-      OperationOutput,
-      ClientResolvedConfigurationBase<OutputTypesUnion, Readable>,
-      Readable
+      any,
+      OperationInput,
+      OperationOutput
     >
-  ) => command.resolveMiddleware(this.middlewareStack, this.config)({ input })
+  ) =>
+    command.resolveMiddleware(
+      this.middlewareStack,
+      this.config,
+      undefined
+    )({ input })
 };
 
 export const operationCommand: Command<
   InputTypesUnion,
-  OperationInput,
   OutputTypesUnion,
-  OperationOutput,
-  ClientResolvedConfigurationBase<OutputTypesUnion, Readable>,
-  Readable
+  any,
+  OperationInput,
+  OperationOutput
 > = {
-  middlewareStack: new MiddlewareStack<object, OutputTypesUnion, Readable>(),
-  model: {} as any,
+  middlewareStack: new MiddlewareStack<object, OutputTypesUnion>(),
   input: {} as any,
   resolveMiddleware: (
-    stack: MiddlewareStack<InputTypesUnion, OutputTypesUnion, Readable>
+    stack: MiddlewareStack<InputTypesUnion, OutputTypesUnion>,
+    config: any,
+    options: any
   ) => {
-    return () => Promise.resolve(output);
+    return () => Promise.resolve({ output, response: {} });
   }
 };
 
-export const httpRequest: HttpRequest<Readable> = {
+export const httpRequest = new HttpRequest({
   protocol: "https:",
   path: "/foo",
   hostname: "foo-service.us-east-1.amazonaws.com",
   headers: {},
   method: "GET",
   body: ""
-};
+});

packages/util-create-request/src/index.spec.ts

@@ -8,12 +8,12 @@ import {
 } from "./foo.fixture";
 import {
   MetadataBearer,
-  AWSClient,
   SerializeHandlerArguments,
   BuildHandlerArguments,
   FinalizeHandlerArguments
 } from "@aws-sdk/types";
-import { Readable } from "stream";
+import { Client } from "@aws-sdk/smithy-client";
+import { HttpRequest } from "@aws-sdk/protocol-http";
 
 describe("create-request", () => {
   it("should concat initialize and serialize middlewares from client and command", async () => {
@@ -32,7 +32,9 @@ describe("create-request", () => {
     );
     operationCommand.middlewareStack.add(
       next => (args: SerializeHandlerArguments<OperationInput>) => {
-        args.request.body += "2";
+        if (HttpRequest.isInstance(args.request)) {
+          args.request.body += "2";
+        }
         return next(args);
       },
       {
@@ -41,7 +43,9 @@ describe("create-request", () => {
     );
     operationCommand.middlewareStack.add(
       next => (args: BuildHandlerArguments<OperationInput>) => {
-        args.request.body += "3";
+        if (HttpRequest.isInstance(args.request)) {
+          args.request.body += "3";
+        }
         return next(args);
       },
       {
@@ -50,11 +54,13 @@ describe("create-request", () => {
     );
     operationCommand.middlewareStack.add(
       next => (args: FinalizeHandlerArguments<OperationInput>) => {
-        args.request.body += "4";
+        if (HttpRequest.isInstance(args.request)) {
+          args.request.body += "4";
+        }
         return next(args);
       },
       {
-        step: "finalize"
+        step: "finalizeRequest"
       }
     );
 
@@ -73,7 +79,9 @@ describe("create-request", () => {
     );
     fooClient.middlewareStack.add(
       next => (args: SerializeHandlerArguments<OperationInput>) => {
-        args.request.body += "B";
+        if (HttpRequest.isInstance(args.request)) {
+          args.request.body += "B";
+        }
         return next(args);
       },
       {
@@ -82,7 +90,9 @@ describe("create-request", () => {
     );
     fooClient.middlewareStack.add(
       next => (args: BuildHandlerArguments<OperationInput>) => {
-        args.request.body += "C";
+        if (HttpRequest.isInstance(args.request)) {
+          args.request.body += "C";
+        }
         return next(args);
       },
       {
@@ -91,20 +101,22 @@ describe("create-request", () => {
     );
     fooClient.middlewareStack.add(
       next => (args: FinalizeHandlerArguments<OperationInput>) => {
-        args.request.body += "D";
+        if (HttpRequest.isInstance(args.request)) {
+          args.request.body += "D";
+        }
         return next(args);
       },
       {
-        step: "finalize"
+        step: "finalizeRequest"
       }
     );
     const request = await createRequest(
-      fooClient as AWSClient<InputTypesUnion, MetadataBearer, Readable>,
+      fooClient as Client<any, InputTypesUnion, MetadataBearer, any>,
       operationCommand
     );
     expect(request).toEqual({
       ...httpRequest,
-      body: "1A2B"
+      body: "A1B2"
     });
   });
 });

packages/util-create-request/src/index.ts

@@ -1,55 +1,40 @@
 import {
-  CommandInput,
-  FinalizeHandler,
-  FinalizeHandlerArguments,
   HttpRequest,
-  AWSClient,
-  Command,
   MetadataBearer,
-  MiddlewareStack
+  SerializeMiddleware
 } from "@aws-sdk/types";
+import { MiddlewareStack } from "@aws-sdk/middleware-stack";
+import { Client, Command } from "@aws-sdk/smithy-client";
 
 export async function createRequest<
   InputTypesUnion extends object,
   InputType extends InputTypesUnion,
-  StreamType,
   OutputType extends MetadataBearer = MetadataBearer
 >(
-  client: AWSClient<InputTypesUnion, MetadataBearer, StreamType>,
-  command: Command<
-    InputTypesUnion,
+  client: Client<any, InputTypesUnion, MetadataBearer, any>,
+  command: Command<InputType, OutputType, any, InputTypesUnion, MetadataBearer>
+): Promise<HttpRequest> {
+  const presignMiddleware: SerializeMiddleware<
     InputType,
-    MetadataBearer,
-    OutputType,
-    any,
-    StreamType
-  >
-): Promise<HttpRequest<StreamType>> {
-  const presignHandler: FinalizeHandler<
-    any,
-    HttpRequest<StreamType>,
-    StreamType
-  > = async (
-    args: FinalizeHandlerArguments<CommandInput>
-  ): Promise<HttpRequest<StreamType>> => Promise.resolve(args.request);
+    OutputType
+  > = next => async args => {
+    return { output: { request: args.request } as any, response: undefined };
+  };
   const clientStack = client.middlewareStack.clone();
-  const commandStack = (command.middlewareStack.clone() as unknown) as MiddlewareStack<
+  const commandStack = command.middlewareStack.clone();
+  const concatenatedStack = clientStack.concat(commandStack) as MiddlewareStack<
     InputType,
-    any,
-    StreamType
+    OutputType
   >;
-  const concatenatedStack = clientStack
-    .concat(commandStack)
-    .filter(middlewareStats => {
-      return (
-        middlewareStats.step === "initialize" ||
-        middlewareStats.step === "serialize"
-      );
-    });
+  //add middleware to the last of 'build' step
+  concatenatedStack.add(presignMiddleware, {
+    step: "serialize",
+    priority: "low"
+  });
 
-  const handler = concatenatedStack.resolve(presignHandler, {
-    model: command.model,
+  const handler = concatenatedStack.resolve((() => {}) as any, {
     logger: {} as any
   });
-  return await handler(command);
+  //@ts-ignore
+  return await handler(command).then(output => output.output.request);
 }