feat(core): add AccountIdEndpointMode config option

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

@@ -0,0 +1,122 @@
+/*
+ * Copyright 2019 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License").
+ * You may not use this file except in compliance with the License.
+ * A copy of the License is located at
+ *
+ *  http://aws.amazon.com/apache2.0
+ *
+ * or in the "license" file accompanying this file. This file is distributed
+ * on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
+ * express or implied. See the License for the specific language governing
+ * permissions and limitations under the License.
+ */
+
+package software.amazon.smithy.aws.typescript.codegen;
+
+import software.amazon.smithy.aws.traits.ServiceTrait;
+import software.amazon.smithy.codegen.core.SymbolProvider;
+import software.amazon.smithy.model.Model;
+import software.amazon.smithy.model.shapes.ServiceShape;
+import software.amazon.smithy.rulesengine.traits.EndpointRuleSetTrait;
+import software.amazon.smithy.typescript.codegen.endpointsV2.RuleSetParameterFinder;
+import software.amazon.smithy.typescript.codegen.LanguageTarget;
+import software.amazon.smithy.typescript.codegen.TypeScriptDependency;
+import software.amazon.smithy.typescript.codegen.TypeScriptSettings;
+import software.amazon.smithy.typescript.codegen.TypeScriptWriter;
+import software.amazon.smithy.typescript.codegen.integration.TypeScriptIntegration;
+import software.amazon.smithy.utils.SmithyInternalApi;
+
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.function.Consumer;
+import java.util.logging.Logger;
+
+/**
+ * Generates accountIdEndpointMode configuration field for service clients that have the eponymous built-in param in the ruleset.
+ */
+@SmithyInternalApi
+public final class AddAccountIdEndpointModeRuntimeConfig implements TypeScriptIntegration {
+
+    private static final Logger LOGGER = Logger.getLogger(AddAccountIdEndpointModeRuntimeConfig.class.getName());
+
+    @Override
+    public void addConfigInterfaceFields(
+            TypeScriptSettings settings,
+            Model model,
+            SymbolProvider symbolProvider,
+            TypeScriptWriter writer
+    ) {
+        if (isAwsService(settings, model)) {
+            ServiceShape service = settings.getService(model);
+            EndpointRuleSetTrait endpointRuleSetTrait = service.getTrait(EndpointRuleSetTrait.class)
+                    .orElseThrow(() -> new RuntimeException("service missing EndpointRuleSetTrait"));
+            RuleSetParameterFinder ruleSetParameterFinder = new RuleSetParameterFinder(service);
+            if (ruleSetParameterFinder.getBuiltInParams().containsKey("AccountIdEndpointMode")) {
+                writer.writeDocs("Defines if the AWS AccountId will be used for endpoint routing.")
+                        .write("accountIdEndpointMode?: AccountIdEndpointMode | __Provider<AccountIdEndpointMode>;\n");
+            }
+        }
+    }
+
+    @Override
+    public void prepareCustomizations(
+        TypeScriptWriter writer,
+        LanguageTarget target,
+        TypeScriptSettings settings,
+        Model model
+    ) {
+        if (isAwsService(settings, model) && target.equals(LanguageTarget.NODE)) {
+            writer.addDependency(AwsDependency.AWS_SDK_CORE);
+            writer.addImport("emitWarningIfUnsupportedVersion", "awsCheckVersion", AwsDependency.AWS_SDK_CORE);
+            writer.write("awsCheckVersion(process.version);");
+        }
+    }
+
+    @Override
+    public Map<String, Consumer<TypeScriptWriter>> getRuntimeConfigWriters(
+            TypeScriptSettings settings,
+            Model model,
+            SymbolProvider symbolProvider,
+            LanguageTarget target
+    ) {
+        ServiceShape service = settings.getService(model);
+        Map<String, Consumer<TypeScriptWriter>> runtimeConfigs = new HashMap<>();
+        if (isAwsService(settings, model)) {
+            EndpointRuleSetTrait endpointRuleSetTrait = service.getTrait(EndpointRuleSetTrait.class)
+                    .orElseThrow(() -> new RuntimeException("service missing EndpointRuleSetTrait"));
+            RuleSetParameterFinder ruleSetParameterFinder = new RuleSetParameterFinder(service);
+            if (ruleSetParameterFinder.getBuiltInParams().containsKey("AccountIdEndpointMode")) {
+                switch (target) {
+                    case BROWSER:
+                        runtimeConfigs.put("accountIdEndpointMode", writer -> {
+                            writer.addDependency(TypeScriptDependency.CONFIG_RESOLVER);
+                            writer.addImport("DEFAULT_ACCOUNT_ID_ENDPOINT_MODE", "DEFAULT_ACCOUNT_ID_ENDPOINT_MODE",
+                                    TypeScriptDependency.CONFIG_RESOLVER);
+                            writer.write("(() => Promise.resolve(DEFAULT_ACCOUNT_ID_ENDPOINT_MODE))");
+                        });
+                        break;
+                    case NODE:
+                        runtimeConfigs.put("accountIdEndpointMode", writer -> {
+                            writer.addDependency(TypeScriptDependency.NODE_CONFIG_PROVIDER);
+                            writer.addImport("loadConfig", "loadNodeConfig",
+                                    TypeScriptDependency.NODE_CONFIG_PROVIDER);
+                            writer.addDependency(TypeScriptDependency.CONFIG_RESOLVER);
+                            writer.addImport("NODE_ACCOUNT_ID_ENDPOINT_MODE_CONFIG_OPTIONS", "NODE_ACCOUNT_ID_ENDPOINT_MODE_CONFIG_OPTIONS",
+                                    TypeScriptDependency.CONFIG_RESOLVER);
+                            writer.write(
+                                    "loadNodeConfig(NODE_ACCOUNT_ID_ENDPOINT_MODE_CONFIG_OPTIONS");
+                        });
+                        break;
+                    default:
+                        LOGGER.warning("AccountIdEndpointMode config not supported for target: " + target);
+                        break;
+                }
+            }
+        }
+        return runtimeConfigs;
+    }
+}

