feat: parse serialize(deserialize) util functions from client config

* Serializers/Deserializers should take utils functions from client config
first, if not available then fallback to generated dependencies. This
allows configuring the runtime dependencies manually from client config when
runtime-specific bundlers' decision is not accountable

Author: AllanZhengYP

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

@@ -1,6 +1,6 @@
 import { Command } from '@aws-sdk/smithy-client';
 import { serializerPlugin } from "@aws-sdk/middleware-serializer";
-import { deserializerMiddleware } from "@aws-sdk/middleware-deserializer";
+import { deserializerPlugin } 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';
@@ -32,17 +32,7 @@ export class ExecuteStatementCommand extends Command<ExecuteStatementInput, Exec
     const { httpHandler } = configuration;
 
     this.use(serializerPlugin(configuration, executeStatementSerializer));
-    this.middlewareStack.add(
-      deserializerMiddleware<ExecuteStatementInput, ExecuteStatementOutput>(
-        configuration.protocol,
-        executeStatementDeserializer
-      ) as any,
-      {
-        step: "deserialize",
-        priority: Infinity,
-        tags: { DESERIALIZER: true }
-      }
-    );
+    this.use(deserializerPlugin<ExecuteStatementOutput>(configuration, executeStatementDeserializer));
 
     const stack = clientStack.concat(this.middlewareStack);
 

clients/node/client-rds-data-node/protocol/AwsRestJson1_1.ts

@@ -6,11 +6,15 @@ import {
   SqlParameter
 } from "../models/rdsdataservice";
 import { HttpRequest, HttpResponse } from "@aws-sdk/protocol-http";
+import { SerializerUtils, DeserializerUtils } from '@aws-sdk/types';
 import * as __aws_sdk_stream_collector_node from "@aws-sdk/stream-collector-node";
 import * as __aws_sdk_util_utf8_node from "@aws-sdk/util-utf8-node";
 
