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,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>;
 }