Merge pull request #315 from JordonPhillips/merge-ssdk

Merge ssdk into main

Author: JordonPhillips

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

@@ -17,9 +17,15 @@
 
 import java.util.ArrayList;
 import java.util.List;
+import java.util.stream.Collectors;
+import software.amazon.smithy.codegen.core.Symbol;
 import software.amazon.smithy.model.Model;
 import software.amazon.smithy.model.knowledge.EventStreamIndex;
+import software.amazon.smithy.model.shapes.MemberShape;
 import software.amazon.smithy.model.shapes.OperationShape;
+import software.amazon.smithy.model.shapes.Shape;
+import software.amazon.smithy.model.shapes.StructureShape;
+import software.amazon.smithy.model.traits.StreamingTrait;
 
 /**
  * Utility methods needed across Java packages.
@@ -91,4 +97,39 @@ private static List<String> getDefaultOperationSerdeContextTypes(TypeScriptWrite
         contextInterfaceList.add("__SerdeContext");
         return contextInterfaceList;
     }
+
+    static List<MemberShape> getBlobStreamingMembers(Model model, StructureShape shape) {
+        return shape.getAllMembers().values().stream()
+                .filter(memberShape -> {
+                    // Streaming blobs need to have their types modified
+                    // See `writeStreamingMemberType`
+                    Shape target = model.expectShape(memberShape.getTarget());
+                    return target.isBlobShape() && target.hasTrait(StreamingTrait.class);
+                })
+                .collect(Collectors.toList());
+    }
+
+    /**
+     * Ease the input streaming member restriction so that users don't need to construct a stream every time.
+     * This type decoration is allowed in Smithy because it makes input type more permissive than output type
+     * for the same member.
+     * Refer here for more rationales: https://github.com/aws/aws-sdk-js-v3/issues/843
+     */
+    static void writeStreamingMemberType(
+            TypeScriptWriter writer,
+            Symbol containerSymbol,
+            String typeName,
+            MemberShape streamingMember
+    ) {
+        String memberName = streamingMember.getMemberName();
+        String optionalSuffix = streamingMember.isRequired() ? "" : "?";
+        writer.openBlock("type $LType = Omit<$T, $S> & {", "};", typeName, containerSymbol, memberName, () -> {
+            writer.writeDocs(String.format("For *`%1$s[\"%2$s\"]`*, see {@link %1$s.%2$s}.",
+                    containerSymbol.getName(), memberName));
+            writer.write("$1L$2L: $3T[$1S]|string|Uint8Array|Buffer;", memberName, optionalSuffix, containerSymbol);
+        });
+        writer.writeDocs(String.format("This interface extends from `%1$s` interface. There are more parameters than"
+                + " `%2$s` defined in {@link %1$s}", containerSymbol.getName(), memberName));
+        writer.write("export interface $1L extends $1LType {}", typeName);
+    }
 }

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

