Smithy codegen Client Refactor (#384)

* feat: remove 'apply' entry from configuration definition

'apply' was used to adjust middleware stack and resolved configuration.
It is not relative as we are moving to conposition configuration, and
middleware stack should not be altered by configurations.
Address: aws/aws-sdk-js-v3#94

* feat: complete PoC composable configuration

* feat: change config resolver to multiple client config components

* feat: rename stack finalize step to finalizeRequest

* feat: add use() to smithy client to inject middleware

* fix: rename resolvedruntime configuration

* fix: remove exported reviouslyResolved interface

* feat: add metadatabearer to shapes

* feat: parse derializing utils as parameters

* use config interface as middleware parameter
* use smithy command as super class of all commands so we can support use() in commands

* 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

* feat: add metadata deserializer

* docs: add documentation for config properties

* feat: add defaultUserAgen config

* feat: move some config components to middleware folder

* signing middleware
* retry middleware; Also update retry config interface by introducing RetryStrategy class

* feat: add input type proxy for better intellisense

* docs: add config doc block for retry config

* feat: add a user agent middleware to support custom useragent

Author: AllanZhengYP

packages/config-resolver/package.json

@@ -21,6 +21,8 @@
   },
   "dependencies": {
     "@aws-sdk/types": "^0.1.0-preview.7",
+    "@aws-sdk/signature-v4": "^0.1.0-preview.7",
+    "@aws-sdk/protocol-http": "^0.1.0-preview.1",
     "tslib": "^1.8.0"
   }
 }

packages/config-resolver/src/components.ts

