Merge pull request #281 from adamthom-amzn/symbolprovider

Introduce a server-specific symbol provider.

Author: adamthom-amzn

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

@@ -75,6 +75,7 @@ class CodegenVisitor extends ShapeVisitor.Default<Void> {
     private final ServiceShape service;
     private final FileManifest fileManifest;
     private final SymbolProvider symbolProvider;
+    private final SymbolProvider serverSymbolProvider;
     private final Model nonTraits;
     private final TypeScriptDelegator writers;
     private final List<TypeScriptIntegration> integrations = new ArrayList<>();
@@ -120,6 +121,11 @@ class CodegenVisitor extends ShapeVisitor.Default<Void> {
             resolvedProvider = integration.decorateSymbolProvider(settings, model, resolvedProvider);
         }
         symbolProvider = SymbolProvider.cache(resolvedProvider);
+        if (settings.generateServerSdk()) {
+            serverSymbolProvider = SymbolProvider.cache(new ServerSymbolVisitor(model, symbolProvider));
+        } else {
+            serverSymbolProvider = symbolProvider;
+        }
 
         // Resolve the nullable protocol generator and application protocol.
         protocolGenerator = resolveProtocolGenerator(integrations, service, settings);
@@ -199,6 +205,11 @@ void execute() {
         // Generate index for client.
         IndexGenerator.writeIndex(settings, model, symbolProvider, fileManifest, protocolGenerator);
 
+        if (settings.generateServerSdk()) {
+            // Generate index for server
+            IndexGenerator.writeServerIndex(settings, model, serverSymbolProvider, fileManifest);
+        }
+
         // Generate protocol tests IFF found in the model.
         if (protocolGenerator != null) {
             ShapeId protocol = protocolGenerator.getProtocol();
@@ -294,10 +305,6 @@ public Void serviceShape(ServiceShape shape) {
 
         if (settings.generateServerSdk()) {
             generateServiceInterface(shape);
-            writers.useFileWriter("server/index.ts", writer -> {
-                writer.write("export * from \"./interfaces\";");
-                writer.write("export * from \"./handler\";");
-            });
         }
 
         if (protocolGenerator != null) {
@@ -317,10 +324,12 @@ public Void serviceShape(ServiceShape shape) {
                     protocolGenerator.generateResponseDeserializers(context);
                 }
                 if (context.getSettings().generateServerSdk()) {
-                    protocolGenerator.generateRequestDeserializers(context);
-                    protocolGenerator.generateResponseSerializers(context);
-                    protocolGenerator.generateMux(context);
-                    protocolGenerator.generateHandlerFactory(context);
+                    ProtocolGenerator.GenerationContext serverContext =
+                            context.withSymbolProvider(serverSymbolProvider);
+                    protocolGenerator.generateRequestDeserializers(serverContext);
+                    protocolGenerator.generateResponseSerializers(serverContext);
+                    protocolGenerator.generateMux(serverContext);
+                    protocolGenerator.generateHandlerFactory(serverContext);
                 }
                 protocolGenerator.generateSharedComponents(context);
             });
@@ -378,11 +387,11 @@ private void generateClient(ServiceShape shape) {
     private void generateServiceInterface(ServiceShape shape) {
         TopDownIndex topDownIndex = TopDownIndex.of(model);
         Set<OperationShape> operations = new TreeSet<>(topDownIndex.getContainedOperations(shape));
-        writers.useFileWriter("server/interfaces.ts", interfaceWriter ->
-                ServerGenerator.generateServerInterfaces(symbolProvider, shape, operations, interfaceWriter));
-        writers.useFileWriter("server/handler.ts", interfaceWriter ->
-                ServerGenerator.generateServiceHandler(shape, operations, interfaceWriter));
-
+        writers.useShapeWriter(shape, serverSymbolProvider, writer -> {
+            ServerGenerator.generateOperationsType(serverSymbolProvider, shape, operations, writer);
+            ServerGenerator.generateServerInterfaces(serverSymbolProvider, shape, operations, writer);
+            ServerGenerator.generateServiceHandler(serverSymbolProvider, shape, operations, writer);
+        });
     }
 
     private void generateCommands(ServiceShape shape) {
@@ -391,9 +400,17 @@ private void generateCommands(ServiceShape shape) {
         Set<OperationShape> containedOperations = new TreeSet<>(topDownIndex.getContainedOperations(shape));
         for (OperationShape operation : containedOperations) {
             // Right now this only generates stubs
-            writers.useShapeWriter(operation, commandWriter -> new CommandGenerator(
-                    settings, model, operation, symbolProvider, commandWriter,
-                    runtimePlugins, protocolGenerator, applicationProtocol).run());
+            if (settings.generateClient()) {
+                writers.useShapeWriter(operation, commandWriter -> new CommandGenerator(
+                        settings, model, operation, symbolProvider, commandWriter,
+                        runtimePlugins, protocolGenerator, applicationProtocol).run());
+            }
+
+            if (settings.generateServerSdk()) {
+                writers.useShapeWriter(operation, serverSymbolProvider, commandWriter -> new CommandGenerator(
+                        settings, model, operation, serverSymbolProvider, commandWriter,
+                        runtimePlugins, protocolGenerator, applicationProtocol).run());
+            }
         }
     }
 

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

@@ -64,6 +64,26 @@ private static void writeProtocolExports(ProtocolGenerator protocolGenerator, Ty
         writer.write("export * as $L from \"./protocols/$L\";", protocolName, protocolName);
     }
 
+    static void writeServerIndex(
+            TypeScriptSettings settings,
+            Model model,
+            SymbolProvider symbolProvider,
+            FileManifest fileManifest
+    ) {
+        TypeScriptWriter writer = new TypeScriptWriter("");
+
+        ServiceShape service = settings.getService(model);
+        Symbol symbol = symbolProvider.toSymbol(service);
+
+        TopDownIndex topDownIndex = TopDownIndex.of(model);
+        Set<OperationShape> containedOperations = new TreeSet<>(topDownIndex.getContainedOperations(service));
+        for (OperationShape operation : containedOperations) {
+            writer.write("export * from \"./types/$L\";", symbolProvider.toSymbol(operation).getName());
+        }
+        writer.write("export * from \"./$L\"", symbol.getName());
+        fileManifest.writeFile("server/index.ts", writer.toString());
+    }
+
     private static void writeClientExports(
             TypeScriptSettings settings,
             Model model,

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

@@ -15,19 +15,35 @@
 
 package software.amazon.smithy.typescript.codegen;
 
-import java.util.LinkedHashSet;
+import java.util.Iterator;
 import java.util.Set;
 import software.amazon.smithy.codegen.core.Symbol;
 import software.amazon.smithy.codegen.core.SymbolProvider;
 import software.amazon.smithy.model.shapes.OperationShape;
 import software.amazon.smithy.model.shapes.ServiceShape;
-import software.amazon.smithy.utils.StringUtils;
+import software.amazon.smithy.model.shapes.Shape;
 
 final class ServerGenerator {
 
     private ServerGenerator() {}
 
-    static void generateServiceHandler(ServiceShape service,
+    static void generateOperationsType(SymbolProvider symbolProvider,
+                                       Shape serviceShape,
+                                       Set<OperationShape> operations,
+                                       TypeScriptWriter writer) {
+        Symbol serviceSymbol = symbolProvider.toSymbol(serviceShape);
+        writer.writeInline("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()) {
+                writer.writeInline(" | ");
+            }
+        }
+        writer.write(";");
+    }
+
+    static void generateServiceHandler(SymbolProvider symbolProvider,
+                                       Shape serviceShape,
                                        Set<OperationShape> operations,
                                        TypeScriptWriter writer) {
         writer.addImport("ServiceHandler", null, "@aws-smithy/server-common");
@@ -42,17 +58,15 @@ static void generateServiceHandler(ServiceShape service,
         writer.addImport("HttpRequest", null, "@aws-sdk/protocol-http");
         writer.addImport("HttpResponse", null, "@aws-sdk/protocol-http");
 
-        String serviceName = StringUtils.capitalize(service.getId().getName());
-        String operationsTypeName = serviceName + "Operations";
-
-        writer.addImport(serviceName + "Service", null, ".");
-        writer.write("type $L = keyof $L;", operationsTypeName, serviceName + "Service");
+        Symbol serviceSymbol = symbolProvider.toSymbol(serviceShape);
+        Symbol handlerSymbol = serviceSymbol.expectProperty("handler", Symbol.class);
+        Symbol operationsType = serviceSymbol.expectProperty("operations", Symbol.class);
 
-        writer.openBlock("export class $LServiceHandler implements ServiceHandler {", "}", serviceName, () -> {
-            writer.write("private service: $LService;", serviceName);
-            writer.write("private mux: Mux<$S, $L>;", serviceName, operationsTypeName);
-            writer.write("private serializers: Record<$1L, OperationSerializer<$2LService, $1L>>;",
-                    operationsTypeName, serviceName);
+        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.openBlock("private serdeContextBase = {", "};", () -> {
                 writer.write("base64Encoder: toBase64,");
                 writer.write("base64Decoder: fromBase64,");
@@ -63,19 +77,19 @@ static void generateServiceHandler(ServiceShape service,
                 writer.write("disableHostPrefix: true");
             });
             writer.write("/**");
-            writer.write(" * Construct a $LService handler.", serviceName);
-            writer.write(" * @param service The {@link $LService} implementation that supplies", serviceName);
-            writer.write(" *                the business logic for $LService", serviceName);
+            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(" *                    $LService that handles deserialization of requests and", serviceName);
-            writer.write(" *                    serialization of responses");
+            writer.write(" *                    $T that handles deserialization of requests", serviceSymbol);
+            writer.write(" *                    and serialization of responses");
             writer.write(" */");
-            writer.openBlock("constructor(service: $1LService, "
-                            + "mux: Mux<$1S, $2L>, "
-                            + "serializers: Record<$2L, OperationSerializer<$1LService, $2L>>) {", "}",
-                    serviceName, operationsTypeName, () -> {
+            writer.openBlock("constructor(service: $1T, "
+                            + "mux: Mux<$3S, $2T>, "
+                            + "serializers: Record<$2T, OperationSerializer<$1T, $2T>>) {", "}",
+                    serviceSymbol, operationsType, serviceShape.getId().getName(), () -> {
                 writer.write("this.service = service;");
                 writer.write("this.mux = mux;");
                 writer.write("this.serializers = serializers;");
@@ -88,22 +102,25 @@ static void generateServiceHandler(ServiceShape service,
                 });
                 writer.openBlock("switch (target.operation) {", "}", () -> {
                     for (OperationShape operation : operations) {
-                        generateHandlerCase(writer, serviceName, operation);
+                        generateHandlerCase(writer, serviceSymbol, operation, symbolProvider.toSymbol(operation));
                     }
                 });
             });
         });
     }
 
-    private static void generateHandlerCase(TypeScriptWriter writer, String serviceName, OperationShape operation) {
-        String opName = operation.getId().getName();
+    private static void generateHandlerCase(TypeScriptWriter writer,
+                                            Symbol serviceSymbol,
+                                            Shape operationShape,
+                                            Symbol operationSymbol) {
+        String opName = operationShape.getId().getName();
         writer.openBlock("case $S : {", "}", opName, () -> {
-            writer.write("let serializer = this.serializers.$1L as OperationSerializer<$2LService, $1S>;",
-                    opName, serviceName);
+            writer.write("let serializer = this.serializers.$2L as OperationSerializer<$1L, $2S>;",
+                    serviceSymbol.getName(), opName);
             writer.openBlock("let input = await serializer.deserialize(request, {", "});", () -> {
                 writer.write("endpoint: () => Promise.resolve(request), ...this.serdeContextBase");
             });
-            writer.write("let output = this.service.$L(input, request);", opName);
+            writer.write("let output = this.service.$L(input, request);", operationSymbol.getName());
             writer.write("return serializer.serialize(output, this.serdeContextBase);");
         });
     }
@@ -114,41 +131,16 @@ static void generateServerInterfaces(SymbolProvider symbolProvider,
                                          TypeScriptWriter writer) {
         writer.addImport("Operation", "__Operation", "@aws-smithy/server-common");
 
-        String serviceInterfaceName = StringUtils.capitalize(service.getId().getName()) + "Service";
+        String serviceInterfaceName = symbolProvider.toSymbol(service).getName();
 
         writer.openBlock("export interface $L {", "}", serviceInterfaceName, () -> {
             for (OperationShape operation : operations) {
                 Symbol symbol = symbolProvider.toSymbol(operation);
-                writer.write("$L: $L<$T, $T>", StringUtils.capitalize(operation.getId().getName()),
+                writer.write("$L: $L<$T, $T>", symbol.getName(),
                         "__Operation",
                         symbol.expectProperty("inputType", Symbol.class),
                         symbol.expectProperty("outputType", Symbol.class));
             }
         });
-
-        writer.addImport("ParsedRequest", "__ParsedRequest", "@aws-smithy/server-common");
-        writer.addImport("PreparedResponse", "__PreparedResponse", "@aws-smithy/server-common");
-
-        Set<String> requestInterfaces = new LinkedHashSet<>();
-        Set<String> responseInterfaces = new LinkedHashSet<>();
-        for (OperationShape operation : operations) {
-            String opName = StringUtils.capitalize(operation.getId().getName());
-            String requestInterfaceName = "Parsed" + opName + "Request";
-            String responseInterfaceName = "Prepared" + opName + "Response";
-
-            writer.write("export interface $L extends $L<$L, $S> {}",
-                    requestInterfaceName, "__ParsedRequest", serviceInterfaceName, opName);
-            writer.write("export interface $L extends $L<$L, $S> {}",
-                    responseInterfaceName, "__PreparedResponse", serviceInterfaceName, opName);
-
-            requestInterfaces.add(requestInterfaceName);
-            responseInterfaces.add(responseInterfaceName);
-        }
-
-        writer.write("export type $LRequests = $L;",
-                serviceInterfaceName, String.join(" | ", requestInterfaces));
-
-        writer.write("export type $LResponses = $L;",
-                serviceInterfaceName, String.join(" | ", responseInterfaces));
     }
 }