Merge pull request #289 from JordonPhillips/ssdk-exception-handling

JordonPhillips · web-flow · commit 173510563bca · 2021-03-22T18:06:18.000+01:00
ssdk modeled exception handling
diff --git a/smithy-typescript-codegen/src/main/java/software/amazon/smithy/typescript/codegen/CodegenVisitor.java b/smithy-typescript-codegen/src/main/java/software/amazon/smithy/typescript/codegen/CodegenVisitor.java
@@ -329,7 +329,9 @@ public Void serviceShape(ServiceShape shape) {
                             context.withSymbolProvider(serverSymbolProvider);
                     protocolGenerator.generateRequestDeserializers(serverContext);
                     protocolGenerator.generateResponseSerializers(serverContext);
-                    protocolGenerator.generateHandlerFactory(serverContext);
+                    writers.useShapeWriter(shape, serverSymbolProvider, w -> {
+                        protocolGenerator.generateHandlerFactory(serverContext.withWriter(w));
+                    });
                 }
                 protocolGenerator.generateSharedComponents(context);
             });
@@ -408,7 +410,8 @@ private void generateCommands(ServiceShape shape) {
 
             if (settings.generateServerSdk()) {
                 writers.useShapeWriter(operation, serverSymbolProvider, commandWriter -> new ServerCommandGenerator(
-                        settings, model, operation, serverSymbolProvider, commandWriter).run());
+                        settings, model, operation, serverSymbolProvider, commandWriter,
+                        protocolGenerator, applicationProtocol).run());
             }
         }
     }
diff --git a/smithy-typescript-codegen/src/main/java/software/amazon/smithy/typescript/codegen/ServerCommandGenerator.java b/smithy-typescript-codegen/src/main/java/software/amazon/smithy/typescript/codegen/ServerCommandGenerator.java
@@ -18,6 +18,7 @@
 import static software.amazon.smithy.typescript.codegen.CodegenUtils.getBlobStreamingMembers;
 import static software.amazon.smithy.typescript.codegen.CodegenUtils.writeStreamingMemberType;
 
+import java.util.Iterator;
 import java.util.List;
 import java.util.Optional;
 import software.amazon.smithy.codegen.core.Symbol;
@@ -26,7 +27,9 @@
 import software.amazon.smithy.model.knowledge.OperationIndex;
 import software.amazon.smithy.model.shapes.MemberShape;
 import software.amazon.smithy.model.shapes.OperationShape;
+import software.amazon.smithy.model.shapes.ShapeId;
 import software.amazon.smithy.model.shapes.StructureShape;
