feat: move client.use() to client.middlewarestack.use()

Author: AllanZhengYP

clients/node/client-rds-data-node/RDSDataClient.ts

@@ -0,0 +1,57 @@
+import { contentLengthPlugin } from "@aws-sdk/middleware-content-length";
+import {
+  userAgentPlugin,
+  UserAgentConfig
+} from "@aws-sdk/middleware-user-agent";
+import { retryPlugin, RetryConfig } from "@aws-sdk/retry-middleware";
+import {
+  awsAuthPlugin,
+  AwsAuthConfiguration
+} from "@aws-sdk/signing-middleware";
+import {
+  RDSDataConfiguration,
+  RDSDataResolvedConfiguration
+} from "./RDSDataConfiguration";
+import { RDSRuntimeConfiguration } from "./runtimeConfig";
+import {
+  RegionConfiguration,
+  EndpointsConfig,
+  ProtocolConfig
+} from "@aws-sdk/config-resolver";
+import { HttpOptions, MetadataBearer } from "@aws-sdk/types";
+import { Client as SmithyClient } from "@aws-sdk/smithy-client";
+
+type InputTypesUnion = any;
+type OutputTypesUnion = MetadataBearer;
+
+export class RDSDataClient extends SmithyClient<
+  HttpOptions,
+  InputTypesUnion,
+  OutputTypesUnion
+> {
+  readonly config: RDSDataResolvedConfiguration;
+
+  constructor(configuration: RDSDataConfiguration) {
+    const intermediaConfig_0 = ProtocolConfig.resolve({
+      ...RDSRuntimeConfiguration,
+      ...configuration
+    });
+    let intermediaConfig_1 = RegionConfiguration.resolve(intermediaConfig_0);
+    let intermediaConfig_2 = AwsAuthConfiguration.resolve(intermediaConfig_1);
+    let intermediaConfig_3 = EndpointsConfig.resolve(intermediaConfig_2);
+    let intermediaConfig_4 = RetryConfig.resolve(intermediaConfig_3);
+    let intermediaConfig_5 = UserAgentConfig.resolve(intermediaConfig_4);
+    super(intermediaConfig_0);
+    this.config = intermediaConfig_5;
+    this.middlewareStack.use(contentLengthPlugin(this.config));
+    this.middlewareStack.use(retryPlugin(this.config));
+    this.middlewareStack.use(awsAuthPlugin(this.config));
+    this.middlewareStack.use(userAgentPlugin(this.config));
+  }
+
+  destroy(): void {
+    if (typeof this.config.httpHandler.destroy === "function") {
+      this.config.httpHandler.destroy();
+    }
+  }
+}

clients/node/client-rds-data-node/commands/ExecuteStatementCommand.ts

@@ -36,7 +36,9 @@ export class ExecuteStatementCommand extends Command<
       protocol: { handler }
     } = configuration;
 
-    this.use(serdePlugin(configuration, this.serialize, this.deserialize));
+    this.middlewareStack.use(
+      serdePlugin(configuration, this.serialize, this.deserialize)
+    );
 
     const stack = clientStack.concat(this.middlewareStack);
 

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

@@ -44,13 +44,13 @@ export function contentLengthMiddleware(
   };
 }
 
-export namespace ContentLength {
-  export const setMiddleware = (options: {
-    bodyLengthChecker: BodyLengthCalculator;
-  }): Pluggable<any, any> => clientStack => {
+export const getContentLengthPlugin = (options: {
+  bodyLengthChecker: BodyLengthCalculator;
+}): Pluggable<any, any> => ({
+  applyToStack: clientStack => {
     clientStack.add(contentLengthMiddleware(options.bodyLengthChecker), {
       step: "build",
       tags: { SET_CONTENT_LENGTH: true }
     });
-  };
-}
+  }
+});

packages/middleware-serde/src/serdePlugin.ts

