feat: integrate clients with endpoint.ts

Author: AllanZhengYP

clients/client-rds-data/RDSDataClient.ts

@@ -54,7 +54,8 @@ import {
   HttpHandlerOptions as __HttpHandlerOptions,
   Provider as __Provider,
   StreamCollector as __StreamCollector,
-  UrlParser as __UrlParser
+  UrlParser as __UrlParser,
+  RegionInfoProvider
 } from "@aws-sdk/types";
 
 export type ServiceInputTypes =
@@ -140,6 +141,11 @@ export interface ClientDefaults
    * Provider function that return promise of a region string
    */
   regionDefaultProvider?: (input: any) => __Provider<string>;
+
+  /**
+   * Fetch hostname, signing name or signing region of given region
+   */
+  regionInfoProvider?: RegionInfoProvider;
 }
 
 export type RDSDataClientConfig = Partial<
@@ -184,7 +190,6 @@ export class RDSDataClient extends __Client<
 
   constructor(configuration: RDSDataClientConfig) {
     let _config_0 = {
-      service: "rds-data", //TODO: remove this
       ...__ClientDefaultValues,
       ...configuration
     };

clients/client-rds-data/endpoints.ts

@@ -0,0 +1,72 @@
+import { RegionInfoProvider } from "@aws-sdk/types";
+
+// Partition default templates
+const AWS_TEMPLATE = "rds-data.{region}.amazonaws.com";
+const AWS_CN_TEMPLATE = "rds-data.{region}.amazonaws.com.cn";
+const AWS_ISO_TEMPLATE = "rds-data.{region}.c2s.ic.gov";
+const AWS_ISO_B_TEMPLATE = "rds-data.{region}.sc2s.sgov.gov";
+const AWS_US_GOV_TEMPLATE = "rds-data.{region}.amazonaws.com";
+
+// Partition regions
+const AWS_REGIONS = new Set([
+  "ap-south-1",
+  "eu-north-1",
+  "eu-west-3",
+  "eu-west-2",
+  "eu-west-1",
+  "ap-northeast-2",
+  "ap-northeast-1",
+  "me-south-1",
+  "ca-central-1",
+  "sa-east-1",
+  "ap-east-1",
+  "ap-southeast-1",
+  "ap-southeast-2",
+  "eu-central-1",
+  "us-east-1",
+  "us-east-2",
+  "us-west-1",
+  "us-west-2"
+]);
+const AWS_CN_REGIONS = new Set(["cn-north-1", "cn-northwest-1"]);
+const AWS_ISO_REGIONS = new Set(["us-iso-east-1"]);
+const AWS_ISO_B_REGIONS = new Set(["us-isob-east-1"]);
+const AWS_US_GOV_REGIONS = new Set(["us-gov-west-1", "us-gov-east-1"]);
+
+export let defaultRegionInfoProvider: RegionInfoProvider;
+defaultRegionInfoProvider = function(region: string, options?: any) {
+  switch (region) {
+    // First, try to match exact region names.
+    // Next, try to match partition endpoints.
+    default:
+      if (region in AWS_REGIONS) {
+        return {
+          hostname: AWS_TEMPLATE.replace("{region}", region)
+        };
+      }
+      if (region in AWS_CN_REGIONS) {
+        return {
+          hostname: AWS_CN_TEMPLATE.replace("{region}", region)
+        };
+      }
+      if (region in AWS_ISO_REGIONS) {
+        return {
+          hostname: AWS_ISO_TEMPLATE.replace("{region}", region)
+        };
+      }
+      if (region in AWS_ISO_B_REGIONS) {
+        return {
+          hostname: AWS_ISO_B_TEMPLATE.replace("{region}", region)
+        };
+      }
+      if (region in AWS_US_GOV_REGIONS) {
+        return {
+          hostname: AWS_US_GOV_TEMPLATE.replace("{region}", region)
+        };
+      }
+      // Finally, assume it's an AWS partition endpoint.
+      return {
+        hostname: AWS_TEMPLATE.replace("{region}", region)
+      };
+  }
+};

clients/client-rds-data/runtimeConfig.shared.ts

@@ -1,4 +1,6 @@
+import { defaultRegionInfoProvider } from "./endpoints";
 export const ClientSharedValues = {
   apiVersion: "2018-08-01",
   signingName: "rds-data",
+  regionInfoProvider: defaultRegionInfoProvider
 };

codegen/smithy-aws-typescript-codegen/src/main/java/software/amazon/smithy/aws/typescript/codegen/AddBuiltinPlugins.java

@@ -58,10 +58,10 @@ public List<RuntimeClientPlugin> getClientPlugins() {
                         .withConventions(TypeScriptDependency.CONFIG_RESOLVER.dependency, "Region", HAS_CONFIG)
                         .build(),
                 RuntimeClientPlugin.builder()
-                        .withConventions(AwsDependency.MIDDLEWARE_SIGNING.dependency, "AwsAuth")
+                        .withConventions(TypeScriptDependency.CONFIG_RESOLVER.dependency, "Endpoints", HAS_CONFIG)
                         .build(),
                 RuntimeClientPlugin.builder()
-                        .withConventions(TypeScriptDependency.CONFIG_RESOLVER.dependency, "Endpoints", HAS_CONFIG)
+                        .withConventions(AwsDependency.MIDDLEWARE_SIGNING.dependency, "AwsAuth")
                         .build(),
                 RuntimeClientPlugin.builder()
                         .withConventions(TypeScriptDependency.MIDDLEWARE_RETRY.dependency, "Retry")

codegen/smithy-aws-typescript-codegen/src/main/java/software/amazon/smithy/aws/typescript/codegen/EndpointGenerator.java

@@ -129,10 +129,11 @@ private void writePartitionRegions() {
     }
 
     private void writeEndpointProviderFunction() {
-        writer.write("export let defaultEndpointProvider: EndpointProvider;");
-        writer.openBlock("defaultEndpointProvider = function(\n"
+        writer.addImport("RegionInfoProvider", "RegionInfoProvider", "@aws-sdk/types");
+        writer.write("export const defaultRegionInfoProvider: RegionInfoProvider;");
+        writer.openBlock("defaultRegionInfoProvider = function(\n"
                          + "  region: string,\n"
-                         + "  options?: EndpointOptions\n"
+                         + "  options?: any\n"
                          + ") {", "}", () -> {
             writer.openBlock("switch (region) {", "}", () -> {
                 writer.write("// First, try to match exact region names.");

packages/config-resolver/src/EndpointsConfig.ts

@@ -1,4 +1,10 @@
-import { Provider, UrlParser, Endpoint } from "@aws-sdk/types";
+import {
+  Provider,
+  UrlParser,
+  Endpoint,
+  RegionInfoProvider,
+  RegionInfo
+} from "@aws-sdk/types";
 
 export function normalizeEndpoint(
   endpoint?: string | Endpoint | Provider<Endpoint>,
@@ -20,20 +26,15 @@ export interface EndpointsInputConfig {
    */
   endpoint?: string | Endpoint | Provider<Endpoint>;
 
-  /**
-   * The endpoint provider to call if no endpoint is provided
-   */
-  endpointProvider?: any;
-
   /**
    * Whether TLS is enabled for requests.
    */
   tls?: boolean;
 }
 interface PreviouslyResolved {
+  regionInfoProvider: RegionInfoProvider;
   urlParser: UrlParser;
   region: Provider<string>;
-  service: string;
 }
 export interface EndpointsResolvedConfig
   extends Required<EndpointsInputConfig> {
@@ -43,18 +44,21 @@ export function resolveEndpointsConfig<T>(
   input: T & EndpointsInputConfig & PreviouslyResolved
 ): T & EndpointsResolvedConfig {
   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;
   const endpoint: Provider<Endpoint> = input.endpoint
     ? normalizeEndpoint(input.endpoint, input.urlParser)
-    : () => input.region().then(region => endpointProvider(tls, region));
+    : () =>
+        input.region().then(region => {
+          const hostname = (
+            input.regionInfoProvider(region) || ({} as RegionInfo)
+          ).hostname;
+          if (!hostname)
+            throw new Error("Cannot resolve hostname from client config");
+          const endpoint = input.urlParser(hostname);
+          endpoint.protocol = tls ? "https:" : "http:";
+          return endpoint;
+        });
   return {
     ...input,
-    endpointProvider,
     endpoint,
     tls
   };

packages/middleware-signing/src/configurations.ts

@@ -2,7 +2,9 @@ import {
   RequestSigner,
   Credentials,
   Provider,
-  HashConstructor
+  HashConstructor,
+  RegionInfoProvider,
+  RegionInfo
 } from "@aws-sdk/types";
 import { SignatureV4 } from "@aws-sdk/signature-v4";
 
@@ -15,7 +17,7 @@ export interface AwsAuthInputConfig {
   /**
    * The signer to use when signing requests.
    */
-  signer?: RequestSigner;
+  signer?: RequestSigner | Provider<RequestSigner>;
 
   /**
    * Whether to escape request path when signing the request.
@@ -26,16 +28,23 @@ export interface AwsAuthInputConfig {
    * An offset value in milliseconds to apply to all signing times.
    */
   systemClockOffset?: number;
+
+  /**
+   * The region where you want to sign your request against. This
+   * can be different to the region in the endpoint.
+   */
+  signingRegion?: string;
 }
 interface PreviouslyResolved {
   credentialDefaultProvider: (input: any) => Provider<Credentials>;
   region: string | Provider<string>;
+  regionInfoProvider: RegionInfoProvider;
   signingName: string;
   sha256: HashConstructor;
 }
 export interface AwsAuthResolvedConfig {
   credentials: Provider<Credentials>;
-  signer: RequestSigner;
+  signer: Provider<RequestSigner>;
   signingEscapePath: boolean;
   systemClockOffset: number;
 }
@@ -45,20 +54,49 @@ export function resolveAwsAuthConfig<T>(
   let credentials =
     input.credentials || input.credentialDefaultProvider(input as any);
   const normalizedCreds = normalizeProvider(credentials);
-  const signingEscapePath = input.signingEscapePath || false;
-  const systemClockOffset = input.systemClockOffset || 0;
+  const {
+    signingEscapePath = false,
+    systemClockOffset = input.systemClockOffset || 0,
+    sha256
+  } = input;
+  let signer: Provider<RequestSigner>;
+  if (input.signer) signer = normalizeProvider(input.signer);
+  else {
+    signer = () =>
+      normalizeProvider(input.region)()
+        .then(
+          region =>
+            [input.regionInfoProvider(region) || {}, region] as [
+              RegionInfo,
+              string
+            ]
+        )
+        .then(([regionInfo, region]) => {
+          const {
+            signingRegion = input.signingRegion,
+            signingService = input.signingName
+          } = regionInfo;
+          //update client's resolved config if it's resolved
+          //resolution: user supplied signingRegion -> endpoints.js inferred region -> client region
+          input.signingRegion = input.signingRegion || signingRegion || region;
+          input.signingName = input.signingName || signingService;
+
+          return new SignatureV4({
+            credentials: normalizedCreds,
+            region: input.signingRegion,
+            service: input.signingName,
+            sha256,
+            uriEscapePath: signingEscapePath
+          });
+        });
+  }
+
   return {
     ...input,
     systemClockOffset,
     signingEscapePath,
     credentials: normalizedCreds,
-    signer: new SignatureV4({
-      credentials: normalizedCreds,
-      region: input.region,
-      service: input.signingName,
-      sha256: input.sha256,
-      uriEscapePath: signingEscapePath
-    })
+    signer
   };
 }
 

packages/middleware-signing/src/middleware.ts

@@ -27,9 +27,13 @@ export function awsAuthMiddleware<Input extends object, Output extends object>(
       args: FinalizeHandlerArguments<Input>
     ): Promise<FinalizeHandlerOutput<Output>> {
       if (!HttpRequest.isInstance(args.request)) return next(args);
+      const signer =
+        typeof options.signer === "function"
+          ? await options.signer()
+          : options.signer;
       const output = await next({
         ...args,
-        request: await options.signer.sign(args.request, {
+        request: await signer.sign(args.request, {
           signingDate: new Date(Date.now() + options.systemClockOffset)
         })
       });

packages/types/src/util.ts

@@ -82,3 +82,24 @@ export interface RetryStrategy {
 export interface UrlParser {
   (url: string): Endpoint;
 }
+
+/**
+ * Object containing regionalization information of
+ * AWS services.
+ */
+export interface RegionInfo {
+  hostname: string;
+  path?: string;
+  signingService?: string;
+  signingRegion?: string;
+}
+
+/**
+ * Function returns designated service's regionalization
+ * information from given region. Each service client
+ * comes with its regionalization provider. it serves
+ * to provide the default values of related configurations
+ */
+export interface RegionInfoProvider {
+  (region: string, options?: any): RegionInfo | undefined;
+}