Combine serde context (#418)

* feat: combine serde types, cleanup unused imports

* feat: update model location

* feat: change Injectable to Pluggable

Author: Chase Coalwell

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

@@ -5,7 +5,7 @@ import {
   BodyLengthCalculator,
   MetadataBearer,
   BuildHandlerOutput,
-  Injectable
+  Pluggable
 } from "@aws-sdk/types";
 import { HttpRequest } from "@aws-sdk/protocol-http";
 
@@ -46,7 +46,7 @@ export function contentLengthMiddleware(
 
 export const contentLengthPlugin = (options: {
   bodyLengthChecker: BodyLengthCalculator;
-}): Injectable<any, any> => clientStack => {
+}): Pluggable<any, any> => clientStack => {
   clientStack.add(contentLengthMiddleware(options.bodyLengthChecker), {
     step: "build",
     tags: { SET_CONTENT_LENGTH: true }

packages/middleware-serde/src/serdePlugin.ts

@@ -1,12 +1,11 @@
 import {
   RequestSerializer,
   ResponseDeserializer,
-  Injectable,
+  Pluggable,
   Protocol,
   MetadataBearer,
   MiddlewareStack,
-  EndpointBearer,
-  Provider
+  EndpointBearer
 } from "@aws-sdk/types";
 import { deserializerMiddleware } from "./deserializerMiddleware";
 import { serializerMiddleware } from "./serializerMiddleware";
@@ -17,11 +16,11 @@ export function serdePlugin<
   OutputType extends MetadataBearer,
   DeserializerRuntimeUtils
 >(
-  config: PromisifyEndpoint<SerializerRuntimeUtils> &
+  config: SerializerRuntimeUtils &
     DeserializerRuntimeUtils & { protocol: Protocol<any, any> },
   serializer: RequestSerializer<any, SerializerRuntimeUtils>,
   deserializer: ResponseDeserializer<OutputType, any, DeserializerRuntimeUtils>
-): Injectable<InputType, OutputType> {
+): Pluggable<InputType, OutputType> {
   return (commandStack: MiddlewareStack<InputType, OutputType>) => {
     commandStack.add(deserializerMiddleware(config, deserializer), {
       step: "deserialize",
@@ -33,7 +32,3 @@ export function serdePlugin<
     });
   };
 }
-
-export type PromisifyEndpoint<T extends EndpointBearer> = {
-  [K in keyof T]: K extends "endpoint" ? Provider<T[K]> : T[K];
-};

packages/middleware-serde/src/serializerMiddleware.ts

@@ -7,14 +7,13 @@ import {
   Protocol,
   EndpointBearer
 } from "@aws-sdk/types";
-import { PromisifyEndpoint } from "./serdePlugin";
 
 export function serializerMiddleware<
   Input extends object,
   Output extends object,
   RuntimeUtils extends EndpointBearer
 >(
-  options: { protocol: Protocol<any, any> } & PromisifyEndpoint<RuntimeUtils>,
+  options: { protocol: Protocol<any, any> } & RuntimeUtils,
   serializer: RequestSerializer<any, RuntimeUtils>
 ): SerializeMiddleware<Input, Output> {
   return (

packages/smithy-client/src/client.ts

@@ -1,5 +1,5 @@
 import { MiddlewareStack } from "@aws-sdk/middleware-stack";
-import { Protocol, Command, MetadataBearer, Injectable } from "@aws-sdk/types";
+import { Protocol, Command, MetadataBearer, Pluggable } from "@aws-sdk/types";
 
 export interface SmithyConfiguration<HandlerOptions> {
   protocol: Protocol<any, any, HandlerOptions>;
@@ -19,8 +19,8 @@ export class Client<
   constructor(config: SmithyConfiguration<HandlerOptions>) {
     this.config = config;
   }
-  use(injectable: Injectable<ClientInput, ClientOutput>) {
-    injectable(this.middlewareStack);
+  use(pluggable: Pluggable<ClientInput, ClientOutput>) {
+    pluggable(this.middlewareStack);
   }
   send<InputType extends ClientInput, OutputType extends ClientOutput>(
     command: Command<

packages/smithy-client/src/command.ts

@@ -1,9 +1,9 @@
 import { MiddlewareStack } from "@aws-sdk/middleware-stack";
-import { Injectable, HandlerOptions as InjectOptions } from "@aws-sdk/types";
+import { Pluggable, HandlerOptions as InjectOptions } from "@aws-sdk/types";
 
 export class Command<InputType extends object, OutputType extends object> {
   readonly middlewareStack = new MiddlewareStack<InputType, OutputType>();
-  use(injectable: Injectable<InputType, OutputType>) {
-    injectable(this.middlewareStack);
+  use(pluggable: Pluggable<InputType, OutputType>) {
+    pluggable(this.middlewareStack);
   }
 }

packages/types/src/client.ts

@@ -1,15 +1,11 @@
-import { MiddlewareStack, Terminalware } from "./middleware";
-import { Structure } from "./protocol";
+import { MiddlewareStack } from "./middleware";
 import { Provider, Decoder, Encoder, UrlParser } from "./util";
-// import { StreamCollector, ResponseParser } from "./unmarshaller";
-import { RequestSerializer } from "./serializer";
 import { Endpoint } from "./http";
 import { TransferHandler } from "./transfer";
 import { Command } from "./command";
 import { MetadataBearer } from "./response";
 import { Credentials } from "./credentials";
 import { Hash, HashConstructor } from "./crypto";
-import { Middleware } from "./middleware";
 
 export interface ConfigurationPropertyDefinition<
   InputType,
@@ -82,9 +78,6 @@ export interface ClientResolvedConfigurationBase {
   base64Encoder?: Encoder;
   utf8Decoder?: Decoder;
   utf8Incoder?: Encoder;
-  // streamCollector?: StreamCollector<StreamType>;
-  // serializer?: Provider<RequestSerializer<StreamType>>;
-  // parser?: ResponseParser<StreamType>;
   _user_injected_http_handler?: boolean;
   httpHandler?: TransferHandler<any, any>;
   md5?: { new (): Hash };

packages/types/src/deserializer.ts

@@ -6,11 +6,10 @@ export * from "./crypto";
 export * from "./exception";
 export * from "./http";
 export * from "./logger";
-export * from "./serializer";
+export * from "./serde";
 export * from "./middleware";
 export * from "./protocol";
 export * from "./response";
 export * from "./signature";
-export * from "./deserializer";
 export * from "./transfer";
 export * from "./util";

packages/types/src/index.ts

@@ -366,7 +366,7 @@ export interface HandlerExecutionContext {
   logger: Logger;
 }
 
-export interface Injectable<Input extends object, Output extends object> {
+export interface Pluggable<Input extends object, Output extends object> {
   /**
    * A function that mutate the passed in middleware stack. Functions implementing
    * this interface can add, remove, modify existing middleware stack from clients

packages/types/src/middleware.ts

@@ -0,0 +1,64 @@
+import { Decoder, Encoder, Provider } from "./util";
+import { Endpoint } from "./http";
+
+/**
+ * Interface for object requires an Endpoint set.
+ */
+export interface EndpointBearer {
+  endpoint: Provider<Endpoint>;
+}
+
+export interface StreamCollector {
+  /**
+   * A function that converts a stream into an array of bytes.
+   *
+   * @param stream  The low-level native stream from browser or Nodejs runtime
+   */
+  (stream: any): Promise<Uint8Array>;
+}
+
+/**
+ * Request and Response serde util functions for AWS services
+ */
+export interface SerdeContext extends EndpointBearer {
+  base64Encoder: Encoder;
+  base64Decoder: Decoder;
+  utf8Encoder: Encoder;
+  utf8Decoder: Decoder;
+  streamCollector: StreamCollector;
+}
+
+export interface RequestSerializer<
+  Request,
+  Context extends EndpointBearer = any
+> {
+  /**
+   * 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): Request;
+}
+
+export interface ResponseDeserializer<
+  OutputType,
+  ResponseType = any,
+  Context = any
+> {
+  /**
+   * 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 context    context containing runtime-specific util functions.
+   */
+  (output: ResponseType, protocolName: string, context: Context): Promise<
+    OutputType
+  >;
+}

packages/types/src/serde.ts

@@ -1,5 +1,4 @@
-import { RequestSerializer } from "./serializer";
-import { ResponseDeserializer } from "./deserializer";
+import { RequestSerializer, ResponseDeserializer } from "./serde";
 
 export type TransferHandlerOutput<ResponseType> = { response: ResponseType };