update runtime config customization to be fully overridable (smithy-lang#153)

* update runtime config customization to be fully overridable

Previously, some default runtime config values are hard-coded into
templates. This change makes each one of the properties(e.g. requestHandler)
to be overridable by customizations from SDK side. If no customization
exists, the generator can still generate SDK with proper dependencies.

This change is added to support the customization of using WebSocket
requestHandler.

This change also brings in the capability that customization applied
later can override the runtime config values added in earlier
customization. This is necessary sometimes. For example, if customization
A adds runtime config: {x: X, y: Y}. x and y are deeply coupled that
they need to be in the same customization. If there's a single client
needs runtime config {x: X, y: Y-update}, we should be able to make
a new customization overriding the original customization.

* Add ordering to customizations; runtimeConfig needs writing a whole line

Author: AllanZhengYP

smithy-typescript-codegen/src/main/java/software/amazon/smithy/typescript/codegen/CodegenVisitor.java

@@ -17,6 +17,7 @@
 
 import java.util.ArrayList;
 import java.util.Collection;
+import java.util.Comparator;
 import java.util.HashMap;
 import java.util.LinkedHashMap;
 import java.util.List;
@@ -95,6 +96,8 @@ class CodegenVisitor extends ShapeVisitor.Default<Void> {
                         runtimePlugins.add(runtimePlugin);
                     });
                 });
+        // Sort the integrations in specified order.
+        integrations.sort(Comparator.comparingInt(TypeScriptIntegration::getOrder));
 
         // Decorate the symbol provider using integrations.
         SymbolProvider resolvedProvider = TypeScriptCodegenPlugin.createSymbolProvider(model);

smithy-typescript-codegen/src/main/java/software/amazon/smithy/typescript/codegen/RuntimeConfigGenerator.java

@@ -16,10 +16,16 @@
 package software.amazon.smithy.typescript.codegen;
 
 import java.util.List;
+import java.util.Map;
+import java.util.TreeMap;
+import java.util.function.Consumer;
+
+import software.amazon.smithy.build.SmithyBuildException;
 import software.amazon.smithy.codegen.core.SymbolProvider;
 import software.amazon.smithy.model.Model;
 import software.amazon.smithy.model.shapes.ServiceShape;
 import software.amazon.smithy.typescript.codegen.integration.TypeScriptIntegration;