@@ -70,6 +70,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<>();
@@ -107,14 +108,20 @@ class CodegenVisitor extends ShapeVisitor.Default<Void> {
         nonTraits = context.getModelWithoutTraitShapes();
         service = settings.getService(model);
         fileManifest = context.getFileManifest();
-        LOGGER.info(() -> "Generating TypeScript client for service " + service.getId());
+        LOGGER.info(() -> String.format("Generating TypeScript %s for service %s",
+                settings.generateClient() ? "client" : "server", service.getId()));
 
         // Decorate the symbol provider using integrations.
         SymbolProvider resolvedProvider = TypeScriptCodegenPlugin.createSymbolProvider(model, settings);
         for (TypeScriptIntegration integration : integrations) {
             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);
@@ -175,11 +182,15 @@ void execute() {
         // Generate the client Node and Browser configuration files. These
         // files are switched between in package.json based on the targeted
         // environment.
-        RuntimeConfigGenerator configGenerator = new RuntimeConfigGenerator(
-                settings, model, symbolProvider, writers, integrations);
-        for (LanguageTarget target : LanguageTarget.values()) {
-            LOGGER.fine("Generating " + target + " runtime configuration");
-            configGenerator.generate(target);
+        if (settings.generateClient()) {
+            // For now these are only generated for clients.
+            // TODO: generate ssdk config
+            RuntimeConfigGenerator configGenerator = new RuntimeConfigGenerator(
+                    settings, model, symbolProvider, writers, integrations);
+            for (LanguageTarget target : LanguageTarget.values()) {
+                LOGGER.fine("Generating " + target + " runtime configuration");
+                configGenerator.generate(target);
+            }
         }
 
         // Write each custom file.
@@ -189,12 +200,18 @@ void execute() {
         }
 
         // Generate index for client.
-        IndexGenerator.writeIndex(settings, model, symbolProvider, fileManifest, integrations);
+        IndexGenerator.writeIndex(settings, model, symbolProvider, fileManifest, integrations, 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();
-            new HttpProtocolTestGenerator(settings, model, protocol, symbolProvider, writers).run();
+            new HttpProtocolTestGenerator(
+                    settings, model, protocol, symbolProvider, serverSymbolProvider, writers, protocolGenerator).run();
         }
 
         // Write each pending writer.
@@ -270,13 +287,74 @@ public Void stringShape(StringShape shape) {
         return null;
     }
 
+    @Override
+    public Void operationShape(OperationShape operation) {
+        if (settings.generateServerSdk()) {
+            writers.useShapeWriter(operation, serverSymbolProvider, w -> {
+                ServerGenerator.generateOperationHandler(serverSymbolProvider, service, operation, w);
+            });
+        }
+        return null;
+    }
+
     @Override
     public Void serviceShape(ServiceShape shape) {
         if (!Objects.equals(service, shape)) {
             LOGGER.fine(() -> "Skipping `" + shape.getId() + "` because it is not `" + service.getId() + "`");
             return null;
         }
 
+        if (settings.generateClient()) {
+            generateClient(shape);
+        }
+        if (settings.generateClient() || settings.generateServerSdk()) {
+            generateCommands(shape);
+        }
+
+        if (settings.generateServerSdk()) {
+            generateServiceInterface(shape);
+            generateServerErrors(shape);
+        }
+
+        if (protocolGenerator != null) {
+            LOGGER.info("Generating serde for protocol " + protocolGenerator.getName() + " on " + shape.getId());
+            String fileName = "protocols/" + ProtocolGenerator.getSanitizedName(protocolGenerator.getName()) + ".ts";
+            writers.useFileWriter(fileName, writer -> {
+                ProtocolGenerator.GenerationContext context = new ProtocolGenerator.GenerationContext();
+                context.setProtocolName(protocolGenerator.getName());
+                context.setIntegrations(integrations);
+                context.setModel(model);
+                context.setService(shape);
+                context.setSettings(settings);
+                context.setSymbolProvider(symbolProvider);
+                context.setWriter(writer);
+                if (context.getSettings().generateClient()) {
+                    protocolGenerator.generateRequestSerializers(context);
+                    protocolGenerator.generateResponseDeserializers(context);
+                }
+                if (context.getSettings().generateServerSdk()) {
+                    ProtocolGenerator.GenerationContext serverContext =
+                            context.withSymbolProvider(serverSymbolProvider);
+                    protocolGenerator.generateRequestDeserializers(serverContext);
+                    protocolGenerator.generateResponseSerializers(serverContext);
+                    protocolGenerator.generateFrameworkErrorSerializer(serverContext);
+                    writers.useShapeWriter(shape, serverSymbolProvider, w -> {
+                        protocolGenerator.generateServiceHandlerFactory(serverContext.withWriter(w));
+                    });
+                    for (OperationShape operation: TopDownIndex.of(model).getContainedOperations(service)) {
+                        writers.useShapeWriter(operation, serverSymbolProvider, w -> {
+                            protocolGenerator.generateOperationHandlerFactory(serverContext.withWriter(w), operation);
+                        });
+                    }
+                }
+                protocolGenerator.generateSharedComponents(context);
+            });
+        }
+
+        return null;
+    }
+
+    private void generateClient(ServiceShape shape) {
         // Generate the modular service client.
         writers.useShapeWriter(shape, writer -> new ServiceGenerator(
                 settings, model, symbolProvider, writer, integrations, runtimePlugins, applicationProtocol).run());
@@ -294,9 +372,6 @@ public Void serviceShape(ServiceShape shape) {
         boolean hasPaginatedOperation = false;
 
         for (OperationShape operation : containedOperations) {
-            writers.useShapeWriter(operation, commandWriter -> new CommandGenerator(
-                    settings, model, operation, symbolProvider, commandWriter,
-                    runtimePlugins, protocolGenerator, applicationProtocol).run());
             if (operation.hasTrait(PaginatedTrait.ID)) {
                 hasPaginatedOperation = true;
                 String outputFilename = PaginationGenerator.getOutputFilelocation(operation);
@@ -323,25 +398,48 @@ public Void serviceShape(ServiceShape shape) {
                             serviceSymbol,
                             paginationWriter));
         }
+    }
 
-        if (protocolGenerator != null) {
-            LOGGER.info("Generating serde for protocol " + protocolGenerator.getName() + " on " + shape.getId());
-            String fileName = "protocols/" + ProtocolGenerator.getSanitizedName(protocolGenerator.getName()) + ".ts";
-            writers.useFileWriter(fileName, writer -> {
-                ProtocolGenerator.GenerationContext context = new ProtocolGenerator.GenerationContext();
-                context.setProtocolName(protocolGenerator.getName());
-                context.setIntegrations(integrations);
-                context.setModel(model);
-                context.setService(shape);
-                context.setSettings(settings);
-                context.setSymbolProvider(symbolProvider);
-                context.setWriter(writer);
-                protocolGenerator.generateRequestSerializers(context);
-                protocolGenerator.generateResponseDeserializers(context);
-                protocolGenerator.generateSharedComponents(context);
-            });
-        }
+    private void generateServiceInterface(ServiceShape shape) {
+        TopDownIndex topDownIndex = TopDownIndex.of(model);
+        Set<OperationShape> operations = new TreeSet<>(topDownIndex.getContainedOperations(shape));
+        writers.useShapeWriter(shape, serverSymbolProvider, writer -> {
+            ServerGenerator.generateOperationsType(serverSymbolProvider, shape, operations, writer);
+            ServerGenerator.generateServerInterfaces(serverSymbolProvider, shape, operations, writer);
+            ServerGenerator.generateServiceHandler(serverSymbolProvider, shape, operations, writer);
+        });
+    }
 
-        return null;
+    private void generateServerErrors(ServiceShape service) {
+        TopDownIndex.of(model)
+                .getContainedOperations(service)
+                .stream()
+                .flatMap(o -> o.getErrors().stream())
+                .distinct()
+                .map(id -> model.expectShape(id).asStructureShape().orElseThrow(IllegalArgumentException::new))
+                .sorted()
+                .forEachOrdered(error -> writers.useShapeWriter(service, serverSymbolProvider, writer -> {
+                    new ServerErrorGenerator(settings, model, error, serverSymbolProvider, writer).run();
+                }));
+    }
+
+    private void generateCommands(ServiceShape shape) {
+        // Generate each operation for the service.
+        TopDownIndex topDownIndex = TopDownIndex.of(model);
+        Set<OperationShape> containedOperations = new TreeSet<>(topDownIndex.getContainedOperations(shape));
+        for (OperationShape operation : containedOperations) {
+            // Right now this only generates stubs
+            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 ServerCommandGenerator(
+                        settings, model, operation, serverSymbolProvider, commandWriter,
+                        protocolGenerator, applicationProtocol).run());
+            }
+        }
     }
 }

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

@@ -15,6 +15,9 @@
 
 package software.amazon.smithy.typescript.codegen;
 
+import static software.amazon.smithy.typescript.codegen.CodegenUtils.getBlobStreamingMembers;
+import static software.amazon.smithy.typescript.codegen.CodegenUtils.writeStreamingMemberType;
+
 import java.util.List;
 import java.util.Optional;
 import java.util.stream.Collectors;
@@ -25,9 +28,7 @@
 import software.amazon.smithy.model.shapes.MemberShape;
 import software.amazon.smithy.model.shapes.OperationShape;
 import software.amazon.smithy.model.shapes.ServiceShape;
-import software.amazon.smithy.model.shapes.Shape;
 import software.amazon.smithy.model.shapes.StructureShape;
-import software.amazon.smithy.model.traits.StreamingTrait;
 import software.amazon.smithy.typescript.codegen.integration.ProtocolGenerator;
 import software.amazon.smithy.typescript.codegen.integration.RuntimeClientPlugin;
 import software.amazon.smithy.utils.OptionalUtils;
@@ -85,6 +86,11 @@ final class CommandGenerator implements Runnable {
 
     @Override
     public void run() {
+        addInputAndOutputTypes();
+        generateClientCommand();
+    }
+
+    private void generateClientCommand() {
         Symbol serviceSymbol = symbolProvider.toSymbol(service);
         String configType = ServiceGenerator.getResolvedConfigTypeName(serviceSymbol);
 
@@ -98,8 +104,6 @@ public void run() {
         writer.addImport("HandlerExecutionContext", "HandlerExecutionContext", "@aws-sdk/types");
         writer.addImport("MiddlewareStack", "MiddlewareStack", "@aws-sdk/types");
 
-        addInputAndOutputTypes();
-
         String name = symbol.getName();
         writer.writeShapeDocs(operation);
         writer.openBlock("export class $L extends $$Command<$T, $T, $L> {", "}", name, inputType, outputType,
@@ -190,11 +194,11 @@ private void addInputAndOutputTypes() {
     private void writeInputType(String typeName, Optional<StructureShape> inputShape) {
         if (inputShape.isPresent()) {
             StructureShape input = inputShape.get();
-            List<MemberShape> blobStreamingMembers = getBlobStreamingMembers(input);
+            List<MemberShape> blobStreamingMembers = getBlobStreamingMembers(model, input);
             if (blobStreamingMembers.isEmpty()) {
                 writer.write("export interface $L extends $T {}", typeName, symbolProvider.toSymbol(input));
             } else {
-                writeStreamingInputType(typeName, input, blobStreamingMembers.get(0));
+                writeStreamingMemberType(writer, symbolProvider.toSymbol(input), typeName, blobStreamingMembers.get(0));
             }
         } else {
             // If the input is non-existent, then use an empty object.
@@ -214,37 +218,6 @@ private void writeOutputType(String typeName, Optional<StructureShape> outputSha
         }
     }
 
-    private List<MemberShape> getBlobStreamingMembers(StructureShape shape) {
-        return shape.getAllMembers().values().stream()
-                .filter(memberShape -> {
-                    // Streaming blobs need to have their types modified
-                    // See `writeStreamingInputType`
-                    Shape target = model.expectShape(memberShape.getTarget());
-                    return target.isBlobShape() && target.hasTrait(StreamingTrait.class);
-                })
-                .collect(Collectors.toList());
-    }
-
-    /**
-     * Ease the input streaming member restriction so that users don't need to construct a stream every time.
-     * This type decoration is allowed in Smithy because it makes input type more permissive than output type
-     * for the same member.
-     * Refer here for more rationales: https://github.com/aws/aws-sdk-js-v3/issues/843
-     */
-    private void writeStreamingInputType(String typeName, StructureShape inputShape, MemberShape streamingMember) {
-        Symbol inputSymbol = symbolProvider.toSymbol(inputShape);
-        String memberName = streamingMember.getMemberName();
-        String optionalSuffix = streamingMember.isRequired() ? "" : "?";
-        writer.openBlock("type $LType = Omit<$T, $S> & {", "};", typeName, inputSymbol, memberName, () -> {
-            writer.writeDocs(String.format("For *`%1$s[\"%2$s\"]`*, see {@link %1$s.%2$s}.",
-                    inputSymbol.getName(), memberName));
-            writer.write("$1L$2L: $3T[$1S]|string|Uint8Array|Buffer;", memberName, optionalSuffix, inputSymbol);
-        });
-        writer.writeDocs(String.format("This interface extends from `%1$s` interface. There are more parameters than"
-                + " `%2$s` defined in {@link %1$s}", inputSymbol.getName(), memberName));
-        writer.write("export interface $1L extends $1LType {}", typeName);
-    }
-
     private void addCommandSpecificPlugins() {
         // Some plugins might only apply to specific commands. They are added to the
         // command's middleware stack here. Plugins that apply to all commands are