chore: add updated RDS DATA smithy model (#370)

* chore: add http request type guard for middlewares

header default middleware
expect continue middleare

* chore: add http request type guard for apply body checksum middlewares

* chore: only build and test demo smithy client

* feat: add isInstance to httpResponse

* chore: update rds data model

* chore: update to ts3.7; update rds model#3

* chore: update tsconfig to genenerte types only once

* chore: update gitignore

* chore: parse body with streamCollector

* chore: add error deserialization

* chore: stub Field union

* fix: fix middleware-header-default test

* fix: fix retry-middleware unit test

Author: AllanZhengYP

packages/fetch-http-handler/src/fetch-http-handler.spec.ts

@@ -1,6 +1,7 @@
 import { FetchHttpHandler } from "./fetch-http-handler";
 import { AbortController } from "@aws-sdk/abort-controller";
 import * as timeouts from "./request-timeout";
+import { HttpRequest } from "@aws-sdk/protocol-http";
 
 const mockRequest = jest.fn();
 let mockResponse: any;
@@ -66,14 +67,14 @@ describe("httpHandler", () => {
 
     (global as any).fetch = mockFetch;
 
-    let httpRequest = {
+    let httpRequest = new HttpRequest({
       headers: {},
       hostname: "foo.amazonaws.com",
       method: "GET",
       path: "/test/?bar=baz",
       protocol: "https:",
       port: 443
-    };
+    });
     const fetchHttpHandler = new FetchHttpHandler();
 
     let response = await fetchHttpHandler.handle(httpRequest, {});

packages/fetch-http-handler/src/fetch-http-handler.ts

@@ -1,11 +1,5 @@
-import {
-  HttpOptions,
-  HeaderBag,
-  HttpHandlerOptions,
-  HttpRequest,
-  HttpResponse
-} from "@aws-sdk/types";
-import { HttpHandler } from "@aws-sdk/protocol-http";
+import { HttpOptions, HeaderBag, HttpHandlerOptions } from "@aws-sdk/types";
+import { HttpHandler, HttpRequest, HttpResponse } from "@aws-sdk/protocol-http";
 import { requestTimeout } from "./request-timeout";
 import { buildQueryString } from "@aws-sdk/querystring-builder";
 
@@ -31,9 +25,9 @@ export class FetchHttpHandler implements HttpHandler {
   }
 
   handle(
-    request: HttpRequest<Blob>,
+    request: HttpRequest,
     options: HttpHandlerOptions
-  ): Promise<{ response: HttpResponse<Blob> }> {
+  ): Promise<{ response: HttpResponse }> {
     const abortSignal = options && options.abortSignal;
     const requestTimeoutInMs = this.httpOptions.requestTimeout;
 
@@ -78,12 +72,12 @@ export class FetchHttpHandler implements HttpHandler {
           transformedHeaders[pair[0]] = pair[1];
         }
 
-        return response.blob().then<{ response: HttpResponse<Blob> }>(body => ({
-          response: {
+        return response.blob().then<{ response: HttpResponse }>(body => ({
+          response: new HttpResponse({
             headers: transformedHeaders,
             statusCode: response.status,
             body
-          }
+          })
         }));
       }),
       requestTimeout(requestTimeoutInMs)

packages/node-http-handler/src/node-http-handler.spec.ts

@@ -1,4 +1,5 @@
 import { AbortController } from "@aws-sdk/abort-controller";
+import { HttpRequest, HttpResponse } from "@aws-sdk/protocol-http";
 import { Server as HttpServer } from "http";
 import { Server as HttpsServer } from "https";
 import * as https from "https";
@@ -8,7 +9,6 @@ import { ReadFromBuffers } from "./readable.mock";
 import {
   createMockHttpServer,
   createMockHttpsServer,
-  createContinueResponseFunction,
   createResponseFunction
 } from "./server.mock";
 import { AddressInfo } from "net";
@@ -38,14 +38,14 @@ describe("NodeHttpHandler", () => {
       const nodeHttpHandler = new NodeHttpHandler();
 
       let { response } = await nodeHttpHandler.handle(
-        {
+        new HttpRequest({
           hostname: "localhost",
           method: "GET",
           port: (mockHttpServer.address() as AddressInfo).port,
           protocol: "http:",
           path: "/",
           headers: {}
-        },
+        }),
         {}
       );
 
@@ -247,14 +247,14 @@ describe("NodeHttpHandler", () => {
 
       await expect(
         nodeHttpHandler.handle(
-          {
+          new HttpRequest({
             hostname: "localhost",
             method: "GET",
             port: (mockHttpsServer.address() as AddressInfo).port,
             protocol: "fake:", // trigger a request error
             path: "/",
             headers: {}
-          },
+          }),
           {}
         )
       ).rejects.toHaveProperty("message");
@@ -281,14 +281,14 @@ describe("NodeHttpHandler", () => {
 
       await expect(
         nodeHttpHandler.handle(
-          {
+          new HttpRequest({
             hostname: "localhost",
             method: "GET",
             port: (mockHttpsServer.address() as AddressInfo).port,
             protocol: "https:",
             path: "/",
             headers: {}
-          },
+          }),
           {
             abortSignal: {
               aborted: true
@@ -331,14 +331,14 @@ describe("NodeHttpHandler", () => {
 
       await expect(
         nodeHttpHandler.handle(
-          {
+          new HttpRequest({
             hostname: "localhost",
             method: "GET",
             port: (mockHttpsServer.address() as AddressInfo).port,
             protocol: "https:",
             path: "/",
             headers: {}
-          },
+          }),
           {
             abortSignal: abortController.signal
           }

packages/node-http-handler/src/node-http-handler.ts

@@ -2,14 +2,8 @@ import * as https from "https";
 import * as http from "http";
 import { Readable } from "stream";
 import { buildQueryString } from "@aws-sdk/querystring-builder";
-import {
-  HeaderBag,
-  HttpOptions,
-  HttpRequest,
-  HttpResponse,
-  NodeHttpOptions
-} from "@aws-sdk/types";
-import { HttpHandler } from "@aws-sdk/protocol-http";
+import { HeaderBag, HttpOptions, NodeHttpOptions } from "@aws-sdk/types";
+import { HttpHandler, HttpRequest, HttpResponse } from "@aws-sdk/protocol-http";
 import { setConnectionTimeout } from "./set-connection-timeout";
 import { setSocketTimeout } from "./set-socket-timeout";
 import { writeRequestBody } from "./write-request-body";
@@ -30,9 +24,9 @@ export class NodeHttpHandler implements HttpHandler {
   }
 
   handle(
-    request: HttpRequest<Readable>,
+    request: HttpRequest,
     options: HttpOptions
-  ): Promise<{ response: HttpResponse<Readable> }> {
+  ): Promise<{ response: HttpResponse }> {
     // determine which http(s) client to use
     const isSSL = request.protocol === "https:";
     const httpClient = isSSL ? https : http;
@@ -78,11 +72,11 @@ export class NodeHttpHandler implements HttpHandler {
             : headerValues;
         }
 
-        const httpResponse: HttpResponse<Readable> = {
+        const httpResponse = new HttpResponse({
           statusCode: res.statusCode || -1,
           headers: transformedHeaders,
           body: res
-        };
+        });
         resolve({ response: httpResponse });
       });
 

packages/protocol-http/src/httpRequest.ts

@@ -18,7 +18,7 @@ export class HttpRequest implements HttpMessage, HttpEndpoint {
   public query: QueryParameterBag;
   public headers: HeaderBag;
   public body?: any;
-  public isHttpRequest = true;
+  private readonly isHttpRequest = true;
 
   constructor(options: HttpRequestOptions) {
     this.method = options.method || "GET";
@@ -40,7 +40,9 @@ export class HttpRequest implements HttpMessage, HttpEndpoint {
   }
 
   static isInstance(request: unknown): request is HttpRequest {
-    return (request as HttpRequest).isHttpRequest;
+    return (
+      request !== undefined && (request as HttpRequest).isHttpRequest === true
+    );
   }
 
   getFormatedUrl(): string {

packages/protocol-http/src/httpResponse.ts

@@ -13,9 +13,17 @@ export class HttpResponse {
   public statusCode: number;
   public headers: HeaderBag;
   public body?: any;
+  private readonly isHttpResponse = true;
+
   constructor(options: HttpResponseOptions) {
     this.statusCode = options.statusCode;
     this.headers = options.headers || {};
     this.body = options.body;
   }
+
+  static isInstance(request: unknown): request is HttpResponse {
+    return (
+      request !== undefined && (request as HttpResponse).isHttpResponse === true
+    );
+  }
 }

packages/types/src/client.ts

@@ -9,6 +9,7 @@ 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,
@@ -80,10 +81,7 @@ export type ConfigurationDefinition<
  * A general interface for service clients' configuration interface.
  * It is idempotent among browser or node clients
  */
-export interface ClientResolvedConfigurationBase<
-  OutputTypes extends object,
-  StreamType
-> {
+export interface ClientResolvedConfigurationBase {
   credentials?: Provider<Credentials>;
   profile?: string;
   maxRedirects?: number;
@@ -98,7 +96,7 @@ export interface ClientResolvedConfigurationBase<
   utf8Decoder?: Decoder;
   utf8Incoder?: Encoder;
   // streamCollector?: StreamCollector<StreamType>;
-  serializer?: Provider<RequestSerializer<StreamType>>;
+  // serializer?: Provider<RequestSerializer<StreamType>>;
   // parser?: ResponseParser<StreamType>;
   _user_injected_http_handler?: boolean;
   httpHandler?: TransferHandler<any, any>;
@@ -111,16 +109,15 @@ export interface ClientResolvedConfigurationBase<
  */
 interface InvokeFunction<
   InputTypes extends object,
-  OutputTypes extends MetadataBearer,
-  StreamType
+  OutputTypes extends MetadataBearer
 > {
   <InputType extends InputTypes, OutputType extends OutputTypes>(
     command: Command<
       InputTypes,
       InputType,
       OutputTypes,
       OutputType,
-      ClientResolvedConfigurationBase<OutputTypes, StreamType>
+      ClientResolvedConfigurationBase
     >,
     options?: any
   ): Promise<OutputType>;
@@ -130,7 +127,7 @@ interface InvokeFunction<
       InputType,
       OutputTypes,
       OutputType,
-      ClientResolvedConfigurationBase<OutputTypes, StreamType>
+      ClientResolvedConfigurationBase
     >,
     options: any,
     cb: (err: any, data?: OutputType) => void
@@ -141,7 +138,7 @@ interface InvokeFunction<
       InputType,
       OutputTypes,
       OutputType,
-      ClientResolvedConfigurationBase<OutputTypes, StreamType>
+      ClientResolvedConfigurationBase
     >,
     options?: any,
     cb?: (err: any, data?: OutputType) => void
@@ -151,12 +148,21 @@ interface InvokeFunction<
 /**
  * A general interface for service clients, idempotent to browser or node clients
  */
-export interface AWSClient<
-  InputTypes extends object,
-  OutputTypes extends MetadataBearer,
-  StreamType
-> {
-  readonly config: ClientResolvedConfigurationBase<OutputTypes, StreamType>;
-  middlewareStack: MiddlewareStack<InputTypes, OutputTypes>;
-  send: InvokeFunction<InputTypes, OutputTypes, StreamType>;
+export interface AWSClient {
+  readonly config: ClientResolvedConfigurationBase;
+  middlewareStack: MiddlewareStack<any, any>;
+  send: InvokeFunction<any, any>;
+}
+
+export interface Injectable {
+  injectTo: (client: AWSClient) => AWSClient;
+}
+
+export interface ClientPlugin<
+  ConfigType extends object,
+  ResolvedConfig = Required<ConfigType>
+> extends Injectable {
+  clientConfig: ConfigType;
+  resolvedClientConfig: ResolvedConfig;
+  middleware: Middleware<any, any>;
 }

packages/types/src/unmarshaller.ts

@@ -15,15 +15,15 @@ import { ServiceException } from "./exception";
 //   parse<OutputType>(shape: Member, input: SerializedType): OutputType;
 // }
 
-export interface ResponseDeserializer<ResponseType> {
+export interface ResponseDeserializer<OutputType, ResponseType = 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
    */
-  <OutputType>(output: ResponseType, protocolName: string): Promise<OutputType>;
+  (output: ResponseType, protocolName: string): Promise<OutputType>;
 }
 
 /**