+import software.amazon.smithy.utils.MapUtils;
 
 /**
  * Generates runtime configuration files, files that are used to
@@ -34,6 +40,170 @@ final class RuntimeConfigGenerator {
     private final SymbolProvider symbolProvider;
     private final TypeScriptDelegator delegator;
     private final List<TypeScriptIntegration> integrations;
+    private final Map<String, Consumer<TypeScriptWriter>> nodeRuntimeConfigDefaults = MapUtils.of(
+            "requestHandler", writer -> {
+                writer.addDependency(TypeScriptDependency.AWS_SDK_NODE_HTTP_HANDLER);
+                writer.addImport("NodeHttpHandler", "NodeHttpHandler",
+                        TypeScriptDependency.AWS_SDK_NODE_HTTP_HANDLER.packageName);
+                writer.write("requestHandler: new NodeHttpHandler(),");
+            },
+            "sha256", writer -> {
+                writer.addDependency(TypeScriptDependency.AWS_SDK_HASH_NODE);
+                writer.addImport("Hash", "Hash",
+                        TypeScriptDependency.AWS_SDK_HASH_NODE.packageName);
+                writer.write("sha256: Hash.bind(null, \"sha256\"),");
+            },
+            "urlParser", writer -> {
+                writer.addDependency(TypeScriptDependency.AWS_SDK_URL_PARSER_NODE);
+                writer.addImport("parseUrl", "parseUrl",
+                        TypeScriptDependency.AWS_SDK_URL_PARSER_NODE.packageName);
+                writer.write("urlParser: parseUrl,");
+            },
+            "bodyLengthChecker", writer -> {
+                writer.addDependency(TypeScriptDependency.AWS_SDK_UTIL_BODY_LENGTH_NODE);
+                writer.addImport("calculateBodyLength", "calculateBodyLength",
+                        TypeScriptDependency.AWS_SDK_UTIL_BODY_LENGTH_NODE.packageName);
+                writer.write("bodyLengthChecker: calculateBodyLength,");
+            },
+            "streamCollector", writer -> {
+                writer.addDependency(TypeScriptDependency.AWS_SDK_STREAM_COLLECTOR_NODE);
+                writer.addImport("streamCollector", "streamCollector",
+                        TypeScriptDependency.AWS_SDK_STREAM_COLLECTOR_NODE.packageName);
+                writer.write("streamCollector,");
+            },
+            "base64Decoder", writer -> {
+                writer.addDependency(TypeScriptDependency.AWS_SDK_UTIL_BASE64_NODE);
+                writer.addImport("fromBase64", "fromBase64",
+                        TypeScriptDependency.AWS_SDK_UTIL_BASE64_NODE.packageName);
+                writer.write("base64Decoder: fromBase64,");
+            },
+            "base64Encoder", writer -> {
+                writer.addDependency(TypeScriptDependency.AWS_SDK_UTIL_BASE64_NODE);
+                writer.addImport("toBase64", "toBase64",
+                        TypeScriptDependency.AWS_SDK_UTIL_BASE64_NODE.packageName);
+                writer.write("base64Encoder: toBase64,");
+            },
+            "utf8Decoder", writer -> {
+                writer.addDependency(TypeScriptDependency.AWS_SDK_UTIL_UTF8_NODE);
+                writer.addImport("fromUtf8", "fromUtf8",
+                        TypeScriptDependency.AWS_SDK_UTIL_UTF8_NODE.packageName);
+                writer.write("utf8Decoder: fromUtf8,");
+            },
+            "utf8Encoder", writer -> {
+                writer.addDependency(TypeScriptDependency.AWS_SDK_UTIL_UTF8_NODE);
+                writer.addImport("toUtf8", "toUtf8",
+                        TypeScriptDependency.AWS_SDK_UTIL_UTF8_NODE.packageName);
+                writer.write("utf8Encoder: toUtf8,");
+            },
+            "defaultUserAgent", writer -> {
+                writer.addDependency(TypeScriptDependency.AWS_SDK_UTIL_USER_AGENT_NODE);
+                writer.addImport("defaultUserAgent", "defaultUserAgent",
+                        TypeScriptDependency.AWS_SDK_UTIL_USER_AGENT_NODE.packageName);
+                writer.addImport("name", "name", "./package.json");
+                writer.addImport("version", "version", "./package.json");
+                writer.write("defaultUserAgent: defaultUserAgent(name, version),");
+            }
+    );
+    private final Map<String, Consumer<TypeScriptWriter>> browserRuntimeConfigDefaults = MapUtils.of(
+            "requestHandler", writer -> {
+                writer.addDependency(TypeScriptDependency.AWS_SDK_FETCH_HTTP_HANDLER);
+                writer.addImport("FetchHttpHandler", "FetchHttpHandler",
+                        TypeScriptDependency.AWS_SDK_FETCH_HTTP_HANDLER.packageName);
+                writer.write("requestHandler: new FetchHttpHandler(),");
+            },
+            "sha256", writer -> {
+                writer.addDependency(TypeScriptDependency.AWS_CRYPTO_SHA256_BROWSER);
+                writer.addImport("Sha256", "Sha256",
+                        TypeScriptDependency.AWS_CRYPTO_SHA256_BROWSER.packageName);
+                writer.write("sha256: Sha256,");
+            },
+            "urlParser", writer -> {
+                writer.addDependency(TypeScriptDependency.AWS_SDK_URL_PARSER_BROWSER);
+                writer.addImport("parseUrl", "parseUrl",
+                        TypeScriptDependency.AWS_SDK_URL_PARSER_BROWSER.packageName);
+                writer.write("urlParser: parseUrl,");
+            },
+            "bodyLengthChecker", writer -> {
+                writer.addDependency(TypeScriptDependency.AWS_SDK_UTIL_BODY_LENGTH_BROWSER);
+                writer.addImport("calculateBodyLength", "calculateBodyLength",
+                        TypeScriptDependency.AWS_SDK_UTIL_BODY_LENGTH_BROWSER.packageName);
+                writer.write("bodyLengthChecker: calculateBodyLength,");
+            },
+            "streamCollector", writer -> {
+                writer.addDependency(TypeScriptDependency.AWS_SDK_STREAM_COLLECTOR_BROWSER);
+                writer.addImport("streamCollector", "streamCollector",
+                        TypeScriptDependency.AWS_SDK_STREAM_COLLECTOR_BROWSER.packageName);
+                writer.write("streamCollector,");
+            },
+            "base64Decoder", writer -> {
+                writer.addDependency(TypeScriptDependency.AWS_SDK_UTIL_BASE64_BROWSER);
+                writer.addImport("fromBase64", "fromBase64",
+                        TypeScriptDependency.AWS_SDK_UTIL_BASE64_BROWSER.packageName);
+                writer.write("base64Decoder: fromBase64,");
+            },
+            "base64Encoder", writer -> {
+                writer.addDependency(TypeScriptDependency.AWS_SDK_UTIL_BASE64_BROWSER);
+                writer.addImport("toBase64", "toBase64",
+                        TypeScriptDependency.AWS_SDK_UTIL_BASE64_BROWSER.packageName);
+                writer.write("base64Encoder: toBase64,");
+            },
+            "utf8Decoder", writer -> {
+                writer.addDependency(TypeScriptDependency.AWS_SDK_UTIL_UTF8_BROWSER);
+                writer.addImport("fromUtf8", "fromUtf8",
+                        TypeScriptDependency.AWS_SDK_UTIL_UTF8_BROWSER.packageName);
+                writer.write("utf8Decoder: fromUtf8,");
+            },
+            "utf8Encoder", writer -> {
+                writer.addDependency(TypeScriptDependency.AWS_SDK_UTIL_UTF8_BROWSER);
+                writer.addImport("toUtf8", "toUtf8",
+                        TypeScriptDependency.AWS_SDK_UTIL_UTF8_BROWSER.packageName);
+                writer.write("utf8Encoder: toUtf8,");
+            },
+            "defaultUserAgent", writer -> {
+                writer.addDependency(TypeScriptDependency.AWS_SDK_UTIL_USER_AGENT_BROWSER);
+                writer.addImport("defaultUserAgent", "defaultUserAgent",
+                        TypeScriptDependency.AWS_SDK_UTIL_USER_AGENT_BROWSER.packageName);
+                writer.addImport("name", "name", "./package.json");
+                writer.addImport("version", "version", "./package.json");
+                writer.write("defaultUserAgent: defaultUserAgent(name, version),");
+            }
+    );
+    private final Map<String, Consumer<TypeScriptWriter>> reactNativeRuntimeConfigDefaults = MapUtils.of(
+            "requestHandler", writer -> {
+                writer.addDependency(TypeScriptDependency.AWS_SDK_FETCH_HTTP_HANDLER);
+                writer.addImport("FetchHttpHandler", "FetchHttpHandler",
+                        TypeScriptDependency.AWS_SDK_FETCH_HTTP_HANDLER.packageName);
+                writer.write("requestHandler: new FetchHttpHandler({ bufferBody: true }),");
+            },
+            "sha256", writer -> {
+                writer.addDependency(TypeScriptDependency.AWS_CRYPTO_SHA256_JS);
+                writer.addImport("Sha256", "Sha256",
+                        TypeScriptDependency.AWS_CRYPTO_SHA256_JS.packageName);
+                writer.write("sha256: Sha256,");
+            },
+            "urlParser", writer -> {
+                writer.addDependency(TypeScriptDependency.AWS_SDK_URL_PARSER_BROWSER);
+                writer.addImport("parseUrl", "parseUrl",
+                        TypeScriptDependency.AWS_SDK_URL_PARSER_BROWSER.packageName);
+                writer.write("urlParser: parseUrl,");
+            },
+            "streamCollector", writer -> {
+                writer.addDependency(TypeScriptDependency.AWS_SDK_STREAM_COLLECTOR_RN);
+                writer.addImport("streamCollector", "streamCollector",
+                        TypeScriptDependency.AWS_SDK_STREAM_COLLECTOR_RN.packageName);
+                writer.write("streamCollector,");
+            },
+            "defaultUserAgent", writer -> {
+                writer.addImport("name", "name", "./package.json");
+                writer.addImport("version", "version", "./package.json");
+                writer.write("defaultUserAgent: `aws-sdk-js-v3-react-native-$${name}/$${version}`,");
+            }
+    );
+    private final Map<String, Consumer<TypeScriptWriter>> sharedRuntimeConfigDefaults = MapUtils.of(
+            "disableHostPrefix", writer -> {
+                writer.write("disableHostPrefix: false,");
+            }
+    );
 
     RuntimeConfigGenerator(
             TypeScriptSettings settings,
@@ -62,12 +232,32 @@ void generate(LanguageTarget target) {
             // Inject customizations into the ~template.
             writer.onSection("customizations", original -> {
                 writer.indent();
+                // Start with defaults, use a TreeMap for keeping entries sorted.
+                Map<String, Consumer<TypeScriptWriter>> configs =
+                        new TreeMap<>(getDefaultRuntimeConfigs(target));
+                // Add any integration supplied runtime config writers.
                 for (TypeScriptIntegration integration : integrations) {
-                    integration.addRuntimeConfigValues(settings, model, symbolProvider, writer, target);
+                    configs.putAll(integration.getRuntimeConfigWriters(settings, model, symbolProvider, target));
                 }
+                configs.values().forEach(value -> value.accept(writer));
                 writer.dedent();
             });
             writer.write(contents, "");
         });
     }
+
+    private Map<String, Consumer<TypeScriptWriter>> getDefaultRuntimeConfigs(LanguageTarget target) {
+        switch (target) {
+            case NODE:
+                return nodeRuntimeConfigDefaults;
+            case BROWSER:
+                return browserRuntimeConfigDefaults;
+            case REACT_NATIVE:
+                return reactNativeRuntimeConfigDefaults;
+            case SHARED:
+                return sharedRuntimeConfigDefaults;
+            default:
+                throw new SmithyBuildException("Unknown target: " + target);
+        }
+    }
 }

smithy-typescript-codegen/src/main/java/software/amazon/smithy/typescript/codegen/integration/AddEventStreamDependency.java

@@ -15,8 +15,11 @@
 
 package software.amazon.smithy.typescript.codegen.integration;
 
+import java.util.Collections;
 import java.util.List;
+import java.util.Map;
 import java.util.Set;
+import java.util.function.Consumer;
 
 import software.amazon.smithy.codegen.core.SymbolProvider;
 import software.amazon.smithy.model.Model;
@@ -29,6 +32,7 @@
 import software.amazon.smithy.typescript.codegen.TypeScriptSettings;
 import software.amazon.smithy.typescript.codegen.TypeScriptWriter;
 import software.amazon.smithy.utils.ListUtils;
+import software.amazon.smithy.utils.MapUtils;
 
 /**
  * Adds event streams if needed.
@@ -65,42 +69,43 @@ public void addConfigInterfaceFields(
     }
 
     @Override
-    public void addRuntimeConfigValues(
+    public Map<String, Consumer<TypeScriptWriter>> getRuntimeConfigWriters(
             TypeScriptSettings settings,
             Model model,
             SymbolProvider symbolProvider,
-            TypeScriptWriter writer,
             LanguageTarget target
     ) {
         if (!hasEventStream(model, settings.getService(model))) {
-            return;
+            return Collections.emptyMap();
         }
-
         switch (target) {
             case NODE:
-                writer.addDependency(TypeScriptDependency.AWS_SDK_EVENTSTREAM_SERDE_NODE);
-                writer.addImport("eventStreamSerdeProvider", "eventStreamSerdeProvider",
-                        TypeScriptDependency.AWS_SDK_EVENTSTREAM_SERDE_NODE.packageName);
-                writer.write("eventStreamSerdeProvider");
-                break;
+                return MapUtils.of("eventStreamSerdeProvider", writer -> {
+                    writer.addDependency(TypeScriptDependency.AWS_SDK_EVENTSTREAM_SERDE_NODE);
+                    writer.addImport("eventStreamSerdeProvider", "eventStreamSerdeProvider",
+                            TypeScriptDependency.AWS_SDK_EVENTSTREAM_SERDE_NODE.packageName);
+                    writer.write("eventStreamSerdeProvider,");
+                });
             case BROWSER:
-                writer.addDependency(TypeScriptDependency.AWS_SDK_EVENTSTREAM_SERDE_BROWSER);
-                writer.addImport("eventStreamSerdeProvider", "eventStreamSerdeProvider",
-                        TypeScriptDependency.AWS_SDK_EVENTSTREAM_SERDE_BROWSER.packageName);
-                writer.write("eventStreamSerdeProvider");
-                break;
+                return MapUtils.of("eventStreamSerdeProvider", writer -> {
+                    writer.addDependency(TypeScriptDependency.AWS_SDK_EVENTSTREAM_SERDE_BROWSER);
+                    writer.addImport("eventStreamSerdeProvider", "eventStreamSerdeProvider",
+                            TypeScriptDependency.AWS_SDK_EVENTSTREAM_SERDE_BROWSER.packageName);
+                    writer.write("eventStreamSerdeProvider,");
+                });
             case REACT_NATIVE:
                 // TODO: add ReactNative eventstream support
-                writer.addDependency(TypeScriptDependency.INVALID_DEPENDENCY);
-                writer.addImport("invalidFunction", "invalidFunction",
-                        TypeScriptDependency.INVALID_DEPENDENCY.packageName);
-                writer.openBlock("eventStreamSerdeProvider: () => ({", "})", () -> {
-                    writer.write("serialize: invalidFunction(\"event stream is not supported in ReactNative.\"),");
-                    writer.write("deserialize: invalidFunction(\"event stream is not supported in ReactNative.\")");
+                return MapUtils.of("eventStreamSerdeProvider", writer -> {
+                    writer.addDependency(TypeScriptDependency.INVALID_DEPENDENCY);
+                    writer.addImport("invalidFunction", "invalidFunction",
+                            TypeScriptDependency.INVALID_DEPENDENCY.packageName);
+                    writer.openBlock("eventStreamSerdeProvider: () => ({", "}),", () -> {
+                        writer.write("serialize: invalidFunction(\"event stream is not supported in ReactNative.\"),");
+                        writer.write("deserialize: invalidFunction(\"event stream is not supported in ReactNative.\")");
+                    });
                 });
-                break;
             default:
-                // do nothing
+                return Collections.emptyMap();
         }
     }