@@ -0,0 +1,222 @@
+import {
+  Credentials,
+  Provider,
+  HashConstructor,
+  UrlParser,
+  Protocol,
+  HttpOptions,
+  StreamCollector,
+  Decoder,
+  Encoder
+} from "@aws-sdk/types";
+import {
+  HttpEndpoint,
+  HttpHandler,
+  HttpRequest,
+  HttpResponse
+} from "@aws-sdk/protocol-http";
+
+export interface RuntimeDependencies {
+  /**
+   * The HTTP handler to use. Fetch in browser and Https in Nodejs
+   */
+  httpHandler?: HttpHandler;
+
+  /**
+   * A constructor for a class implementing the @aws-sdk/types.Hash interface that computes the SHA-256 HMAC or checksum of a string or binary buffer
+   */
+  sha256?: HashConstructor;
+
+  /**
+   * Default credentials provider; Not available in browser runtime
+   */
+  credentialDefaultProvider?: (input: any) => Provider<Credentials>;
+
+  /**
+   * Provider function that return promise of a region string
+   */
+  regionDefaultProvider?: (input: any) => Provider<string>;
+
+  /**
+   * The function that will be used to convert strings into HTTP endpoints
+   */
+  urlParser?: UrlParser;
+
+  /**
+   * A function that can calculate the length of a request body.
+   */
+  bodyLengthChecker?: (body: any) => number | undefined;
+
+  /**
+   * A function that converts a stream into an array of bytes.
+   */
+  streamCollector?: StreamCollector;
+
+  /**
+   * The function that will be used to convert a base64-encoded string to a byte array
+   */
+  base64Decoder?: Decoder;
+
+  /**
+   * The function that will be used to convert binary data to a base64-encoded string
+   */
+  base64Encoder?: Encoder;
+
+  /**
+   * The function that will be used to convert a UTF8-encoded string to a byte array
+   */
+  utf8Decoder?: Decoder;
+
+  /**
+   * The function that will be used to convert binary data to a UTF-8 encoded string
+   */
+  utf8Encoder?: Encoder;
+
+  /**
+   * The function that will be used to populate default value in 'User-Agent' header
+   */
+  defaultUserAgent?: string;
+}
+
+export interface AWSClientRuntimeConfiguration extends RuntimeDependencies {
+  /**
+   * The function that will be used to populate serializing protocol
+   */
+  protocolDefaultProvider?: (
+    handler: HttpHandler
+  ) => Protocol<HttpRequest, HttpResponse>;
+
+  /**
+   * The service name with which to sign requests.
+   */
+  signingName?: string;
+
+  /**
+   * The service name with which to construct endpoints.
+   */
+  service?: string;
+}
+
+export function normalizeProvider<T>(input: T | Provider<T>): Provider<T> {
+  if (typeof input === "object") {
+    const promisified = Promise.resolve(input);
+    return () => promisified;
+  }
+  return input as Provider<T>;
+}
+
+export function normalizeEndpoint(
+  endpoint?: string | HttpEndpoint | Provider<HttpEndpoint>,
+  urlParser?: UrlParser
+): Provider<HttpEndpoint> {
+  if (typeof endpoint === "string") {
+    const promisified = Promise.resolve(urlParser!(endpoint));
+    return () => promisified;
+  } else if (typeof endpoint === "object") {
+    const promisified = Promise.resolve(endpoint);
+    return () => promisified;
+  }
+  return endpoint!;
+}
+
+export namespace RegionConfiguration {
+  export interface Input {
+    /**
+     * The AWS region to which this client will send requests
+     */
+    region?: string | Provider<string>;
+  }
+  interface PreviouslyResolved {
+    regionDefaultProvider: (input: any) => Provider<string>;
+  }
+  export interface Resolved {
+    region: Provider<string>;
+  }
+  export function resolve<T>(
+    input: T & Input & PreviouslyResolved
+  ): T & Resolved {
+    let region = input.region || input.regionDefaultProvider(input as any);
+    return {
+      ...input,
+      region: normalizeProvider(region)
+    };
+  }
+}
+//export separately for showing comment block in Intellisense
+export type RegionConfigurationInput = RegionConfiguration.Input;
+
+export namespace EndpointsConfig {
+  export interface Input {
+    /**
+     * The fully qualified endpoint of the webservice. This is only required when using a custom endpoint (for example, when using a local version of S3).
+     */
+    endpoint?: string | HttpEndpoint | Provider<HttpEndpoint>;
+
+    /**
+     * The endpoint provider to call if no endpoint is provided
+     */
+    endpointProvider?: any;
+
+    /**
+     * Whether TLS is enabled for requests.
+     */
+    tls?: boolean;
+  }
+  interface PreviouslyResolved {
+    urlParser: UrlParser;
+    region: Provider<string>;
+    service: string;
+  }
+  export interface Resolved extends Required<Input> {
+    endpoint: Provider<HttpEndpoint>;
+  }
+  export function resolve<T>(
+    input: T & Input & PreviouslyResolved
+  ): T & Resolved {
+    const tls = input.tls || true;
+    const defaultProvider = (tls: boolean, region: string) => ({
+      protocol: tls ? "https:" : "http:",
+      path: "/",
+      hostname: `${input.service}.${region}.amazonaws.com`
+    });
+    const endpointProvider = input.endpointProvider || defaultProvider;
+    let endpoint: Provider<HttpEndpoint> = input.endpoint
+      ? normalizeEndpoint(input.endpoint, input.urlParser)
+      : () => input.region().then(region => endpointProvider(tls, region));
+    return {
+      ...input,
+      endpointProvider,
+      endpoint,
+      tls
+    };
+  }
+}
+//export separately for showing comment block in Intellisense
+export type EndpointsConfigInput = EndpointsConfig.Input;
+
+export namespace ProtocolConfig {
+  export interface Input {
+    /**
+     * The serializing protocol to used in request
+     */
+    protocol?: Protocol<any, any>;
+  }
+  interface PreviouslyResolved {
+    httpHandler: HttpHandler;
+    protocolDefaultProvider: (
+      handler: HttpHandler
+    ) => Protocol<HttpRequest, HttpResponse, HttpOptions>;
+  }
+  export type Resolved = Required<Input>;
+  export function resolve<T>(
+    input: T & Input & PreviouslyResolved
+  ): T & Resolved {
+    return {
+      ...input,
+      protocol:
+        input.protocol || input.protocolDefaultProvider(input.httpHandler)
+    };
+  }
+}
+//export separately for showing comment block in Intellisense
+export type ProtocolConfigInput = ProtocolConfig.Input;