feat: remove protocol rest json class (#438)

* feat: remove rest-json protocol class

* feat: rename handler to RequestHandler; Consolidate types

Author: AllanZhengYP

packages/config-resolver/src/HandlerConfig.ts

@@ -0,0 +1,7 @@
+import { RequestHandler } from "@aws-sdk/types";
+
+export function destroyRequestHandlerConfig(config: {
+  requestHandler: RequestHandler<any, any, any>;
+}): void {
+  if (config.requestHandler.destroy) config.requestHandler.destroy();
+}

packages/config-resolver/src/ProtocolConfig.ts

@@ -1,3 +1,3 @@
 export * from "./EndpointsConfig";
 export * from "./RegionConfig";
-export * from "./ProtocolConfig";
+export * from "./HandlerConfig";

packages/config-resolver/src/index.ts

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

packages/middleware-serde/src/deserializerMiddleware.ts

@@ -2,24 +2,25 @@ import {
   RequestSerializer,
   ResponseDeserializer,
   Pluggable,
-  Protocol,
   MetadataBearer,
   MiddlewareStack,
-  EndpointBearer
+  EndpointBearer,
+  RequestHandler
 } from "@aws-sdk/types";
 import { deserializerMiddleware } from "./deserializerMiddleware";
 import { serializerMiddleware } from "./serializerMiddleware";
 
 export function getSerdePlugin<
   InputType extends object,
-  SerializerRuntimeUtils extends EndpointBearer,
-  OutputType extends MetadataBearer,
-  DeserializerRuntimeUtils
+  SerDeContext extends EndpointBearer,
+  OutputType extends MetadataBearer
 >(
-  config: SerializerRuntimeUtils &
-    DeserializerRuntimeUtils & { protocol: Protocol<any, any> },
-  serializer: RequestSerializer<any, SerializerRuntimeUtils>,
-  deserializer: ResponseDeserializer<OutputType, any, DeserializerRuntimeUtils>
+  config: SerDeContext & {
+    protocol: string;
+    requestHandler: RequestHandler<any, any, any>;
+  },
+  serializer: RequestSerializer<any, SerDeContext>,
+  deserializer: ResponseDeserializer<OutputType, any, SerDeContext>
 ): Pluggable<InputType, OutputType> {
   return {
     applyToStack: (commandStack: MiddlewareStack<InputType, OutputType>) => {

packages/middleware-serde/src/serdePlugin.ts

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

packages/middleware-serde/src/serializerMiddleware.ts

@@ -1,8 +1,8 @@
 import { HttpRequest } from "./httpRequest";
 import { HttpResponse } from "./httpResponse";
-import { TransferHandler, HttpOptions } from "@aws-sdk/types";
+import { RequestHandler, HttpOptions } from "@aws-sdk/types";
 
-export type HttpHandler = TransferHandler<
+export type HttpHandler = RequestHandler<
   HttpRequest,
   HttpResponse,
   HttpOptions

packages/protocol-http/src/httpHandler.ts

@@ -1,22 +1,30 @@
 import { MiddlewareStack } from "@aws-sdk/middleware-stack";
-import { Protocol, Command, MetadataBearer } from "@aws-sdk/types";
+import {
+  RequestHandler,
+  MetadataBearer,
+  Command,
+  Client as IClient
+} from "@aws-sdk/types";
 
 export interface SmithyConfiguration<HandlerOptions> {
-  protocol: Protocol<any, any, HandlerOptions>;
+  requestHandler: RequestHandler<any, any, HandlerOptions>;
 }
 
 export type SmithyResolvedConfiguration<HandlerOptions> = SmithyConfiguration<
   HandlerOptions
 >;
 
 export class Client<
-  HandlerOptions = any,
-  ClientInput extends object = any,
-  ClientOutput extends MetadataBearer = any
-> {
+  HandlerOptions,
+  ClientInput extends object,
+  ClientOutput extends MetadataBearer,
+  ResolvedClientConfiguration extends SmithyResolvedConfiguration<
+    HandlerOptions
+  >
+> implements IClient<ClientInput, ClientOutput, ResolvedClientConfiguration> {
   public middlewareStack = new MiddlewareStack<ClientInput, ClientOutput>();
-  readonly config: SmithyResolvedConfiguration<HandlerOptions>;
-  constructor(config: SmithyConfiguration<HandlerOptions>) {
+  readonly config: ResolvedClientConfiguration;
+  constructor(config: ResolvedClientConfiguration) {
     this.config = config;
   }
   send<InputType extends ClientInput, OutputType extends ClientOutput>(

packages/smithy-client/src/client.ts

@@ -1,5 +1,26 @@
 import { MiddlewareStack } from "@aws-sdk/middleware-stack";
+import { Command as ICommand, MetadataBearer, Handler } from "@aws-sdk/types";
 
-export class Command<InputType extends object, OutputType extends object> {
-  readonly middlewareStack = new MiddlewareStack<InputType, OutputType>();
+export abstract class Command<
+  ClientInput extends object,
+  Input extends ClientInput,
+  ClientOutput extends MetadataBearer,
+  Output extends ClientOutput,
+  ResolvedClientConfiguration
+>
+  implements
+    ICommand<
+      ClientInput,
+      Input,
+      ClientOutput,
+      Output,
+      ResolvedClientConfiguration
+    > {
+  abstract input: Input;
+  readonly middlewareStack = new MiddlewareStack<Input, Output>();
+  abstract resolveMiddleware(
+    stack: MiddlewareStack<ClientInput, ClientOutput>,
+    configuration: ResolvedClientConfiguration,
+    options: any
+  ): Handler<Input, Output>;
 }

packages/smithy-client/src/command.ts

@@ -1,103 +1,22 @@
 import { MiddlewareStack } from "./middleware";
-import { Provider, Decoder, Encoder, UrlParser } from "./util";
-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";
-
-export interface ConfigurationPropertyDefinition<
-  InputType,
-  ResolvedType extends InputType,
-  ServiceConfiguration extends { [key: string]: any },
-  ResolvedConfiguration extends ServiceConfiguration
-> {
-  /**
-   * Whether this property must be supplied by the user of a client. If value
-   * must be resolved but a default is available, this property should be
-   * `false` or undefined.
-   */
-  required?: boolean;
-
-  /**
-   * A static value to use as the default should none be supplied.
-   */
-  defaultValue?: ResolvedType;
-
-  /**
-   * A function that returns a default value for this property. It will be
-   * called if no value is supplied.
-   */
-  defaultProvider?: {
-    (config: ResolvedConfiguration): ResolvedType;
-  };
-
-  /**
-   * A function that normalizes input to the subtype expected by the SDK.
-   */
-  normalize?: {
-    (value: InputType, config: Partial<ResolvedConfiguration>): ResolvedType;
-  };
-}
-
-/**
- * A map of configuration property names to configuration property definitions.
- *
- * Order is significant in the definition provided, as the config object passed
- * to any `defaultProvider` and `apply` functions will only include properties
- * that have already been resolved.
- */
-export type ConfigurationDefinition<
-  Configuration extends { [key: string]: any },
-  ResolvedConfiguration extends Configuration
-> = {
-  readonly [P in keyof Configuration]: ConfigurationPropertyDefinition<
-    Configuration[P],
-    ResolvedConfiguration[P],
-    Configuration,
-    ResolvedConfiguration
-  >;
-};
-
-/**
- * A general interface for service clients' configuration interface.
- * It is idempotent among browser or node clients
- */
-export interface ClientResolvedConfigurationBase {
-  credentials?: Provider<Credentials>;
-  profile?: string;
-  maxRedirects?: number;
-  maxRetries?: number;
-  region?: Provider<string>;
-  sslEnabled?: boolean;
-  urlParser?: UrlParser;
-  endpointProvider?: any;
-  endpoint?: Provider<Endpoint>;
-  base64Decoder?: Decoder;
-  base64Encoder?: Encoder;
-  utf8Decoder?: Decoder;
-  utf8Incoder?: Encoder;
-  _user_injected_http_handler?: boolean;
-  httpHandler?: TransferHandler<any, any>;
-  md5?: { new (): Hash };
-  sha256?: HashConstructor;
-}
 
 /**
  * function definition for different overrides of client's 'send' function.
  */
 interface InvokeFunction<
   InputTypes extends object,
-  OutputTypes extends MetadataBearer
+  OutputTypes extends MetadataBearer,
+  ResolvedClientConfiguration
 > {
   <InputType extends InputTypes, OutputType extends OutputTypes>(
     command: Command<
       InputTypes,
       InputType,
       OutputTypes,
       OutputType,
-      ClientResolvedConfigurationBase
+      ResolvedClientConfiguration
     >,
     options?: any
   ): Promise<OutputType>;
@@ -107,7 +26,7 @@ interface InvokeFunction<
       InputType,
       OutputTypes,
       OutputType,
-      ClientResolvedConfigurationBase
+      ResolvedClientConfiguration
     >,
     options: any,
     cb: (err: any, data?: OutputType) => void
@@ -118,7 +37,7 @@ interface InvokeFunction<
       InputType,
       OutputTypes,
       OutputType,
-      ClientResolvedConfigurationBase
+      ResolvedClientConfiguration
     >,
     options?: any,
     cb?: (err: any, data?: OutputType) => void
@@ -128,8 +47,12 @@ interface InvokeFunction<
 /**
  * A general interface for service clients, idempotent to browser or node clients
  */
-export interface AWSClient {
-  // readonly config: ClientResolvedConfigurationBase;
-  middlewareStack: MiddlewareStack<any, any>;
-  send: InvokeFunction<any, any>;
+export interface Client<
+  Input extends object,
+  Output extends MetadataBearer,
+  ResolvedClientConfiguration
+> {
+  readonly config: ResolvedClientConfiguration;
+  middlewareStack: MiddlewareStack<Input, Output>;
+  send: InvokeFunction<Input, Output, ResolvedClientConfiguration>;
 }