+import software.amazon.smithy.typescript.codegen.integration.ProtocolGenerator;
 
 /**
  * Generates server operation types.
@@ -41,29 +44,40 @@ final class ServerCommandGenerator implements Runnable {
     private final OperationIndex operationIndex;
     private final Symbol inputType;
     private final Symbol outputType;
+    private final Symbol errorsType;
+    private final ProtocolGenerator protocolGenerator;
+    private final ApplicationProtocol applicationProtocol;
 
     ServerCommandGenerator(
             TypeScriptSettings settings,
             Model model,
             OperationShape operation,
             SymbolProvider symbolProvider,
-            TypeScriptWriter writer
+            TypeScriptWriter writer,
+            ProtocolGenerator protocolGenerator,
+            ApplicationProtocol applicationProtocol
     ) {
         this.settings = settings;
         this.model = model;
         this.operation = operation;
         this.symbolProvider = symbolProvider;
         this.writer = writer;
+        this.protocolGenerator = protocolGenerator;
+        this.applicationProtocol = applicationProtocol;
 
         Symbol operationSymbol = symbolProvider.toSymbol(operation);
         operationIndex = OperationIndex.of(model);
         inputType = operationSymbol.expectProperty("inputType", Symbol.class);
         outputType = operationSymbol.expectProperty("outputType", Symbol.class);
+        errorsType = operationSymbol.expectProperty("errorsType", Symbol.class);
     }
 
     @Override
     public void run() {
+        writeOperationType();
         addInputAndOutputTypes();
+        writeErrorType();
+        writeOperationSerializer();
     }
 
     private void addInputAndOutputTypes() {
@@ -99,4 +113,93 @@ private void writeOutputType(String typeName, Optional<StructureShape> outputSha
             writer.write("export type $L = __MetadataBearer", typeName);
         }
     }
+
+    private void writeErrorType() {
+        if (operation.getErrors().isEmpty()) {
+            writer.write("export type $L = never;", errorsType.getName());
+        } else {
+            writer.writeInline("export type $L = ", errorsType.getName());
+            for (Iterator<ShapeId> iter = operation.getErrors().iterator(); iter.hasNext();) {
+                writer.writeInline("$T", symbolProvider.toSymbol(model.expectShape(iter.next())));
+                if (iter.hasNext()) {
+                    writer.writeInline(" | ");
+                }
+            }
+            writer.write("");
+        }
+        writer.write("");
+    }
+
+    private void writeOperationType() {
+        Symbol operationSymbol = symbolProvider.toSymbol(operation);
+        writer.addImport("Operation", "__Operation", "@aws-smithy/server-common");
+        writer.write("export type $L = __Operation<$T, $T>", operationSymbol.getName(), inputType, outputType);
+        writer.write("");
+    }
+
+    private void writeOperationSerializer() {
+        Symbol operationSymbol = symbolProvider.toSymbol(operation);
+        String serializerName = operationSymbol.expectProperty("serializerType", Symbol.class).getName();
+        Symbol serverSymbol = symbolProvider.toSymbol(model.expectShape(settings.getService()));
+
+        writer.addImport("OperationSerializer", null, "@aws-smithy/server-common");
+        writer.openBlock("export class $L implements OperationSerializer<$T, $S, $T> {", "}",
+                serializerName, serverSymbol, operation.getId().getName(), errorsType, () -> {
+            String serializerFunction = ProtocolGenerator.getGenericSerFunctionName(operationSymbol) + "Response";
+            String deserializerFunction = ProtocolGenerator.getGenericDeserFunctionName(operationSymbol) + "Request";
+            writer.addImport(serializerFunction, null,
+                    "./protocols/" + ProtocolGenerator.getSanitizedName(protocolGenerator.getName()));
+            writer.addImport(deserializerFunction, null,
+                    "./protocols/" + ProtocolGenerator.getSanitizedName(protocolGenerator.getName()));
+            writer.write("serialize = $L;", serializerFunction);
+            writer.write("deserialize = $L;", deserializerFunction);
+            writer.write("");
+            writeErrorChecker();
+            writeErrorHandler();
+        });
+        writer.write("");
+    }
+
+    private void writeErrorChecker() {
+        writer.openBlock("isOperationError(error: any): error is $T {", "};", errorsType, () -> {
+            if (operation.getErrors().isEmpty()) {
+                writer.write("return false;");
+            } else {
+                writer.writeInline("const names: $T['name'][] = [", errorsType);
+                for (Iterator<ShapeId> iter = operation.getErrors().iterator(); iter.hasNext();) {
+                    writer.writeInline("$S", iter.next().getName());
+                    if (iter.hasNext()) {
+                        writer.writeInline(", ");
+                    }
+                }
+                writer.write("];");
+                writer.write("return names.includes(error.name);");
+            }
+        });
+        writer.write("");
+    }
+
+    private void writeErrorHandler() {
+        writer.addImport("SerdeContext", null, "@aws-sdk/types");
+        writer.openBlock("serializeError(error: $T, ctx: Omit<SerdeContext, 'endpoint'>): Promise<$T> {", "}",
+                errorsType, applicationProtocol.getResponseType(), () -> {
+            writer.openBlock("switch (error.name) {", "}", () -> {
+                for (ShapeId errorId : operation.getErrors()) {
+                    writeErrorHandlerCase(errorId);
+                }
+                writer.openBlock("default: {", "}", () -> writer.write("throw error;"));
+            });
+        });
+        writer.write("");
+    }
+
+    private void writeErrorHandlerCase(ShapeId errorId) {
+        Symbol errorSymbol = symbolProvider.toSymbol(model.expectShape(errorId));
+        String serializerFunction = ProtocolGenerator.getGenericSerFunctionName(errorSymbol) + "Error";
+        writer.addImport(serializerFunction, null,
+                "./protocols/" + ProtocolGenerator.getSanitizedName(protocolGenerator.getName()));
+        writer.openBlock("case $S: {", "}", errorId.getName(), () -> {
+            writer.write("return $L(error, ctx);", serializerFunction);
+        });
+    }
 }
diff --git a/smithy-typescript-codegen/src/main/java/software/amazon/smithy/typescript/codegen/ServerGenerator.java b/smithy-typescript-codegen/src/main/java/software/amazon/smithy/typescript/codegen/ServerGenerator.java
@@ -57,6 +57,7 @@ static void generateServiceHandler(SymbolProvider symbolProvider,
         writer.addImport("toUtf8", null, "@aws-sdk/util-utf8-node");
         writer.addImport("HttpRequest", null, "@aws-sdk/protocol-http");
         writer.addImport("HttpResponse", null, "@aws-sdk/protocol-http");
+        writer.addImport("SmithyException", null, "@aws-sdk/smithy-client");
 
         Symbol serviceSymbol = symbolProvider.toSymbol(serviceShape);
         Symbol handlerSymbol = serviceSymbol.expectProperty("handler", Symbol.class);
@@ -65,8 +66,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 serializerFactory: <T extends $T>(operation: T) => OperationSerializer<$T, T>;",
-                    operationsType, serviceSymbol);
+            writer.write("private serializerFactory: <T extends $T>(operation: T) => "
+                            + "OperationSerializer<$T, T, SmithyException>;", operationsType, serviceSymbol);
             writer.openBlock("private serdeContextBase = {", "};", () -> {
                 writer.write("base64Encoder: toBase64,");
                 writer.write("base64Decoder: fromBase64,");
@@ -89,7 +90,8 @@ static void generateServiceHandler(SymbolProvider symbolProvider,
             });
             writer.openBlock("constructor(service: $1T, "
                             + "mux: Mux<$3S, $2T>, "
-                            + "serializerFactory: <T extends $2T>(op: T) => OperationSerializer<$1T, T>) {", "}",
+                            + "serializerFactory: <T extends $2T>(op: T) => "
+                            + "OperationSerializer<$1T, T, SmithyException>) {", "}",
                     serviceSymbol, operationsType, serviceShape.getId().getName(), () -> {
                 writer.write("this.service = service;");
                 writer.write("this.mux = mux;");
@@ -117,11 +119,19 @@ private static void generateHandlerCase(TypeScriptWriter writer,
         String opName = operationShape.getId().getName();
         writer.openBlock("case $S : {", "}", 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");
+            writer.openBlock("try {", "} catch(error: unknown) {", () -> {
+                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);", operationSymbol.getName());
+                writer.write("return serializer.serialize(output, this.serdeContextBase);");
+            });
+            writer.openBlock("", "}", () -> {
+                writer.openBlock("if (serializer.isOperationError(error)) {", "}", () -> {
+                    writer.write("return serializer.serializeError(error, this.serdeContextBase);");
+                });
+                writer.write("throw error;");
             });
-            writer.write("let output = this.service.$L(input, request);", operationSymbol.getName());
-            writer.write("return serializer.serialize(output, this.serdeContextBase);");
         });
     }
 
@@ -136,10 +146,7 @@ static void generateServerInterfaces(SymbolProvider symbolProvider,
         writer.openBlock("export interface $L {", "}", serviceInterfaceName, () -> {
             for (OperationShape operation : operations) {
                 Symbol symbol = symbolProvider.toSymbol(operation);
-                writer.write("$L: $L<$T, $T>", symbol.getName(),
-                        "__Operation",
-                        symbol.expectProperty("inputType", Symbol.class),
-                        symbol.expectProperty("outputType", Symbol.class));
+                writer.write("$L: $T", symbol.getName(), symbol);
             }
         });
     }
diff --git a/smithy-typescript-codegen/src/main/java/software/amazon/smithy/typescript/codegen/ServerSymbolVisitor.java b/smithy-typescript-codegen/src/main/java/software/amazon/smithy/typescript/codegen/ServerSymbolVisitor.java
@@ -81,6 +81,8 @@ public Symbol operationShape(OperationShape shape) {
         //TODO: these names suck but otherwise they clash with the names in models
         builder.putProperty("inputType", intermediate.toBuilder().name(shapeName + "ServerInput").build());
         builder.putProperty("outputType", intermediate.toBuilder().name(shapeName + "ServerOutput").build());
+        builder.putProperty("errorsType", intermediate.toBuilder().name(shapeName + "Errors").build());
+        builder.putProperty("serializerType", intermediate.toBuilder().name(shapeName + "Serializer").build());
         return builder.build();
     }
 
diff --git a/smithy-typescript-codegen/src/main/java/software/amazon/smithy/typescript/codegen/integration/HttpBindingProtocolGenerator.java b/smithy-typescript-codegen/src/main/java/software/amazon/smithy/typescript/codegen/integration/HttpBindingProtocolGenerator.java
@@ -299,14 +299,12 @@ public void generateHandlerFactory(GenerationContext context) {
         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$L = (service: $T): ServiceHandler => {", "}",
                 handlerSymbol.getName(), serviceSymbol, () -> {
             generateMux(context);
-            writer.openBlock("const serFn: (op: $1T) => OperationSerializer<$2T, $1T> = (op) => {", "};",
-                    operationsSymbol, serviceSymbol, () -> {
+            writer.addImport("SmithyException", "__SmithyException", "@aws-sdk/smithy-client");
+            writer.openBlock("const serFn: (op: $1T) => OperationSerializer<$2T, $1T, __SmithyException> = "
+                            + "(op) => {", "};", operationsSymbol, serviceSymbol, () -> {
                 writer.openBlock("switch (op) {", "}", () -> {
                     operations.stream()
                             .filter(o -> o.getTrait(HttpTrait.class).isPresent())
@@ -317,15 +315,13 @@ public void generateHandlerFactory(GenerationContext context) {
         });
     }
 
-    private Consumer<OperationShape> writeOperationCase(TypeScriptWriter writer, SymbolProvider symbolProvider) {
+    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));
-                });
-            });
+            Symbol symbol = symbolProvider.toSymbol(operation).expectProperty("serializerType", Symbol.class);
+            writer.write("case $S: return new $T();", operation.getId().getName(), symbol);
         };
     }
 
diff --git a/smithy-typescript-codegen/src/main/java/software/amazon/smithy/typescript/codegen/integration/ProtocolGenerator.java b/smithy-typescript-codegen/src/main/java/software/amazon/smithy/typescript/codegen/integration/ProtocolGenerator.java
@@ -303,16 +303,28 @@ public void setProtocolName(String protocolName) {
             this.protocolName = protocolName;
         }
 
-        public GenerationContext withSymbolProvider(SymbolProvider newProvider) {
+        public GenerationContext copy() {
             GenerationContext copy = new GenerationContext();
             copy.setSettings(settings);
             copy.setModel(model);
             copy.setService(service);
-            copy.setSymbolProvider(newProvider);
+            copy.setSymbolProvider(symbolProvider);
             copy.setWriter(writer);
             copy.setIntegrations(integrations);
             copy.setProtocolName(protocolName);
             return copy;
         }
+
+        public GenerationContext withSymbolProvider(SymbolProvider newProvider) {
+            GenerationContext copyContext = copy();
+            copyContext.setSymbolProvider(newProvider);
+            return copyContext;
+        }
+
+        public GenerationContext withWriter(TypeScriptWriter newWriter) {
+            GenerationContext copyContext = copy();
+            copyContext.setWriter(newWriter);
+            return copyContext;
+        }
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -329,7 +329,9 @@ public Void serviceShape(ServiceShape shape) {`
`329`	`329`	`context.withSymbolProvider(serverSymbolProvider);`
`330`	`330`	`protocolGenerator.generateRequestDeserializers(serverContext);`
`331`	`331`	`protocolGenerator.generateResponseSerializers(serverContext);`
`332`		`- protocolGenerator.generateHandlerFactory(serverContext);`
	`332`	`+ writers.useShapeWriter(shape, serverSymbolProvider, w -> {`
	`333`	`+ protocolGenerator.generateHandlerFactory(serverContext.withWriter(w));`
	`334`	`+ });`
`333`	`335`	`}`
`334`	`336`	`protocolGenerator.generateSharedComponents(context);`
`335`	`337`	`});`
`@@ -408,7 +410,8 @@ private void generateCommands(ServiceShape shape) {`
`408`	`410`
`409`	`411`	`if (settings.generateServerSdk()) {`
`410`	`412`	`writers.useShapeWriter(operation, serverSymbolProvider, commandWriter -> new ServerCommandGenerator(`
`411`		`- settings, model, operation, serverSymbolProvider, commandWriter).run());`
	`413`	`+ settings, model, operation, serverSymbolProvider, commandWriter,`
	`414`	`+ protocolGenerator, applicationProtocol).run());`
`412`	`415`	`}`
`413`	`416`	`}`
`414`	`417`	`}`
Original file line number	Diff line number	Diff line change
`@@ -81,6 +81,8 @@ public Symbol operationShape(OperationShape shape) {`
`81`	`81`	`//TODO: these names suck but otherwise they clash with the names in models`
`82`	`82`	`builder.putProperty("inputType", intermediate.toBuilder().name(shapeName + "ServerInput").build());`
`83`	`83`	`builder.putProperty("outputType", intermediate.toBuilder().name(shapeName + "ServerOutput").build());`
	`84`	`+ builder.putProperty("errorsType", intermediate.toBuilder().name(shapeName + "Errors").build());`
	`85`	`+ builder.putProperty("serializerType", intermediate.toBuilder().name(shapeName + "Serializer").build());`
`84`	`86`	`return builder.build();`
`85`	`87`	`}`
`86`	`88`