@@ -21,14 +21,16 @@ export function serdePlugin<
   serializer: RequestSerializer<any, SerializerRuntimeUtils>,
   deserializer: ResponseDeserializer<OutputType, any, DeserializerRuntimeUtils>
 ): Pluggable<InputType, OutputType> {
-  return (commandStack: MiddlewareStack<InputType, OutputType>) => {
-    commandStack.add(deserializerMiddleware(config, deserializer), {
-      step: "deserialize",
-      tags: { DESERIALIZER: true }
-    });
-    commandStack.add(serializerMiddleware(config, serializer), {
-      step: "serialize",
-      tags: { SERIALIZER: true }
-    });
+  return {
+    applyToStack: (commandStack: MiddlewareStack<InputType, OutputType>) => {
+      commandStack.add(deserializerMiddleware(config, deserializer), {
+        step: "deserialize",
+        tags: { DESERIALIZER: true }
+      });
+      commandStack.add(serializerMiddleware(config, serializer), {
+        step: "serialize",
+        tags: { SERIALIZER: true }
+      });
+    }
   };
 }

packages/middleware-signing/src/configurations.ts

@@ -2,74 +2,58 @@ import {
   RequestSigner,
   Credentials,
   Provider,
-  HashConstructor,
-  Pluggable
+  HashConstructor
 } from "@aws-sdk/types";
 import { SignatureV4 } from "@aws-sdk/signature-v4";
-import { signingMiddleware } from "./middleware";
 
-export namespace AwsAuth {
-  export interface Input {
-    /**
-     * The credentials used to sign requests.
-     */
-    credentials?: Credentials | Provider<Credentials>;
+export interface AwsAuthConfigInput {
+  /**
+   * The credentials used to sign requests.
+   */
+  credentials?: Credentials | Provider<Credentials>;
 
-    /**
-     * The signer to use when signing requests.
-     */
-    signer?: RequestSigner;
+  /**
+   * The signer to use when signing requests.
+   */
+  signer?: RequestSigner;
 
-    /**
-     * Whether to escape request path when signing the request
-     */
-    signingEscapePath?: boolean;
-  }
-  interface PreviouslyResolved {
-    credentialDefaultProvider: (input: any) => Provider<Credentials>;
-    region: string | Provider<string>;
-    signingName: string;
-    sha256: HashConstructor;
-  }
-  export interface Resolved {
-    credentials: Provider<Credentials>;
-    signer: RequestSigner;
-    signingEscapePath: boolean;
-  }
-  export function resolveConfig<T>(
-    input: T & Input & PreviouslyResolved
-  ): T & Resolved {
-    let credentials =
-      input.credentials || input.credentialDefaultProvider(input as any);
-    const normalizedCreds = normalizeProvider(credentials);
-    const signingEscapePath = input.signingEscapePath || false;
-    return {
-      ...input,
-      signingEscapePath,
+  /**
+   * Whether to escape request path when signing the request
+   */
+  signingEscapePath?: boolean;
+}
+interface PreviouslyResolved {
+  credentialDefaultProvider: (input: any) => Provider<Credentials>;
+  region: string | Provider<string>;
+  signingName: string;
+  sha256: HashConstructor;
+}
+export interface AwsAuthConfigResolved {
+  credentials: Provider<Credentials>;
+  signer: RequestSigner;
+  signingEscapePath: boolean;
+}
+export function resolveAwsAuthConfig<T>(
+  input: T & AwsAuthConfigInput & PreviouslyResolved
+): T & AwsAuthConfigResolved {
+  let credentials =
+    input.credentials || input.credentialDefaultProvider(input as any);
+  const normalizedCreds = normalizeProvider(credentials);
+  const signingEscapePath = input.signingEscapePath || false;
+  return {
+    ...input,
+    signingEscapePath,
+    credentials: normalizedCreds,
+    signer: new SignatureV4({
       credentials: normalizedCreds,
-      signer: new SignatureV4({
-        credentials: normalizedCreds,
-        region: input.region,
-        service: input.signingName,
-        sha256: input.sha256,
-        uriEscapePath: signingEscapePath
-      })
-    };
-  }
-
-  export const setMiddleware = (
-    options: AwsAuth.Resolved
-  ): Pluggable<any, any> => clientStack => {
-    clientStack.add(signingMiddleware(options), {
-      step: "finalizeRequest",
-      tags: { SIGNATURE: true }
-    });
+      region: input.region,
+      service: input.signingName,
+      sha256: input.sha256,
+      uriEscapePath: signingEscapePath
+    })
   };
 }
 
-//export separately for showing comment block in Intellisense
-export type AwsAuthInput = AwsAuth.Input;
-
 function normalizeProvider<T>(input: T | Provider<T>): Provider<T> {
   if (typeof input === "object") {
     const promisified = Promise.resolve(input);

packages/middleware-signing/src/middleware.ts

@@ -4,11 +4,11 @@ import {
   FinalizeRequestMiddleware,
   FinalizeHandlerOutput
 } from "@aws-sdk/types";
-import { AwsAuth } from "./configurations";
+import { AwsAuthConfigResolved } from "./configurations";
 import { HttpRequest } from "@aws-sdk/protocol-http";
 
 export function signingMiddleware<Input extends object, Output extends object>(
-  options: AwsAuth.Resolved
+  options: AwsAuthConfigResolved
 ): FinalizeRequestMiddleware<Input, Output> {
   return (
     next: FinalizeHandler<Input, Output>
@@ -23,3 +23,14 @@ export function signingMiddleware<Input extends object, Output extends object>(
       });
     };
 }
+
+export const getAwsAuthPlugin = (
+  options: AwsAuthConfigResolved
+): Pluggable<any, any> => ({
+  applyToStack: clientStack => {
+    clientStack.add(signingMiddleware(options), {
+      step: "finalizeRequest",
+      tags: { SIGNATURE: true }
+    });
+  }
+});

packages/middleware-stack/src/index.ts

@@ -1,10 +1,8 @@
 import {
   BuildHandlerOptions,
-  FinalizeHandler,
   FinalizeRequestHandlerOptions,
   SerializeMiddleware,
   FinalizeRequestMiddleware,
-  BuildMiddleware,
   Handler,
   HandlerExecutionContext,
   HandlerOptions,
@@ -14,7 +12,8 @@ import {
   Step,
   DeserializeMiddleware,
   DeserializeHandlerOptions,
-  DeserializeHandler
+  DeserializeHandler,
+  Pluggable
 } from "@aws-sdk/types";
 
 interface HandlerListEntry<Input extends object, Output extends object> {
@@ -70,6 +69,10 @@ export class MiddlewareStack<Input extends object, Output extends object> {
     });
   }
 
+  use(pluggable: Pluggable<Input, Output>) {
+    pluggable.applyToStack(this);
+  }
+
   clone(): IMiddlewareStack<Input, Output> {
     const clone = new MiddlewareStack<Input, Output>();
     clone.entries.push(...this.entries);

packages/middleware-user-agent/src/configurations.ts

@@ -1,34 +1,18 @@
-import { Pluggable } from "@aws-sdk/types";
-import { userAgentMiddleware } from "./middleware";
-
-export namespace UserAgent {
-  export interface Input {
-    /**
-     * The custom user agent header that would be appended to default one
-     */
-    customUserAgent?: string;
-  }
-  export interface PreviouslyResolved {
-    defaultUserAgent: string;
-  }
-  export interface Resolved {
-    defaultUserAgent: string;
-    customUserAgent?: string;
-  }
-  export function resolveConfig<T>(
-    input: T & PreviouslyResolved & Input
-  ): T & Resolved {
-    return input;
-  }
-
-  export const setMiddleware = (
-    config: UserAgent.Resolved
-  ): Pluggable<any, any> => clientStack => {
-    clientStack.add(userAgentMiddleware(config), {
-      step: "build",
-      tags: { SET_USER_AGENT: true }
-    });
-  };
+export interface UserAgentConfigInput {
+  /**
+   * The custom user agent header that would be appended to default one
+   */
+  customUserAgent?: string;
+}
+interface PreviouslyResolved {
+  defaultUserAgent: string;
+}
+export interface UserAgentConfigResolved {
+  defaultUserAgent: string;
+  customUserAgent?: string;
+}
+export function resolveConfig<T>(
+  input: T & PreviouslyResolved & UserAgentConfigInput
+): T & UserAgentConfigResolved {
+  return input;
 }
-
-export type UserAgentInput = UserAgent.Input;

packages/middleware-user-agent/src/middleware.ts

@@ -6,11 +6,11 @@ import {
   Pluggable
 } from "@aws-sdk/types";
 import { HttpRequest } from "@aws-sdk/protocol-http";
-import { UserAgent } from "./configurations";
+import { UserAgentConfigResolved } from "./configurations";
 
 const userAgentHeader = "User-Agent";
 
-export function userAgentMiddleware(options: UserAgent.Resolved) {
+export function userAgentMiddleware(options: UserAgentConfigResolved) {
   return <Output extends MetadataBearer>(
     next: BuildHandler<any, any>
   ): BuildHandler<any, any> => (
@@ -33,3 +33,14 @@ export function userAgentMiddleware(options: UserAgent.Resolved) {
     });
   };
 }
+
+export const userAgentPlugin = (
+  config: UserAgentConfigResolved
+): Pluggable<any, any> => ({
+  applyToStack: clientStack => {
+    clientStack.add(userAgentMiddleware(config), {
+      step: "build",
+      tags: { SET_USER_AGENT: true }
+    });
+  }
+});