packages/core/package.json

@@ -31,7 +31,9 @@
     "@smithy/smithy-client": "^2.5.1",
     "@smithy/types": "^2.12.0",
     "fast-xml-parser": "4.2.5",
-    "tslib": "^2.6.2"
+    "tslib": "^2.6.2",
+    "@smithy/node-config-provider": "^2.3.0",
+    "@smithy/util-middleware": "^2.2.0"
   },
   "devDependencies": {
     "@tsconfig/recommended": "1.0.1",

packages/core/src/AccountIdEndpointModeConfigResolver.ts

@@ -0,0 +1,56 @@
+import { Provider } from "@smithy/types";
+import { normalizeProvider } from "@smithy/util-middleware";
+
+import {
+  AccountIdEndpointMode,
+  DEFAULT_ACCOUNT_ID_ENDPOINT_MODE,
+  validateAccountIdEndpointMode,
+} from "./AccountIdEndpointModeConstants";
+
+/**
+ * @public
+ */
+export interface AccountIdEndpointModeInputConfig {
+  /**
+   * The account ID endpoint mode to use.
+   */
+  accountIdEndpointMode?: AccountIdEndpointMode | Provider<AccountIdEndpointMode>;
+}
+
+/**
+ * @internal
+ */
+interface PreviouslyResolved {}
+
+/**
+ * @internal
+ */
+export interface AccountIdEndpointModeResolvedConfig {
+  /**
+   * Resolved value for input config {config.accountIdEndpointMode}
+   */
+  accountIdEndpointMode: Provider<AccountIdEndpointMode>;
+}
+
+/**
+ * @internal
+ */
+export const resolveAccountIdEndpointModeConfig = <T>(
+  input: T & AccountIdEndpointModeInputConfig & PreviouslyResolved
+): T & AccountIdEndpointModeResolvedConfig => {
+  return {
+    ...input,
+    accountIdEndpointMode: async () => {
+      const accountIdEndpointModeProvider = normalizeProvider(
+        input.accountIdEndpointMode ?? DEFAULT_ACCOUNT_ID_ENDPOINT_MODE
+      );
+      const accIdMode = await accountIdEndpointModeProvider();
+      if (!validateAccountIdEndpointMode(accIdMode)) {
+        throw new Error(
+          `Invalid value for accountIdEndpointMode: ${accIdMode}. Valid values are: "required", "preferred", "disabled".`
+        );
+      }
+      return accIdMode;
+    },
+  };
+};

packages/core/src/AccountIdEndpointModeConstants.spec.ts

@@ -0,0 +1,43 @@
+import { validateAccountIdEndpointMode } from "./AccountIdEndpointModeConstants";
+
+describe("validateAccountIdEndpointMode", () => {
+  it('should return true for "disabled"', () => {
+    const result = validateAccountIdEndpointMode("disabled");
+    expect(result).toBe(true);
+  });
+
+  it('should return true for "preferred"', () => {
+    const result = validateAccountIdEndpointMode("preferred");
+    expect(result).toBe(true);
+  });
+
+  it('should return true for "required"', () => {
+    const result = validateAccountIdEndpointMode("required");
+    expect(result).toBe(true);
+  });
+
+  it("should return false for an invalid value", () => {
+    const result = validateAccountIdEndpointMode("invalidValue");
+    expect(result).toBe(false);
+  });
+
+  it("should return false for an empty string", () => {
+    const result = validateAccountIdEndpointMode("");
+    expect(result).toBe(false);
+  });
+
+  it("should return false for a number", () => {
+    const result = validateAccountIdEndpointMode(123);
+    expect(result).toBe(false);
+  });
+
+  it("should return false for null", () => {
+    const result = validateAccountIdEndpointMode(null);
+    expect(result).toBe(false);
+  });
+
+  it("should return false for undefined", () => {
+    const result = validateAccountIdEndpointMode(undefined);
+    expect(result).toBe(false);
+  });
+});

packages/core/src/AccountIdEndpointModeConstants.ts

@@ -0,0 +1,12 @@
+export type AccountIdEndpointMode = "disabled" | "preferred" | "required";
+
+export const DEFAULT_ACCOUNT_ID_ENDPOINT_MODE = "preferred";
+
+export const ACCOUNT_ID_ENDPOINT_MODE_VALUES: AccountIdEndpointMode[] = ["disabled", "preferred", "required"];
+
+/**
+ * @internal
+ */
+export function validateAccountIdEndpointMode(value: any): value is AccountIdEndpointMode {
+  return ACCOUNT_ID_ENDPOINT_MODE_VALUES.includes(value);
+}

packages/core/src/NodeAccountIdEndpointModeConfigOptions.spec.ts

@@ -0,0 +1,68 @@
+import { DEFAULT_ACCOUNT_ID_ENDPOINT_MODE } from "./AccountIdEndpointModeConstants";
+import {
+  CONFIG_ACCOUNT_ID_ENDPOINT_MODE,
+  ENV_ACCOUNT_ID_ENDPOINT_MODE,
+  NODE_ACCOUNT_ID_ENDPOINT_MODE_CONFIG_OPTIONS,
+} from "./NodeAccountIdEndpointModeConfigOptions";
+
+describe("NODE_ACCOUNT_ID_ENDPOINT_MODE_CONFIG_OPTIONS", () => {
+  const originalEnv = process.env;
+
+  beforeEach(() => {
+    jest.resetModules();
+    process.env = { ...originalEnv };
+  });
+
+  afterEach(() => {
+    process.env = originalEnv;
+  });
+
+  describe("environmentVariableSelector", () => {
+    it("should return the value set in environment variables", () => {
+      const testValue = "preferred";
+      process.env[ENV_ACCOUNT_ID_ENDPOINT_MODE] = testValue;
+      const selector = NODE_ACCOUNT_ID_ENDPOINT_MODE_CONFIG_OPTIONS.environmentVariableSelector;
+      expect(selector(process.env)).toEqual(testValue);
+    });
+
+    it("should throw an error if the environment variable is set to an invalid value", () => {
+      process.env[ENV_ACCOUNT_ID_ENDPOINT_MODE] = "InvalidValue";
+      const selector = NODE_ACCOUNT_ID_ENDPOINT_MODE_CONFIG_OPTIONS.environmentVariableSelector;
+      expect(() => selector(process.env)).toThrow("Invalid AccountIdEndpointMode value");
+    });
+
+    it("should not throw an error if the environment variable is not set", () => {
+      delete process.env[ENV_ACCOUNT_ID_ENDPOINT_MODE];
+      const selector = NODE_ACCOUNT_ID_ENDPOINT_MODE_CONFIG_OPTIONS.environmentVariableSelector;
+      expect(() => selector(process.env)).not.toThrow();
+    });
+  });
+
+  describe("configFileSelector", () => {
+    it("should return the value set in the configuration file", () => {
+      const testValue = "required";
+      const profile = { [CONFIG_ACCOUNT_ID_ENDPOINT_MODE]: testValue };
+      const selector = NODE_ACCOUNT_ID_ENDPOINT_MODE_CONFIG_OPTIONS.configFileSelector;
+      expect(selector(profile)).toEqual(testValue);
+    });
+
+    it("should throw an error if the configuration file contains an invalid value", () => {
+      const profile = { [CONFIG_ACCOUNT_ID_ENDPOINT_MODE]: "InvalidValue" };
+      const selector = NODE_ACCOUNT_ID_ENDPOINT_MODE_CONFIG_OPTIONS.configFileSelector;
+      expect(() => selector(profile)).toThrow("Invalid AccountIdEndpointMode value");
+    });
+
+    it("should not throw an error if the configuration file does not contain the setting", () => {
+      const profile = {};
+      const selector = NODE_ACCOUNT_ID_ENDPOINT_MODE_CONFIG_OPTIONS.configFileSelector;
+      expect(() => selector(profile)).not.toThrow();
+    });
+  });
+
+  describe("default", () => {
+    it("should return the default value", () => {
+      const defaultValue = NODE_ACCOUNT_ID_ENDPOINT_MODE_CONFIG_OPTIONS.default;
+      expect(defaultValue).toEqual(DEFAULT_ACCOUNT_ID_ENDPOINT_MODE);
+    });
+  });
+});

packages/core/src/NodeAccountIdEndpointModeConfigOptions.ts

@@ -0,0 +1,44 @@
+import { LoadedConfigSelectors } from "@smithy/node-config-provider";
+
+import {
+  AccountIdEndpointMode,
+  DEFAULT_ACCOUNT_ID_ENDPOINT_MODE,
+  validateAccountIdEndpointMode,
+} from "./AccountIdEndpointModeConstants";
+
+const err = "Invalid AccountIdEndpointMode value";
+
+const _throw = (message: string): never => {
+  throw new Error(message);
+};
+
+/**
+ * @internal
+ */
+export const ENV_ACCOUNT_ID_ENDPOINT_MODE = "AWS_ACCOUNT_ID_ENDPOINT_MODE";
+
+/**
+ * @internal
+ */
+export const CONFIG_ACCOUNT_ID_ENDPOINT_MODE = "account_id_endpoint_mode";
+
+/**
+ * @internal
+ */
+export const NODE_ACCOUNT_ID_ENDPOINT_MODE_CONFIG_OPTIONS: LoadedConfigSelectors<AccountIdEndpointMode> = {
+  environmentVariableSelector: (env) => {
+    const value = env[ENV_ACCOUNT_ID_ENDPOINT_MODE];
+    if (value && !validateAccountIdEndpointMode(value)) {
+      _throw(err);
+    }
+    return value as AccountIdEndpointMode;
+  },
+  configFileSelector: (profile) => {
+    const value = profile[CONFIG_ACCOUNT_ID_ENDPOINT_MODE];
+    if (value && !validateAccountIdEndpointMode(value)) {
+      _throw(err);
+    }
+    return value as AccountIdEndpointMode;
+  },
+  default: DEFAULT_ACCOUNT_ID_ENDPOINT_MODE,
+};