feat: parse derializing utils as parameters

* use config interface as middleware parameter
* use smithy command as super class of all commands so we can support use() in commands

Author: AllanZhengYP

clients/node/client-rds-data-node/RDSDataClient.ts

@@ -38,7 +38,7 @@ export class RDSDataClient extends SmithyClient<HttpOptions, InputTypesUnion, Ou
     let intermediaConfig_3 = EndpointsConfig.resolve(intermediaConfig_2);
     let intermediaConfig_4 = RetryConfig.resolve(intermediaConfig_3);
     this.config = intermediaConfig_4;
-    super.use(contentLengthPlugin(this.config.bodyLengthChecker));
+    super.use(contentLengthPlugin(this.config));
     if (this.config.maxRetries > 0) {
       this.middlewareStack.add(
         __aws_sdk_retry_middleware.retryMiddleware(

clients/node/client-rds-data-node/RDSDataConfiguration.ts

@@ -4,38 +4,29 @@ import { NodeHttpHandler } from "@aws-sdk/node-http-handler";
 import { defaultProvider as regionDefaultProvider } from "@aws-sdk/region-provider";
 import { parseUrl } from "@aws-sdk/url-parser-node";
 import { calculateBodyLength } from "@aws-sdk/util-body-length-node";
-import { Protocol, HashConstructor, StreamCollector, Provider, Credentials, UrlParser } from "@aws-sdk/types";
-import { HttpRequest, HttpResponse, HttpHandler } from "@aws-sdk/protocol-http";
 import { streamCollector } from '@aws-sdk/stream-collector-node';
 import { RestJsonProtocol } from "@aws-sdk/protocol-rest-json";
-import { AwsAuthConfiguration, RegionConfiguration, RetryConfig, EndpointsConfig, ProtocolConfig } from '@aws-sdk/config-resolver';
-
-export interface AWSClientRuntimeConfiguration {
-  httpHandler?: HttpHandler;
-  protocolDefaultProvider?: (handler: HttpHandler) => Protocol<HttpRequest, HttpResponse>
-  signingName?: string;
-  service?: string;
-  sha256?: HashConstructor;
-  credentialDefaultProvider?: (input: any) => Provider<Credentials>;
-  regionDefaultProvider?: (input: any) => Provider<string>;
-  urlParser?: UrlParser,
-  bodyLengthChecker?: (body: any) => number | undefined;
-  streamCollector?: StreamCollector<any>
-}
+import { fromUtf8, toUtf8 } from '@aws-sdk/util-utf8-node';
+import { fromBase64, toBase64 } from '@aws-sdk/util-base64-node';
+import { AwsAuthConfiguration, RegionConfiguration, RetryConfig, EndpointsConfig, ProtocolConfig, AWSClientRuntimeConfiguration } from '@aws-sdk/config-resolver';
 
 export type AWSClientRuntimeResolvedConfiguration = Required<AWSClientRuntimeConfiguration>;
 
 export const RDSRuntimeConfiguration: AWSClientRuntimeResolvedConfiguration = {
-  httpHandler: new NodeHttpHandler(),
   protocolDefaultProvider: (handler) => new RestJsonProtocol(handler),
   signingName: "rds-data",
   service: "rds-data",
+  httpHandler: new NodeHttpHandler(),
   sha256: Hash.bind(null, "sha256"),
   credentialDefaultProvider,
   regionDefaultProvider,
   urlParser: parseUrl,
   bodyLengthChecker: calculateBodyLength,
-  streamCollector
+  streamCollector,
+  base64Decoder: fromBase64,
+  base64Encoder: toBase64,
+  utf8Decoder: fromUtf8,
+  utf8Encoder: toUtf8
 }
 
 export type RDSDataConfiguration = AWSClientRuntimeConfiguration &

clients/node/client-rds-data-node/commands/ExecuteStatementCommand.ts

@@ -1,11 +1,11 @@
-import * as __aws_sdk_middleware_stack from "@aws-sdk/middleware-stack";
-import { serializerMiddleware } from "@aws-sdk/middleware-serializer";
+import { Command } from '@aws-sdk/smithy-client';
+import { serializerPlugin } from "@aws-sdk/middleware-serializer";
 import { deserializerMiddleware } from "@aws-sdk/middleware-deserializer";
 import * as __aws_sdk_types from "@aws-sdk/types";
 import { RDSDataResolvedConfiguration } from "../RDSDataConfiguration";
 import { HttpRequest } from '@aws-sdk/protocol-http';
 import { executeStatementSerializer, executeStatementDeserializer } from '../protocol/ExecuteStatement'
-import { FinalizeHandlerArguments } from '@aws-sdk/types';
+import { FinalizeHandlerArguments, MiddlewareStack } from '@aws-sdk/types';
 
 /**
  * To remove this when move to Smithy model
@@ -15,16 +15,14 @@ type ExecuteStatementOutput = any;
 type InputTypesUnion = any;
 type OutputTypesUnion = any;
 
-export class ExecuteStatementCommand {
-  readonly middlewareStack = new __aws_sdk_middleware_stack.MiddlewareStack<
-    ExecuteStatementInput,
-    ExecuteStatementOutput
-  >();
+export class ExecuteStatementCommand extends Command<ExecuteStatementInput, ExecuteStatementOutput> {
 
-  constructor(readonly input: ExecuteStatementInput) {}
+  constructor(readonly input: ExecuteStatementInput) {
+    super();
+  }
 
   resolveMiddleware(
-    clientStack: __aws_sdk_middleware_stack.MiddlewareStack<
+    clientStack: MiddlewareStack<
       InputTypesUnion,
       OutputTypesUnion
     >,
@@ -33,17 +31,7 @@ export class ExecuteStatementCommand {
   ): __aws_sdk_types.Handler<ExecuteStatementInput, ExecuteStatementOutput> {
     const { httpHandler } = configuration;
 
-    this.middlewareStack.add(
-      serializerMiddleware(
-        configuration.protocol,
-        executeStatementSerializer
-      ),
-      {
-        step: "serialize",
-        priority: 90,
-        tags: { SERIALIZER: true }
-      }
-    );
+    this.use(serializerPlugin(configuration, executeStatementSerializer));
     this.middlewareStack.add(
       deserializerMiddleware<ExecuteStatementInput, ExecuteStatementOutput>(
         configuration.protocol,
@@ -63,7 +51,7 @@ export class ExecuteStatementCommand {
     };
 
     return stack.resolve(
-      (request: FinalizeHandlerArguments<any>) => {return httpHandler.handle(request.request as HttpRequest, options || {})},
+      (request: FinalizeHandlerArguments<any>) => { return httpHandler.handle(request.request as HttpRequest, options || {}) },
       handlerExecutionContext
     );
   }

packages/config-resolver/src/components.ts

@@ -7,7 +7,10 @@ import {
   DelayDecider,
   UrlParser,
   Protocol,
-  HttpOptions
+  HttpOptions,
+  StreamCollector,
+  Decoder,
+  Encoder
 } from "@aws-sdk/types";
 import { SignatureV4 } from "@aws-sdk/signature-v4";
 import {
@@ -17,6 +20,28 @@ import {
   HttpResponse
 } from "@aws-sdk/protocol-http";
 
+export interface RuntimeDependencies {
+  httpHandler?: HttpHandler;
+  sha256?: HashConstructor;
+  credentialDefaultProvider?: (input: any) => Provider<Credentials>;
+  regionDefaultProvider?: (input: any) => Provider<string>;
+  urlParser?: UrlParser;
+  bodyLengthChecker?: (body: any) => number | undefined;
+  streamCollector?: StreamCollector<any>;
+  base64Decoder?: Decoder;
+  base64Encoder?: Encoder;
+  utf8Decoder?: Decoder;
+  utf8Encoder?: Encoder;
+}
+
+export interface AWSClientRuntimeConfiguration extends RuntimeDependencies {
+  protocolDefaultProvider?: (
+    handler: HttpHandler
+  ) => Protocol<HttpRequest, HttpResponse>;
+  signingName?: string;
+  service?: string;
+}
+
 export function normalizeProvider<T>(input: T | Provider<T>): Provider<T> {
   if (typeof input === "object") {
     const promisified = Promise.resolve(input);

packages/middleware-content-length/src/index.ts

@@ -10,7 +10,7 @@ import {
 import { HttpRequest } from "@aws-sdk/protocol-http";
 
 export function contentLengthMiddleware(
-  bodyLengthCalculator: BodyLengthCalculator
+  bodyLengthChecker: BodyLengthCalculator
 ): BuildMiddleware<any, any> {
   return <Output extends MetadataBearer>(
     next: BuildHandler<any, Output>
@@ -27,7 +27,7 @@ export function contentLengthMiddleware(
           .map(str => str.toLowerCase())
           .indexOf("content-length") === -1
       ) {
-        const length = bodyLengthCalculator(body);
+        const length = bodyLengthChecker(body);
         if (length !== undefined) {
           request.headers = {
             ...request.headers,
@@ -44,11 +44,11 @@ export function contentLengthMiddleware(
   };
 }
 
-export function contentLengthPlugin(
-  bodyLengthCalculator: BodyLengthCalculator
-): InjectableMiddleware {
+export function contentLengthPlugin(options: {
+  bodyLengthChecker: BodyLengthCalculator;
+}): InjectableMiddleware {
   return {
-    middleware: contentLengthMiddleware(bodyLengthCalculator),
+    middleware: contentLengthMiddleware(options.bodyLengthChecker),
     step: "build",
     tags: { SET_CONTENT_LENGTH: true }
   };

packages/middleware-serializer/src/index.ts

@@ -4,25 +4,42 @@ import {
   SerializeHandlerArguments,
   SerializeMiddleware,
   SerializeHandlerOutput,
-  Protocol
+  Protocol,
+  SerializerConfig,
+  InjectableMiddleware
 } from "@aws-sdk/types";
 
 export function serializerMiddleware<
   Input extends object,
   Output extends object
 >(
-  protocol: Protocol<any, any>,
+  options: SerializerMiddlewareConfig,
   serializer: RequestSerializer<any>
 ): SerializeMiddleware<Input, Output> {
   return (
     next: SerializeHandler<Input, Output>
   ): SerializeHandler<Input, Output> => async (
     args: SerializeHandlerArguments<Input>
   ): Promise<SerializeHandlerOutput<Output>> => {
-    const request = protocol.serialize(serializer, args.input);
+    const request = options.protocol.serialize(serializer, args.input, options);
     return next({
       ...args,
       request
     });
   };
 }
+
+export interface SerializerMiddlewareConfig extends SerializerConfig {
+  protocol: Protocol<any, any>;
+}
+
+export function serializerPlugin(
+  config: SerializerMiddlewareConfig,
+  serializer: RequestSerializer<any>
+): InjectableMiddleware {
+  return {
+    middleware: serializerMiddleware(config, serializer),
+    step: "serialize",
+    tags: { SERIALIZER: true }
+  };
+}

packages/smithy-client/src/client.ts

@@ -0,0 +1,92 @@
+import { MiddlewareStack } from "@aws-sdk/middleware-stack";
+import {
+  Protocol,
+  Command,
+  MetadataBearer,
+  InjectableMiddleware,
+  HandlerOptions as InjectOptions
+} from "@aws-sdk/types";
+
+export interface SmithyConfiguration<HandlerOptions> {
+  protocol: Protocol<any, any, HandlerOptions>;
+}
+
+export type SmithyResolvedConfiguration<HandlerOptions> = SmithyConfiguration<
+  HandlerOptions
+>;
+
+export class SmithyClient<
+  HandlerOptions = any,
+  ClientInput extends object = any,
+  ClientOutput extends MetadataBearer = any
+> {
+  public middlewareStack = new MiddlewareStack<ClientInput, ClientOutput>();
+  readonly config: SmithyResolvedConfiguration<HandlerOptions>;
+  constructor(config: SmithyConfiguration<HandlerOptions>) {
+    this.config = config;
+  }
+  use(
+    injectable: InjectableMiddleware<ClientInput, ClientOutput>,
+    options: InjectOptions = {}
+  ) {
+    const { middleware, step, priority, tags } = injectable;
+    this.middlewareStack.add(
+      // @ts-ignore
+      middleware,
+      {
+        step: options.step || step,
+        priority: options.priority || priority,
+        tags: { ...tags, ...options.tags }
+      }
+    );
+  }
+  send<InputType extends ClientInput, OutputType extends ClientOutput>(
+    command: Command<
+      ClientInput,
+      InputType,
+      ClientOutput,
+      OutputType,
+      SmithyResolvedConfiguration<HandlerOptions>
+    >,
+    options?: HandlerOptions
+  ): Promise<OutputType>;
+  send<InputType extends ClientInput, OutputType extends ClientOutput>(
+    command: Command<
+      ClientInput,
+      InputType,
+      ClientOutput,
+      OutputType,
+      SmithyResolvedConfiguration<HandlerOptions>
+    >,
+    options: HandlerOptions,
+    cb: (err: any, data?: OutputType) => void
+  ): void;
+  send<InputType extends ClientInput, OutputType extends ClientOutput>(
+    command: Command<
+      ClientInput,
+      InputType,
+      ClientOutput,
+      OutputType,
+      SmithyResolvedConfiguration<HandlerOptions>
+    >,
+    options?: HandlerOptions,
+    cb?: (err: any, data?: OutputType) => void
+  ): Promise<OutputType> | void {
+    const handler = command.resolveMiddleware(
+      this.middlewareStack as any,
+      this.config,
+      options
+    );
+    if (cb) {
+      handler(command)
+        .then(result => cb(null, result.output), (err: any) => cb(err))
+        .catch(
+          // prevent any errors thrown in the callback from triggering an
+          // unhandled promise rejection
+          () => {}
+        );
+    } else {
+      return handler(command).then(result => result.output);
+    }
+  }
+}

packages/smithy-client/src/command.ts

@@ -0,0 +1,24 @@
+import { MiddlewareStack } from "@aws-sdk/middleware-stack";
+import {
+  InjectableMiddleware,
+  HandlerOptions as InjectOptions
+} from "@aws-sdk/types";
+
+export class Command<InputType extends object, OutputType extends object> {
+  readonly middlewareStack = new MiddlewareStack<InputType, OutputType>();
+  use(
+    injectable: InjectableMiddleware<InputType, OutputType>,
+    options: InjectOptions = {}
+  ) {
+    const { middleware, step, priority, tags } = injectable;
+    this.middlewareStack.add(
+      // @ts-ignore
+      middleware,
+      {
+        step: options.step || step,
+        priority: options.priority || priority,
+        tags: { ...tags, ...options.tags }
+      }
+    );
+  }
+}