+type Utils = { [key: string]: any };
+
 export function executeStatementAwsRestJson1_1Serialize(
-  input: ExecuteStatementRequest
+  input: ExecuteStatementRequest,
+  utils?: Utils
 ): HttpRequest {
   let body: any = {};
   if (input.resourceArn !== undefined) {
@@ -61,12 +65,13 @@ export function executeStatementAwsRestJson1_1Serialize(
 }
 
 export function executeStatementAwsRestJson1_1Deserialize(
-  output: HttpResponse
+  output: HttpResponse,
+  utils?: Utils
 ): Promise<ExecuteStatementResponse> {
   if (output.statusCode !== 200) {
     return executeStatementAwsRestJson1_1DeserializeError(output);
   }
-  let data: any = parseBody(output.body);
+  let data: any = parseBody(output.body, utils);
   return Promise.resolve({
     __type: "com.amazon.rdsdataservice#ExecuteStatementResponse",
     records: recordsAwsRestJson1_1Deserialize(data.records),
@@ -290,8 +295,14 @@ function recordsListAwsRestJson1_1Deserialize(input: any): Array<Field> {
   return list;
 }
 
-function parseBody(streamBody: any): any {
-  __aws_sdk_stream_collector_node.streamCollector(streamBody).then(body => {
-    return __aws_sdk_util_utf8_node.toUtf8(body);
+function parseBody(streamBody: any, utils?: Utils): any {
+  const streamCollector = utils && utils['streamCollector'] ?
+    (<DeserializerUtils>utils)['streamCollector'] :
+    __aws_sdk_stream_collector_node.streamCollector;
+  const toUtf8 = utils && utils['streamCollector'] ?
+    (<DeserializerUtils>utils)['utf8Encoder'] :
+    __aws_sdk_util_utf8_node.toUtf8;
+  streamCollector(streamBody).then(body => {
+    return toUtf8(body);
   });
 }

clients/node/client-rds-data-node/protocol/ExecuteStatement.ts

@@ -8,25 +8,29 @@ import {
   executeStatementAwsRestJson1_1Deserialize
 } from "./AwsRestJson1_1";
 
+type Utils = { [key: string]: any };
+
 export function executeStatementSerializer(
   input: ExecuteStatementRequest,
-  protocol: string
+  protocol: string,
+  utils?: Utils
 ): HttpRequest {
   switch (protocol) {
     case "aws.rest-json-1.1":
-      return executeStatementAwsRestJson1_1Serialize(input);
+      return executeStatementAwsRestJson1_1Serialize(input, utils);
     default:
       throw new Error("Unknown protocol, use aws.rest-json-1.1");
   }
 }
 
 export async function executeStatementDeserializer(
   output: HttpResponse,
-  protocol: string
+  protocol: string,
+  utils?: Utils
 ): Promise<ExecuteStatementResponse> {
   switch (protocol) {
     case "aws.rest-json-1.1":
-      return executeStatementAwsRestJson1_1Deserialize(output);
+      return executeStatementAwsRestJson1_1Deserialize(output, utils);
     default:
       throw new Error("Unknown protocol, use aws.rest-json-1.1");
   }

packages/config-resolver/src/components.ts

@@ -27,7 +27,7 @@ export interface RuntimeDependencies {
   regionDefaultProvider?: (input: any) => Provider<string>;
   urlParser?: UrlParser;
   bodyLengthChecker?: (body: any) => number | undefined;
-  streamCollector?: StreamCollector<any>;
+  streamCollector?: StreamCollector;
   base64Decoder?: Decoder;
   base64Encoder?: Encoder;
   utf8Decoder?: Decoder;

packages/middleware-deserializer/src/index.ts

@@ -4,14 +4,16 @@ import {
   DeserializeHandlerArguments,
   DeserializeMiddleware,
   DeserializeHandlerOutput,
-  Protocol
+  Protocol,
+  DeserializerUtils,
+  InjectableMiddleware
 } from "@aws-sdk/types";
 
 export function deserializerMiddleware<
   Input extends object,
   Output extends object
 >(
-  protocol: Protocol<any, any>,
+  options: DeserializerMiddlewareConfig,
   deserializer: ResponseDeserializer<any>
 ): DeserializeMiddleware<Input, Output> {
   return (
@@ -20,10 +22,29 @@ export function deserializerMiddleware<
     args: DeserializeHandlerArguments<Input>
   ): Promise<DeserializeHandlerOutput<Output>> => {
     const { response } = await next(args);
-    const parsed = await protocol.parse(deserializer, response);
+    const parsed = await options.protocol.deserialize(
+      deserializer,
+      response,
+      options
+    );
     return {
       response,
       output: parsed as Output
     };
   };
 }
+
+export interface DeserializerMiddlewareConfig extends DeserializerUtils {
+  protocol: Protocol<any, any>;
+}
+
+export function deserializerPlugin<OutputType>(
+  config: DeserializerMiddlewareConfig,
+  serializer: ResponseDeserializer<OutputType>
+): InjectableMiddleware {
+  return {
+    middleware: deserializerMiddleware(config, serializer),
+    step: "deserialize",
+    tags: { DESERIALIZER: true }
+  };
+}

packages/middleware-serializer/src/index.ts

@@ -5,7 +5,7 @@ import {
   SerializeMiddleware,
   SerializeHandlerOutput,
   Protocol,
-  SerializerConfig,
+  SerializerUtils,
   InjectableMiddleware
 } from "@aws-sdk/types";
 
@@ -29,7 +29,7 @@ export function serializerMiddleware<
   };
 }
 
-export interface SerializerMiddlewareConfig extends SerializerConfig {
+export interface SerializerMiddlewareConfig extends SerializerUtils {
   protocol: Protocol<any, any>;
 }
 

packages/protocol-rest-json/src/index.ts

@@ -3,7 +3,9 @@ import {
   ResponseDeserializer,
   Protocol,
   TransferHandler,
-  HttpOptions
+  HttpOptions,
+  SerializerUtils,
+  DeserializerUtils
 } from "@aws-sdk/types";
 import { HttpRequest, HttpResponse } from "@aws-sdk/protocol-http";
 
@@ -17,10 +19,18 @@ export class RestJsonProtocol extends Protocol<
   ) {
     super(handler);
   }
-  serialize(serializer: RequestSerializer<HttpRequest>, input: any) {
+  serialize(
+    serializer: RequestSerializer<HttpRequest>,
+    input: any,
+    utils?: SerializerUtils
+  ) {
     return serializer(input, "aws.rest-json-1.1");
   }
-  parse(parser: ResponseDeserializer<HttpResponse>, output: HttpResponse) {
+  deserialize(
+    parser: ResponseDeserializer<HttpResponse>,
+    output: HttpResponse,
+    utils?: DeserializerUtils
+  ) {
     return parser(output, "aws.rest-json-1.1") as any;
   }
 }

packages/stream-collector-browser/src/index.ts

@@ -1,6 +1,6 @@
 import { StreamCollector } from "@aws-sdk/types";
 
-export const streamCollector: StreamCollector<Blob> = function streamCollector(
+export const streamCollector: StreamCollector = function streamCollector(
   stream: Blob
 ): Promise<Uint8Array> {
   return new Promise<Uint8Array>((resolve, reject) => {

packages/stream-collector-node/src/index.ts

@@ -2,9 +2,9 @@ import { Readable } from "stream";
 import { StreamCollector } from "@aws-sdk/types";
 import { Collector } from "./collector";
 
-export const streamCollector: StreamCollector<
-  Readable
-> = function streamCollector(stream): Promise<Uint8Array> {
+export const streamCollector: StreamCollector = function streamCollector(
+  stream: Readable
+): Promise<Uint8Array> {
   return new Promise((resolve, reject) => {
     const collector = new Collector();
     stream.pipe(collector);

packages/types/src/deserializer.ts

@@ -10,9 +10,9 @@ export interface StreamCollector {
 }
 
 /**
- * Response deserializer config interface for AWS services
+ * Response deserializer utils functions for AWS services
  */
-export interface DeserializerConfig {
+export interface DeserializerUtils {
   base64Decoder: Decoder;
   utf8Encoder: Encoder;
   streamCollector: StreamCollector;
@@ -26,12 +26,12 @@ export interface ResponseDeserializer<OutputType, ResponseType = any> {
    *                  response received
    * @param input     The HTTP response received from the service
    *
-   * @param config    The runtime-specific util functions. If provided will
+   * @param utils    The runtime-specific util functions. If provided will
    *                  overwrite the provided ones
    */
   (
     output: ResponseType,
     protocolName: string,
-    config?: { [key: string]: any }
+    utils?: { [key: string]: any }
   ): Promise<OutputType>;
 }

packages/types/src/serializer.ts

@@ -1,9 +1,9 @@
 import { Decoder, Encoder } from "./util";
 
 /**
- * Response deserializer config interface for AWS services
+ * Response deserializer util functions for AWS services
  */
-export interface SerializerConfig {
+export interface SerializerUtils {
   utf8Decoder: Decoder;
   base64Encoder: Encoder;
 }
@@ -22,6 +22,6 @@ export interface RequestSerializer<Request> {
   (
     input: any,
     transferProtocol: string,
-    config?: { [key: string]: any }
+    utils?: { [key: string]: any }
   ): Request;
 }

packages/types/src/transfer.ts

@@ -22,11 +22,11 @@ export abstract class Protocol<RequestType, ResponseType, HandlerOptions = {}> {
   abstract serialize(
     serializer: RequestSerializer<RequestType>,
     input: any,
-    config?: { [key: string]: any }
+    utils?: { [key: string]: any }
   ): RequestType;
   abstract deserialize<T extends ResponseDeserializer<ResponseType>>(
     parser: T,
     input: ResponseType,
-    config?: { [key: string]: any }
+    utils?: { [key: string]: any }
   ): ReturnType<T>;
 }