fix(codegen): add default aws regional endpoint provider

Author: kuhe

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

@@ -5,6 +5,7 @@
 
 package software.amazon.smithy.aws.typescript.codegen;
 
+import java.util.Collections;
 import java.util.List;
 import software.amazon.smithy.aws.traits.ServiceTrait;
 import software.amazon.smithy.model.Model;
@@ -13,13 +14,18 @@
 import software.amazon.smithy.rulesengine.traits.EndpointRuleSetTrait;
 import software.amazon.smithy.typescript.codegen.TypeScriptSettings;
 import software.amazon.smithy.typescript.codegen.endpointsV2.AddDefaultEndpointRuleSet;
+import software.amazon.smithy.typescript.codegen.integration.RuntimeClientPlugin;
 import software.amazon.smithy.typescript.codegen.integration.TypeScriptIntegration;
 
+import static software.amazon.smithy.typescript.codegen.integration.RuntimeClientPlugin.Convention.HAS_CONFIG;
+
 
 /**
  * This replaces behavior from {@link EndpointGenerator}.
  */
 public class AddDefaultAwsEndpointRuleSet implements TypeScriptIntegration {
+    private boolean usesDefaultAwsRegionalEndpoints = false;
+
     /**
      * Running before the smithy-typescript default endpoint integration
      * will prevent it from applying its non-AWS default ruleset and
@@ -31,6 +37,27 @@ public List<String> runBefore() {
         return List.of(AddDefaultEndpointRuleSet.class.getCanonicalName());
     }
 
+    @Override
+    public List<RuntimeClientPlugin> getClientPlugins() {
+        if (usesDefaultAwsRegionalEndpoints) {
+            /*
+            This resolver supports the behavior of endpoints.json-based endpoint provider
+            for default regional services: it makes client.config.endpoint optional on the input side,
+            but guaranteed on the resolved side.
+             */
+            return List.of(
+                RuntimeClientPlugin.builder()
+                    .withConventions(
+                        AwsDependency.UTIL_ENDPOINTS.dependency,
+                        "DefaultAwsRegionalEndpoints",
+                        HAS_CONFIG
+                    )
+                    .build()
+            );
+        }
+        return Collections.emptyList();
+    }
+
     @Override
     public Model preprocessModel(Model model, TypeScriptSettings settings) {
         Model.Builder modelBuilder = model.toBuilder();
@@ -40,7 +67,7 @@ public Model preprocessModel(Model model, TypeScriptSettings settings) {
             && AwsTraitsUtils.isAwsService(serviceShape)) {
             // this branch is for models that identify as AWS services
             // but do not include an endpoint ruleset.
-
+            usesDefaultAwsRegionalEndpoints = true;
             modelBuilder.removeShape(serviceShape.toShapeId());
             modelBuilder.addShape(
                 serviceShape.toBuilder()
@@ -49,6 +76,8 @@ public Model preprocessModel(Model model, TypeScriptSettings settings) {
                     ))
                     .build()
             );
+        } else {
+            usesDefaultAwsRegionalEndpoints = false;
         }
 
         return modelBuilder.build();

packages/util-endpoints/package.json

@@ -26,6 +26,7 @@
   "dependencies": {
     "@aws-sdk/types": "*",
     "@smithy/types": "^4.3.1",
+    "@smithy/url-parser": "^4.0.4",
     "@smithy/util-endpoints": "^3.0.6",
     "tslib": "^2.6.2"
   },

packages/util-endpoints/src/resolveDefaultAwsRegionalEndpointsConfig.ts

@@ -0,0 +1,90 @@
+import type { Endpoint, EndpointParameters, EndpointV2, Logger, Provider } from "@smithy/types";
+import { parseUrl } from "@smithy/url-parser";
+
+/**
+ * This is an additional config resolver layer for clients using the default
+ * AWS regional endpoints ruleset. It makes the *resolved* config guarantee the presence of an
+ * endpoint provider function. This differs from the base behavior of the Endpoint
+ * config resolver, which only normalizes config.endpoint IFF one is provided by the caller.
+ *
+ * This is not used by AWS SDK clients, but rather
+ * generated clients that have the aws.api#service trait. This includes protocol tests
+ * and other customers.
+ *
+ * This resolver is MUTUALLY EXCLUSIVE with the EndpointRequired config resolver from
+ * |@smithy/middleware-endpoint.
+ *
+ * It must be placed after the `resolveEndpointConfig`
+ * resolver. This replaces the endpoints.json-based default endpoint provider.
+ *
+ * @public
+ */
+export type DefaultAwsRegionalEndpointsInputConfig = {
+  endpoint?: unknown;
+  endpointProvider: (
+    endpointParams: EndpointParameters | DefaultRegionalEndpointParameters,
+    context?: { logger?: Logger }
+  ) => EndpointV2;
+};
+
+type PreviouslyResolved = {
+  logger?: Logger;
+  region?: undefined | string | Provider<string | undefined>;
+  useFipsEndpoint?: undefined | boolean | Provider<string | boolean>;
+  useDualstackEndpoint?: undefined | boolean | Provider<string | boolean>;
+};
+
+/**
+ * @internal
+ */
+type DefaultRegionalEndpointParameters = {
+  Region?: string | undefined;
+  UseDualStack?: boolean | undefined;
+  UseFIPS?: boolean | undefined;
+};
+
+/**
+ * @internal
+ */
+export interface DefaultAwsRegionalEndpointsResolvedConfig {
+  endpoint: Provider<Endpoint>;
+}
+
+/**
+ * MUST resolve after `\@smithy/middleware-endpoint`::`resolveEndpointConfig`.
+ *
+ * @internal
+ */
+export const resolveDefaultAwsRegionalEndpointsConfig = <T>(
+  input: T & DefaultAwsRegionalEndpointsInputConfig & PreviouslyResolved
+): T & DefaultAwsRegionalEndpointsResolvedConfig => {
+  if (typeof input.endpointProvider !== "function") {
+    throw new Error("@aws-sdk/util-endpoint - endpointProvider and endpoint missing in config for this client.");
+  }
+
+  const { endpoint } = input;
+  if (endpoint === undefined) {
+    input.endpoint = async () => {
+      return toEndpointV1(
+        input.endpointProvider(
+          {
+            Region: typeof input.region === "function" ? await input.region() : input.region,
+            UseDualStack:
+              typeof input.useDualstackEndpoint === "function"
+                ? await input.useDualstackEndpoint()
+                : input.useDualstackEndpoint,
+            UseFIPS:
+              typeof input.useFipsEndpoint === "function" ? await input.useFipsEndpoint() : input.useFipsEndpoint,
+          },
+          { logger: input.logger }
+        )
+      );
+    };
+  }
+  return input as T & DefaultEndpointResolvedConfig;
+};
+
+/**
+ * @internal
+ */
+export const toEndpointV1 = (endpoint: EndpointV2): Endpoint => parseUrl(endpoint.url);