Merge pull request #282 from adamthom-amzn/norecord

Get rid of needing to cast OperationSerializers.

Author: adamthom-amzn

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

@@ -328,7 +328,6 @@ public Void serviceShape(ServiceShape shape) {
                             context.withSymbolProvider(serverSymbolProvider);
                     protocolGenerator.generateRequestDeserializers(serverContext);
                     protocolGenerator.generateResponseSerializers(serverContext);
-                    protocolGenerator.generateMux(serverContext);
                     protocolGenerator.generateHandlerFactory(serverContext);
                 }
                 protocolGenerator.generateSharedComponents(context);

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

@@ -32,7 +32,7 @@ static void generateOperationsType(SymbolProvider symbolProvider,
                                        Set<OperationShape> operations,
                                        TypeScriptWriter writer) {
         Symbol serviceSymbol = symbolProvider.toSymbol(serviceShape);
-        writer.writeInline("type $L = ", serviceSymbol.expectProperty("operations", Symbol.class).getName());
+        writer.writeInline("export type $L = ", serviceSymbol.expectProperty("operations", Symbol.class).getName());
         for (Iterator<OperationShape> iter = operations.iterator(); iter.hasNext();) {
             writer.writeInline("$S", iter.next().getId().getName());
             if (iter.hasNext()) {
@@ -65,8 +65,8 @@ static void generateServiceHandler(SymbolProvider symbolProvider,
         writer.openBlock("export class $L implements ServiceHandler {", "}", handlerSymbol.getName(), () -> {
             writer.write("private service: $T;", serviceSymbol);
             writer.write("private mux: Mux<$S, $T>;", serviceShape.getId().getName(), operationsType);
-            writer.write("private serializers: Record<$1T, OperationSerializer<$2L, $1T>>;",
-                    operationsType, serviceSymbol.getName());
+            writer.write("private serializerFactory: <T extends $T>(operation: T) => OperationSerializer<$T, T>;",
+                    operationsType, serviceSymbol);
             writer.openBlock("private serdeContextBase = {", "};", () -> {
                 writer.write("base64Encoder: toBase64,");
                 writer.write("base64Decoder: fromBase64,");
@@ -76,23 +76,24 @@ static void generateServiceHandler(SymbolProvider symbolProvider,
                 writer.write("requestHandler: new NodeHttpHandler(),");
                 writer.write("disableHostPrefix: true");
             });
-            writer.write("/**");
-            writer.write(" * Construct a $T handler.", serviceSymbol);
-            writer.write(" * @param service The {@link $T} implementation that supplies", serviceSymbol);
-            writer.write(" *                the business logic for $T", serviceSymbol);
-            writer.write(" * @param mux The {@link Mux} that determines which service and operation are being");
-            writer.write(" *            invoked by a given {@link HttpRequest}");
-            writer.write(" * @param serializers An {@link OperationSerializer} for each operation in");
-            writer.write(" *                    $T that handles deserialization of requests", serviceSymbol);
-            writer.write(" *                    and serialization of responses");
-            writer.write(" */");
+            writer.writeDocs(() -> {
+                writer.write("Construct a $T handler.", serviceSymbol);
+                writer.write("@param service The {@link $1T} implementation that supplies the business logic for $1T",
+                        serviceSymbol);
+                writer.writeInline("@param mux The {@link Mux} that determines which service and operation are being ");
+                writer.write("invoked by a given {@link HttpRequest}");
+                writer.writeInline("@param serializerFactory A factory for an {@link OperationSerializer} for each ");
+                writer.write("operation in $T that ", serviceSymbol);
+                writer.writeInline("                         ")
+                      .write("handles deserialization of requests and serialization of responses");
+            });
             writer.openBlock("constructor(service: $1T, "
                             + "mux: Mux<$3S, $2T>, "
-                            + "serializers: Record<$2T, OperationSerializer<$1T, $2T>>) {", "}",
+                            + "serializerFactory: <T extends $2T>(op: T) => OperationSerializer<$1T, T>) {", "}",
                     serviceSymbol, operationsType, serviceShape.getId().getName(), () -> {
                 writer.write("this.service = service;");
                 writer.write("this.mux = mux;");
-                writer.write("this.serializers = serializers;");
+                writer.write("this.serializerFactory = serializerFactory;");
             });
             writer.openBlock("async handle(request: HttpRequest): Promise<HttpResponse> {", "}", () -> {
                 writer.write("const target = this.mux.match(request);");
@@ -115,8 +116,7 @@ private static void generateHandlerCase(TypeScriptWriter writer,
                                             Symbol operationSymbol) {
         String opName = operationShape.getId().getName();
         writer.openBlock("case $S : {", "}", opName, () -> {
-            writer.write("let serializer = this.serializers.$2L as OperationSerializer<$1L, $2S>;",
-                    serviceSymbol.getName(), opName);
+            writer.write("let serializer = this.serializerFactory($S);", opName);
             writer.openBlock("let input = await serializer.deserialize(request, {", "});", () -> {
                 writer.write("endpoint: () => Promise.resolve(request), ...this.serdeContextBase");
             });

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

@@ -26,6 +26,7 @@
 import java.util.Set;
 import java.util.TreeMap;
 import java.util.TreeSet;
+import java.util.function.Consumer;
 import java.util.logging.Logger;
 import java.util.stream.Collectors;
 import software.amazon.smithy.codegen.core.CodegenException;
@@ -71,7 +72,6 @@
 import software.amazon.smithy.typescript.codegen.TypeScriptWriter;
 import software.amazon.smithy.utils.ListUtils;
 import software.amazon.smithy.utils.OptionalUtils;
-import software.amazon.smithy.utils.StringUtils;
 
 /**
  * Abstract implementation useful for all protocols that use HTTP bindings.
@@ -216,23 +216,19 @@ public void generateResponseSerializers(GenerationContext context) {
         }
     }
 
-    @Override
-    public void generateMux(GenerationContext context) {
+    private void generateMux(GenerationContext context) {
         TopDownIndex topDownIndex = TopDownIndex.of(context.getModel());
         TypeScriptWriter writer = context.getWriter();
-        Set<OperationShape> containedOperations = new TreeSet<>(
-                topDownIndex.getContainedOperations(context.getService()));
 
         writer.addImport("httpbinding", null, "@aws-smithy/server-common");
 
         Symbol serviceSymbol = context.getSymbolProvider().toSymbol(context.getService());
 
-        writer.openBlock("const $L = new httpbinding.HttpBindingMux<$S, keyof $T>([", "]);",
-                getMuxName(serviceSymbol),
+        writer.openBlock("const mux = new httpbinding.HttpBindingMux<$S, keyof $T>([", "]);",
                 context.getService().getId().getName(),
                 serviceSymbol,
                 () -> {
-                    for (OperationShape operation : containedOperations) {
+                    for (OperationShape operation : topDownIndex.getContainedOperations(context.getService())) {
                         OptionalUtils.ifPresentOrElse(
                                 operation.getTrait(HttpTrait.class),
                                 httpTrait -> generateUriSpec(context, operation, httpTrait),
@@ -301,28 +297,36 @@ public void generateHandlerFactory(GenerationContext context) {
 
         Symbol serviceSymbol = symbolProvider.toSymbol(context.getService());
         Symbol handlerSymbol = serviceSymbol.expectProperty("handler", Symbol.class);
+        Symbol operationsSymbol = serviceSymbol.expectProperty("operations", Symbol.class);
 
         writer.addImport("ServiceHandler", null, "@aws-smithy/server-common");
+        writer.addImport("OperationSerializer", null, "@aws-smithy/server-common");
 
-        writer.openBlock("export const get$1L = (service: $2T): ServiceHandler => {", "}",
+        writer.openBlock("export const get$L = (service: $T): ServiceHandler => {", "}",
                 handlerSymbol.getName(), serviceSymbol, () -> {
-            writer.openBlock("return new $T(service, $L, {", "});", handlerSymbol, getMuxName(serviceSymbol), () -> {
-                operations.stream()
-                          .filter(o -> o.getTrait(HttpTrait.class).isPresent())
-                          .sorted()
-                          .forEach(operation -> {
-                    Symbol symbol = symbolProvider.toSymbol(operation);
-                    writer.openBlock("$L: {", "},", operation.getId().getName(), () -> {
-                        writer.write("serialize: $LResponse,", ProtocolGenerator.getGenericSerFunctionName(symbol));
-                        writer.write("deserialize: $LRequest,", ProtocolGenerator.getGenericDeserFunctionName(symbol));
-                    });
+            generateMux(context);
+            writer.openBlock("const serFn: (op: $1T) => OperationSerializer<$2T, $1T> = (op) => {", "};",
+                    operationsSymbol, serviceSymbol, () -> {
+                writer.openBlock("switch (op) {", "}", () -> {
+                    operations.stream()
+                            .filter(o -> o.getTrait(HttpTrait.class).isPresent())
+                            .forEach(writeOperationCase(writer, symbolProvider));
                 });
             });
+            writer.write("return new $T(service, mux, serFn);", handlerSymbol);
         });
     }
 
-    private String getMuxName(Symbol serviceSymbol) {
-        return StringUtils.uncapitalize(serviceSymbol.getName()) + "Mux";
+    private Consumer<OperationShape> writeOperationCase(TypeScriptWriter writer, SymbolProvider symbolProvider) {
+        return operation -> {
+            Symbol symbol = symbolProvider.toSymbol(operation);
+            writer.openBlock("case $S: {", "}", operation.getId().getName(), () -> {
+                writer.openBlock("return {", "};", () -> {
+                    writer.write("serialize: $LResponse,", ProtocolGenerator.getGenericSerFunctionName(symbol));
+                    writer.write("deserialize: $LRequest,", ProtocolGenerator.getGenericDeserFunctionName(symbol));
+                });
+            });
+        };
     }
 
     @Override

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

@@ -153,11 +153,6 @@ public void generateResponseSerializers(GenerationContext context) {
         LOGGER.warning("Response serialization is not currently supported for RPC protocols.");
     }
 
-    @Override
-    public void generateMux(GenerationContext context) {
-        LOGGER.warning("Router generation is not currently supported for RPC protocols.");
-    }
-
     @Override
     public void generateHandlerFactory(GenerationContext context) {
         LOGGER.warning("Handler factory generation is not currently supported for RPC protocols.");

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

@@ -148,14 +148,6 @@ default void generateSharedComponents(GenerationContext context) {
      */
     void generateResponseSerializers(GenerationContext context);
 
-    /**
-     * Generates the code used to determine the service and operation
-     * targeted by a given request.
-     *
-     * @param context Generation context.
-     */
-    void generateMux(GenerationContext context);
-
     /**
      * Generates the code used to determine the service and operation
      * targeted by a given request.