fix: update clientContextParamDefaults to only have conflicting params

smilkuri · smilkuri · commit 8965dee81b96 · 2025-12-10T04:20:55.000Z
diff --git a/packages/eventstream-serde-universal/src/clientContextParams-precedence.integ.spec.ts b/packages/eventstream-serde-universal/src/clientContextParams-precedence.integ.spec.ts
@@ -0,0 +1,40 @@
+import { describe, expect, test as it } from "vitest";
+import { XYZService } from "xyz";
+
+describe("client context parameters precedence integration test", () => {
+  it("should handle conflicting vs non-conflicting parameter precedence correctly", async () => {
+    // For non-conflicting parameter root level takes precedence over nested defaults
+    const clientWithNonConflicting = new XYZService({
+      endpoint: "https://localhost",
+      apiKey: async () => ({ apiKey: "test-key" }),
+      customParam: "user-custom-value", 
+      clientContextParams: {
+        apiKey: "test-key",
+        customParam: "default-custom-value", 
+      },
+    });
+
+    // Verify the resolved config has the user's root-level value
+    const resolvedConfig = (clientWithNonConflicting as any).config;
+    expect(resolvedConfig.customParam).toBe("user-custom-value");
+
+    // For conflicting parameters nested values are used for endpoint resolution
+    const clientWithConflicting = new XYZService({
+      endpoint: "https://localhost", 
+      apiKey: async () => ({ apiKey: "auth-key" }), 
+      clientContextParams: {
+        apiKey: "endpoint-key",
+      },
+    });
+
+    // Verify that both auth and endpoint contexts can coexist
+    const resolvedConfigConflicting = (clientWithConflicting as any).config;
+    
+    // Verify endpoint context has the nested value
+    expect(resolvedConfigConflicting.clientContextParams.apiKey).toBe("endpoint-key");
+    
+    // Verify auth context has the auth provider
+    const authIdentity = await resolvedConfigConflicting.apiKey();
+    expect(authIdentity.apiKey).toBe("auth-key");
+  });
+});
diff --git a/packages/eventstream-serde-universal/src/eventstream-cbor.integ.spec.ts b/packages/eventstream-serde-universal/src/eventstream-cbor.integ.spec.ts
@@ -9,8 +9,11 @@ describe("local model integration test for cbor eventstreams", () => {
   it("should read and write cbor event streams", async () => {
     const client = new XYZService({
       endpoint: "https://localhost",
-      apiKey: { apiKey: "test-api-key" },
-    } as any);
+      apiKey: async () => ({ apiKey: "test-api-key" }),
+      clientContextParams: {
+        apiKey: "test-api-key",
+      },
+    });
 
     const body = cbor.serialize({
       id: "alpha",
diff --git a/packages/middleware-endpoint/src/adaptors/createConfigValueProvider.spec.ts b/packages/middleware-endpoint/src/adaptors/createConfigValueProvider.spec.ts
@@ -61,12 +61,12 @@ describe(createConfigValueProvider.name, () => {
 
   it("should prioritize clientContextParams over direct properties", async () => {
     const config = {
-      apiKey: "direct-api-key",
+      stage: "prod",
       clientContextParams: {
-        apiKey: "nested-api-key",
+        stage: "beta",
       },
     };
-    expect(await createConfigValueProvider("apiKey", "apiKey", config, true)()).toEqual("nested-api-key");
+    expect(await createConfigValueProvider("stage", "stage", config, true)()).toEqual("beta");
   });
 
   it("should fall back to direct property when clientContextParams is not provided", async () => {
diff --git a/packages/util-retry/src/retries.integ.spec.ts b/packages/util-retry/src/retries.integ.spec.ts
@@ -21,7 +21,7 @@ describe("retries", () => {
     const client = new XYZService({
       endpoint: "https://localhost/nowhere",
       apiKey: { apiKey: "test-api-key" },
-    } as any);
+    });
 
     requireRequestsFrom(client)
       .toMatch({
@@ -52,7 +52,7 @@ describe("retries", () => {
     const client = new XYZService({
       endpoint: "https://localhost/nowhere",
       apiKey: { apiKey: "test-api-key" },
-    } as any);
+    });
 
     requireRequestsFrom(client)
       .toMatch({
@@ -83,7 +83,7 @@ describe("retries", () => {
     const client = new XYZService({
       endpoint: "https://localhost/nowhere",
       apiKey: { apiKey: "test-api-key" },
-    } as any);
+    });
 
     requireRequestsFrom(client)
       .toMatch({
@@ -114,7 +114,7 @@ describe("retries", () => {
     const client = new XYZService({
       endpoint: "https://localhost/nowhere",
       apiKey: { apiKey: "test-api-key" },
-    } as any);
+    });
 
     requireRequestsFrom(client)
       .toMatch({
diff --git a/private/my-local-model-schema/src/endpoint/EndpointParameters.ts b/private/my-local-model-schema/src/endpoint/EndpointParameters.ts
@@ -7,13 +7,14 @@ import type { Endpoint, EndpointParameters as __EndpointParameters, EndpointV2,
 export interface ClientInputEndpointParameters {
   clientContextParams?: {
     apiKey?: string | undefined | Provider<string | undefined>;
+    region?: string | undefined | Provider<string | undefined>;
     customParam?: string | undefined | Provider<string | undefined>;
     enableFeature?: boolean | undefined | Provider<boolean | undefined>;
     debugMode?: boolean | undefined | Provider<boolean | undefined>;
     nonConflictingParam?: string | undefined | Provider<string | undefined>;
+    logger?: string | undefined | Provider<string | undefined>;
   };
   endpoint?: string | Provider<string> | Endpoint | Provider<Endpoint> | EndpointV2 | Provider<EndpointV2>;
-  apiKey?: string | undefined | Provider<string | undefined>;
   customParam?: string | undefined | Provider<string | undefined>;
   enableFeature?: boolean | undefined | Provider<boolean | undefined>;
   debugMode?: boolean | undefined | Provider<boolean | undefined>;
@@ -31,10 +32,7 @@ export type ClientResolvedEndpointParameters = Omit<ClientInputEndpointParameter
  * @internal
  */
 const clientContextParamDefaults = {
-  nonConflictingParam: "non-conflict-default",
-  customParam: "default-custom-value",
-  debugMode: false,
-  enableFeature: true,
+  logger: "default-logger",
 } as const;
 
 /**
@@ -59,6 +57,7 @@ export const resolveClientEndpointParameters = <T>(
 export const commonParams = {
   ApiKey: { type: "clientContextParams", name: "apiKey" },
   nonConflictingParam: { type: "clientContextParams", name: "nonConflictingParam" },
+  logger: { type: "clientContextParams", name: "logger" },
   region: { type: "clientContextParams", name: "region" },
   customParam: { type: "clientContextParams", name: "customParam" },
   debugMode: { type: "clientContextParams", name: "debugMode" },
@@ -77,4 +76,5 @@ export interface EndpointParameters extends __EndpointParameters {
   enableFeature?: boolean | undefined;
   debugMode?: boolean | undefined;
   nonConflictingParam?: string | undefined;
+  logger?: string | undefined;
 }
diff --git a/private/my-local-model-schema/src/endpoint/ruleset.ts b/private/my-local-model-schema/src/endpoint/ruleset.ts
@@ -44,6 +44,12 @@ export const ruleSet: RuleSetObject = {
       default: "non-conflict-default",
       documentation: "Non-conflicting with default",
     },
+    logger: {
+      type: "String",
+      required: true,
+      default: "default-logger",
+      documentation: "Conflicting logger with default",
+    },
   },
   rules: [
     {
diff --git a/private/my-local-model/src/endpoint/EndpointParameters.ts b/private/my-local-model/src/endpoint/EndpointParameters.ts
@@ -7,13 +7,14 @@ import type { Endpoint, EndpointParameters as __EndpointParameters, EndpointV2,
 export interface ClientInputEndpointParameters {
   clientContextParams?: {
     apiKey?: string | undefined | Provider<string | undefined>;
+    region?: string | undefined | Provider<string | undefined>;
     customParam?: string | undefined | Provider<string | undefined>;
     enableFeature?: boolean | undefined | Provider<boolean | undefined>;
     debugMode?: boolean | undefined | Provider<boolean | undefined>;
     nonConflictingParam?: string | undefined | Provider<string | undefined>;
+    logger?: string | undefined | Provider<string | undefined>;
   };
   endpoint?: string | Provider<string> | Endpoint | Provider<Endpoint> | EndpointV2 | Provider<EndpointV2>;
-  apiKey?: string | undefined | Provider<string | undefined>;
   customParam?: string | undefined | Provider<string | undefined>;
   enableFeature?: boolean | undefined | Provider<boolean | undefined>;
   debugMode?: boolean | undefined | Provider<boolean | undefined>;
@@ -31,10 +32,7 @@ export type ClientResolvedEndpointParameters = Omit<ClientInputEndpointParameter
  * @internal
  */
 const clientContextParamDefaults = {
-  nonConflictingParam: "non-conflict-default",
-  customParam: "default-custom-value",
-  debugMode: false,
-  enableFeature: true,
+  logger: "default-logger",
 } as const;
 
 /**
@@ -59,6 +57,7 @@ export const resolveClientEndpointParameters = <T>(
 export const commonParams = {
   ApiKey: { type: "clientContextParams", name: "apiKey" },
   nonConflictingParam: { type: "clientContextParams", name: "nonConflictingParam" },
+  logger: { type: "clientContextParams", name: "logger" },
   region: { type: "clientContextParams", name: "region" },
   customParam: { type: "clientContextParams", name: "customParam" },
   debugMode: { type: "clientContextParams", name: "debugMode" },
@@ -77,4 +76,5 @@ export interface EndpointParameters extends __EndpointParameters {
   enableFeature?: boolean | undefined;
   debugMode?: boolean | undefined;
   nonConflictingParam?: string | undefined;
+  logger?: string | undefined;
 }
diff --git a/private/my-local-model/src/endpoint/ruleset.ts b/private/my-local-model/src/endpoint/ruleset.ts
@@ -44,6 +44,12 @@ export const ruleSet: RuleSetObject = {
       default: "non-conflict-default",
       documentation: "Non-conflicting with default",
     },
+    logger: {
+      type: "String",
+      required: true,
+      default: "default-logger",
+      documentation: "Conflicting logger with default",
+    },
   },
   rules: [
     {
diff --git a/smithy-typescript-codegen/src/main/java/software/amazon/smithy/typescript/codegen/endpointsV2/ClientConfigKeys.java b/smithy-typescript-codegen/src/main/java/software/amazon/smithy/typescript/codegen/endpointsV2/ClientConfigKeys.java
@@ -21,6 +21,7 @@ public final class ClientConfigKeys {
     static {
         // Initialize with common client config keys
         KNOWN_CONFIG_KEYS.add("profile");
+        KNOWN_CONFIG_KEYS.add("apiKey");
         KNOWN_CONFIG_KEYS.add("region");
         KNOWN_CONFIG_KEYS.add("credentials");
         KNOWN_CONFIG_KEYS.add("endpoint");
@@ -83,6 +84,16 @@ public static void addConfigKey(String key) {
         KNOWN_CONFIG_KEYS.add(key);
     }
 
+    /**
+     * Check if a key is a known configuration key.
+     *
+     * @param key the configuration key to check
+     * @return true if the key is known
+     */
+    public static boolean isKnownConfigKey(String key) {
+        return KNOWN_CONFIG_KEYS.contains(key);
+    }
+
     /**
      * Get custom context parameters by filtering out built-in and known config
      * keys.
diff --git a/smithy-typescript-codegen/src/main/java/software/amazon/smithy/typescript/codegen/endpointsV2/EndpointsV2Generator.java b/smithy-typescript-codegen/src/main/java/software/amazon/smithy/typescript/codegen/endpointsV2/EndpointsV2Generator.java
@@ -124,16 +124,31 @@ private void generateEndpointParameters() {
                     "export interface ClientInputEndpointParameters {",
                     "}",
                     () -> {
-                        if (ruleSetParameterFinder.hasCustomClientContextParams()) {
+                        Map<String, String> allClientContextParams = ruleSetParameterFinder.getClientContextParams();
+                        if (!allClientContextParams.isEmpty()) {
                             writer.write("clientContextParams?: {");
                             writer.indent();
-                            ruleSetParameterFinder.writeInputConfigCustomClientContextParams(writer);
+                            ObjectNode ruleSet = endpointRuleSetTrait.getRuleSet().expectObjectNode();
+                            ruleSet.getObjectMember("parameters").ifPresent(parameters -> {
+                                parameters.accept(new RuleSetParametersVisitor(writer, allClientContextParams, true));
+                            });
                             writer.dedent();
                             writer.write("};");
                         }
-                        // Add direct params (built-ins + custom context params)
-                        Map<String, String> directParams = new HashMap<>(builtInParams);
-                        directParams.putAll(customContextParams);
+                        // Add direct params (built-ins + custom context params, excluding conflicting)
+                        Map<String, String> directParams = new HashMap<>();
+                        // Add all built-ins (they should always be at root level, even if conflicting)
+                        directParams.putAll(builtInParams);
+                        // Add custom context params excluding conflicting ones
+                        customContextParams.entrySet().forEach(entry -> {
+                            String paramName = entry.getKey();
+                            String localName = EndpointsParamNameMap
+                                .getLocalName(paramName);
+                            if (!ClientConfigKeys.isKnownConfigKey(paramName)
+                                && !ClientConfigKeys.isKnownConfigKey(localName)) {
+                                directParams.put(paramName, entry.getValue());
+                            }
+                        });
                         ObjectNode ruleSet = endpointRuleSetTrait.getRuleSet().expectObjectNode();
                         ruleSet.getObjectMember("parameters").ifPresent(parameters -> {
                             parameters.accept(new RuleSetParametersVisitor(writer, directParams, true));
diff --git a/smithy-typescript-codegen/src/main/java/software/amazon/smithy/typescript/codegen/endpointsV2/RuleSetParameterFinder.java b/smithy-typescript-codegen/src/main/java/software/amazon/smithy/typescript/codegen/endpointsV2/RuleSetParameterFinder.java
@@ -203,27 +203,23 @@ public void writeInputConfigCustomClientContextParams(TypeScriptWriter writer) {
 
     /**
      * Write nested client context parameter defaults to TypeScript writer.
+     * Only includes conflicting parameters with default values.
      */
     public void writeNestedClientContextParamDefaults(TypeScriptWriter writer) {
         Map<String, String> clientContextParams = getClientContextParams();
         Map<String, String> builtInParams = getBuiltInParams();
         builtInParams.keySet().removeIf(OmitEndpointParams::isOmitted);
-        Map<String, String> customContextParams = ClientConfigKeys.getCustomContextParams(
-            clientContextParams, builtInParams);
         ObjectNode ruleSet = ruleset.getRuleSet().expectObjectNode();
         if (ruleSet.getObjectMember("parameters").isPresent()) {
             ObjectNode parameters = ruleSet.getObjectMember("parameters").get().expectObjectNode();
-            boolean hasDefaults = customContextParams.entrySet().stream()
-                .anyMatch(entry -> {
-                    ObjectNode paramNode = parameters.getObjectMember(entry.getKey()).orElse(null);
-                    return paramNode != null && paramNode.containsMember("default");
-                });
-            if (hasDefaults) {
-                writer.write("");
-                writer.writeDocs("@internal");
-                writer.openBlock("const clientContextParamDefaults = {", "} as const;", () -> {
-                    for (Map.Entry<String, String> entry : customContextParams.entrySet()) {
-                        String paramName = entry.getKey();
+            writer.write("");
+            writer.writeDocs("@internal");
+            writer.openBlock("const clientContextParamDefaults = {", "} as const;", () -> {
+                // Write defaults only for conflicting parameters
+                for (Map.Entry<String, String> entry : clientContextParams.entrySet()) {
+                    String paramName = entry.getKey();
+                    // Check if this is a conflicting parameter (exists in both clientContextParams and knownConfigKeys)
+                    if (ClientConfigKeys.isKnownConfigKey(paramName) && !builtInParams.containsKey(paramName)) {
                         ObjectNode paramNode = parameters.getObjectMember(paramName).orElse(null);
                         if (paramNode != null && paramNode.containsMember("default")) {
                             software.amazon.smithy.model.node.Node defaultValue = paramNode.getMember("default").get();
@@ -234,8 +230,8 @@ public void writeNestedClientContextParamDefaults(TypeScriptWriter writer) {
                             }
                         }
                     }
-                });
-            }
+                }
+            });
         }
     }
 
diff --git a/smithy-typescript-codegen/src/main/java/software/amazon/smithy/typescript/codegen/endpointsV2/RuleSetParametersVisitor.java b/smithy-typescript-codegen/src/main/java/software/amazon/smithy/typescript/codegen/endpointsV2/RuleSetParametersVisitor.java
@@ -73,7 +73,10 @@ public Void objectNode(ObjectNode node) {
 
             if (writeDefaults) {
                 if (parameterGenerator.hasDefault()) {
-                    writer.write(parameterGenerator.defaultAsCodeString());
+                    // Don't write root-level defaults for conflicting parameters
+                    if (!ClientConfigKeys.isKnownConfigKey(key)) {
+                        writer.write(parameterGenerator.defaultAsCodeString());
+                    }
                 }
             } else if (clientContextParams.isEmpty() || clientContextParams.containsKey(key)) {
                 boolean isClientContextParams = !clientContextParams.isEmpty();
diff --git a/smithy-typescript-codegen/src/test/java/software/amazon/smithy/typescript/codegen/endpointsV2/EndpointsV2GeneratorTest.java b/smithy-typescript-codegen/src/test/java/software/amazon/smithy/typescript/codegen/endpointsV2/EndpointsV2GeneratorTest.java
@@ -164,9 +164,9 @@ export interface ClientInputEndpointParameters {
                     region?: string | undefined | Provider<string | undefined>;
                     stage?: string | undefined | Provider<string | undefined>;
                   };
-                  region?: string | undefined | Provider<string | undefined>;
                   stage?: string | undefined | Provider<string | undefined>;
-                  endpoint?:"""));
+                  endpoint?: string | Provider<string> | Endpoint | Provider<Endpoint> | EndpointV2 | Provider<EndpointV2>;
+                }"""));
     }
 
     private MockManifest testEndpoints(String filename) {
diff --git a/smithy-typescript-protocol-test-codegen/model/my-local-model/main.smithy b/smithy-typescript-protocol-test-codegen/model/my-local-model/main.smithy
@@ -9,12 +9,14 @@ use smithy.rules#endpointRuleSet
 @rpcv2Cbor
 @documentation("xyz interfaces")
 @httpApiKeyAuth(name: "X-Api-Key", in: "header")
+@httpApiKeyAuth(name: "X-Api-Key", in: "header")
 @clientContextParams(
     customParam: { type: "string", documentation: "Custom parameter" }
     region: { type: "string", documentation: "Conflicting with built-in region" }
     enableFeature: { type: "boolean", documentation: "Feature toggle flag" }
     debugMode: { type: "boolean", documentation: "Debug mode flag" }
     nonConflictingParam: { type: "string", documentation: "Non-conflicting parameter" }
+    logger: { type: "string", documentation: "Conflicting logger parameter" }
     ApiKey: { type: "string", documentation: "ApiKey" }
 )
 @endpointRuleSet({
@@ -27,6 +29,7 @@ use smithy.rules#endpointRuleSet
         enableFeature: { type: "Boolean", required: true, default: true, documentation: "Feature toggle with default" }
         debugMode: { type: "Boolean", required: true, default: false, documentation: "Debug mode with default" }
         nonConflictingParam: { type: "String", required: true, default: "non-conflict-default", documentation: "Non-conflicting with default" }
+        logger: { type: "String", required: true, default: "default-logger", documentation: "Conflicting logger with default" }
     }
     rules: [
         {
