chore: update rds data client (#496)

* feat: update ser-de interface to stop accepting protocol name

* fix: update send() signature to support httpHandlerOptions better

* feat: remove protocol from smithy client config

* fix: remove protocol parameter from middleware serde

* chore: update client rds data

Author: AllanZhengYP

packages/middleware-serde/src/deserializerMiddleware.ts

@@ -3,19 +3,15 @@ import {
   DeserializeMiddleware,
   DeserializeHandler,
   DeserializeHandlerArguments,
-  DeserializeHandlerOutput,
-  RequestHandler
+  DeserializeHandlerOutput
 } from "@aws-sdk/types";
 
 export function deserializerMiddleware<
   Input extends object,
   Output extends object,
   RuntimeUtils = any
 >(
-  options: {
-    requestHandler: RequestHandler<any, any, any>;
-    protocol: string;
-  } & RuntimeUtils,
+  options: RuntimeUtils,
   deserializer: ResponseDeserializer<any, any, RuntimeUtils>
 ): DeserializeMiddleware<Input, Output> {
   return (
@@ -24,7 +20,7 @@ export function deserializerMiddleware<
     args: DeserializeHandlerArguments<Input>
   ): Promise<DeserializeHandlerOutput<Output>> => {
     const { response } = await next(args);
-    const parsed = await deserializer(response, options.protocol, options);
+    const parsed = await deserializer(response, options);
     return {
       response,
       output: parsed as Output

packages/middleware-serde/src/serdePlugin.ts

@@ -29,10 +29,7 @@ export function getSerdePlugin<
   SerDeContext extends EndpointBearer,
   OutputType extends MetadataBearer
 >(
-  config: SerDeContext & {
-    protocol: string;
-    requestHandler: RequestHandler<any, any, any>;
-  },
+  config: SerDeContext,
   serializer: RequestSerializer<any, SerDeContext>,
   deserializer: ResponseDeserializer<OutputType, any, SerDeContext>
 ): Pluggable<InputType, OutputType> {

packages/middleware-serde/src/serializerMiddleware.ts

@@ -4,19 +4,15 @@ import {
   SerializeHandlerArguments,
   SerializeHandlerOutput,
   SerializeMiddleware,
-  EndpointBearer,
-  RequestHandler
+  EndpointBearer
 } from "@aws-sdk/types";
 
 export function serializerMiddleware<
   Input extends object,
   Output extends object,
   RuntimeUtils extends EndpointBearer
 >(
-  options: {
-    requestHandler: RequestHandler<any, any, any>;
-    protocol: string;
-  } & RuntimeUtils,
+  options: RuntimeUtils,
   serializer: RequestSerializer<any, RuntimeUtils>
 ): SerializeMiddleware<Input, Output> {
   return (
@@ -28,11 +24,7 @@ export function serializerMiddleware<
       ...options,
       endpoint: await options.endpoint()
     };
-    const request = await serializer(
-      args.input,
-      options.protocol,
-      endpointResolvedOptions
-    );
+    const request = await serializer(args.input, endpointResolvedOptions);
     return next({
       ...args,
       request

packages/smithy-client/jest.config.js

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

packages/smithy-client/src/client.spec.ts

@@ -0,0 +1,56 @@
+import { Client } from "./client";
+
+describe("SmithyClient", () => {
+  const mockHandler = jest.fn((args: any) =>
+    Promise.resolve({ output: "foo" })
+  );
+  const mockResolveMiddleware = jest.fn(args => mockHandler);
+  const getCommandWithOutput = (output: string) => ({
+    resolveMiddleware: mockResolveMiddleware
+  });
+  const client = new Client({} as any);
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it("should return response promise when only command is supplied", async () => {
+    expect.assertions(1);
+    await expect(
+      client.send(getCommandWithOutput("foo") as any)
+    ).resolves.toEqual("foo");
+  });
+
+  it("should return response promise when command and options is supplied", async () => {
+    expect.assertions(3);
+    const options = {
+      AbortSignal: "bar"
+    };
+    await expect(
+      client.send(getCommandWithOutput("foo") as any, options)
+    ).resolves.toEqual("foo");
+    expect(mockResolveMiddleware.mock.calls.length).toEqual(1);
+    expect(mockResolveMiddleware.mock.calls[0][2 as any]).toEqual(options);
+  });
+
+  it("should apply callback when command and callback is supplied", done => {
+    const callback = jest.fn((err, response) => {
+      expect(response).toEqual("foo");
+      done();
+    });
+    client.send(getCommandWithOutput("foo") as any, callback);
+  });
+
+  it("should apply callback when command, options and callback is supplied", done => {
+    const callback = jest.fn((err, response) => {
+      expect(response).toEqual("foo");
+      expect(mockResolveMiddleware.mock.calls.length).toEqual(1);
+      expect(mockResolveMiddleware.mock.calls[0][2 as any]).toEqual(options);
+      done();
+    });
+    const options = {
+      AbortSignal: "bar"
+    };
+    client.send(getCommandWithOutput("foo") as any, options, callback);
+  });
+});

packages/smithy-client/src/client.ts

@@ -9,7 +9,6 @@ import {
 export interface SmithyConfiguration<HandlerOptions> {
   requestHandler: RequestHandler<any, any, HandlerOptions>;
   readonly apiVersion: string;
-  readonly protocol: string;
 }
 
 export type SmithyResolvedConfiguration<HandlerOptions> = SmithyConfiguration<
@@ -39,6 +38,16 @@ export class Client<
     >,
     options?: HandlerOptions
   ): Promise<OutputType>;
+  send<InputType extends ClientInput, OutputType extends ClientOutput>(
+    command: Command<
+      ClientInput,
+      InputType,
+      ClientOutput,
+      OutputType,
+      SmithyResolvedConfiguration<HandlerOptions>
+    >,
+    cb: (err: any, data?: OutputType) => void
+  ): void;
   send<InputType extends ClientInput, OutputType extends ClientOutput>(
     command: Command<
       ClientInput,
@@ -58,17 +67,25 @@ export class Client<
       OutputType,
       SmithyResolvedConfiguration<HandlerOptions>
     >,
-    options?: HandlerOptions,
+    optionsOrCb?: HandlerOptions | ((err: any, data?: OutputType) => void),
     cb?: (err: any, data?: OutputType) => void
   ): Promise<OutputType> | void {
+    const options = typeof optionsOrCb !== "function" ? optionsOrCb : {};
+    const callback =
+      typeof optionsOrCb === "function"
+        ? (optionsOrCb as ((err: any, data?: OutputType) => void))
+        : cb;
     const handler = command.resolveMiddleware(
       this.middlewareStack as any,
       this.config,
       options
     );
-    if (cb) {
+    if (callback) {
       handler(command)
-        .then(result => cb(null, result.output), (err: any) => cb(err))
+        .then(
+          result => callback(null, result.output),
+          (err: any) => callback(err)
+        )
         .catch(
           // prevent any errors thrown in the callback from triggering an
           // unhandled promise rejection

packages/smithy-client/src/command.ts

@@ -1,5 +1,10 @@
 import { MiddlewareStack } from "@aws-sdk/middleware-stack";
-import { Command as ICommand, MetadataBearer, Handler } from "@aws-sdk/types";
+import {
+  Command as ICommand,
+  MetadataBearer,
+  Handler,
+  MiddlewareStack as IMiddlewareStack
+} from "@aws-sdk/types";
 
 export abstract class Command<
   Input extends ClientInput,
@@ -17,7 +22,10 @@ export abstract class Command<
       ResolvedClientConfiguration
     > {
   abstract input: Input;
-  readonly middlewareStack = new MiddlewareStack<Input, Output>();
+  readonly middlewareStack: IMiddlewareStack<
+    Input,
+    Output
+  > = new MiddlewareStack<Input, Output>();
   abstract resolveMiddleware(
     stack: MiddlewareStack<ClientInput, ClientOutput>,
     configuration: ResolvedClientConfiguration,

packages/types/src/serde.ts

@@ -38,13 +38,11 @@ export interface RequestSerializer<
   /**
    * Converts the provided `input` into a request object
    *
-   * @param transferProtocol The protocol as the request to be serialized
-   *                          to. Like `RestJson`, `RestXML`
    * @param input     The user input to serialize.
    *
    * @param context    Context containing runtime-specific util functions.
    */
-  (input: any, transferProtocol: string, context: Context): Promise<Request>;
+  (input: any, context: Context): Promise<Request>;
 }
 
 export interface ResponseDeserializer<
@@ -55,13 +53,9 @@ export interface ResponseDeserializer<
   /**
    * Converts the output of an operation into JavaScript types.
    *
-   * @param operation The operation model describing the structure of the HTTP
-   *                  response received
-   * @param input     The HTTP response received from the service
+   * @param output     The HTTP response received from the service
    *
    * @param context    context containing runtime-specific util functions.
    */
-  (output: ResponseType, protocolName: string, context: Context): Promise<
-    OutputType
-  >;
+  (output: ResponseType, context: Context): Promise<OutputType>;
 }