Generate validation methods for types

When server generation is enabled, type generation includes a validate method,
aka the low-level validation API, which will enable input validation in the
SSDK.

Author: adamthom-amzn

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

@@ -259,7 +259,8 @@ protected Void getDefault(Shape shape) {
      */
     @Override
     public Void structureShape(StructureShape shape) {
-        writers.useShapeWriter(shape, writer -> new StructureGenerator(model, symbolProvider, writer, shape).run());
+        writers.useShapeWriter(shape, writer ->
+                new StructureGenerator(model, symbolProvider, writer, shape, settings.generateServerSdk()).run());
         return null;
     }
 
@@ -271,7 +272,8 @@ public Void structureShape(StructureShape shape) {
      */
     @Override
     public Void unionShape(UnionShape shape) {
-        writers.useShapeWriter(shape, writer -> new UnionGenerator(model, symbolProvider, writer, shape).run());
+        writers.useShapeWriter(shape, writer ->
+                new UnionGenerator(model, symbolProvider, writer, shape, settings.generateServerSdk()).run());
         return null;
     }
 

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

@@ -36,12 +36,25 @@ final class StructureGenerator implements Runnable {
     private final SymbolProvider symbolProvider;
     private final TypeScriptWriter writer;
     private final StructureShape shape;
+    private final boolean includeValidation;
 
+    /**
+     * sets 'includeValidation' to 'false' for backwards compatibility.
+     */
     StructureGenerator(Model model, SymbolProvider symbolProvider, TypeScriptWriter writer, StructureShape shape) {
+        this(model, symbolProvider, writer, shape, false);
+    }
+
+    StructureGenerator(Model model,
+                       SymbolProvider symbolProvider,
+                       TypeScriptWriter writer,
+                       StructureShape shape,
+                       boolean includeValidation) {
         this.model = model;
         this.symbolProvider = symbolProvider;
         this.writer = writer;
         this.shape = shape;
+        this.includeValidation = includeValidation;
     }
 
     @Override
@@ -64,6 +77,7 @@ public void run() {
      * structure Person {
      *     @required
      *     name: String,
+     *     @range(min: 1)
      *     age: Integer,
      * }
      * }</pre>
@@ -80,6 +94,22 @@ public void run() {
      *   export const filterSensitiveLog = (obj: Person): any => ({...obj});
      * }
      * }</pre>
+     *
+     * <p>If validation is enabled, it generates the following:
+     *
+     * <pre>{@code
+     * export interface Person {
+     *   name: string | undefined;
+     *   age?: number | null;
+     * }
+     *
+     * export namespace Person {
+     *   export const filterSensitiveLog = (obj: Person): any => ({...obj});
+     *   export const validate = (obj: Person): ValidationFailure[] => {
+     *       // validation
+     *   }
+     * }
+     * }</pre>
      */
     private void renderNonErrorStructure() {
         Symbol symbol = symbolProvider.toSymbol(shape);
@@ -102,7 +132,7 @@ private void renderNonErrorStructure() {
         config.writeMembers(writer, shape);
         writer.closeBlock("}");
         writer.write("");
-        renderStructureNamespace();
+        renderStructureNamespace(config, includeValidation);
     }
 
     /**
@@ -162,21 +192,33 @@ private void renderErrorStructure() {
         structuredMemberWriter.writeMembers(writer, shape);
         writer.closeBlock("}"); // interface
         writer.write("");
-        renderStructureNamespace();
+        renderStructureNamespace(structuredMemberWriter, false);
     }
 
-    private void renderStructureNamespace() {
+    private void renderStructureNamespace(StructuredMemberWriter structuredMemberWriter, boolean includeValidation) {
         Symbol symbol = symbolProvider.toSymbol(shape);
         writer.openBlock("export namespace $L {", "}", symbol.getName(), () -> {
             String objectParam = "obj";
             writer.openBlock("export const filterSensitiveLog = ($L: $L): any => ({", "})",
                 objectParam, symbol.getName(),
                 () -> {
-                    StructuredMemberWriter structuredMemberWriter = new StructuredMemberWriter(
-                        model, symbolProvider, shape.getAllMembers().values());
                     structuredMemberWriter.writeFilterSensitiveLog(writer, objectParam);
                 }
             );
+
+            if (!includeValidation) {
+                return;
+            }
+
+            structuredMemberWriter.writeMemberValidators(writer);
+
+            writer.addImport("ValidationFailure", "__ValidationFailure", "@aws-smithy/server-common");
+            writer.openBlock("export const validate = ($L: $L): __ValidationFailure[] => {", "}",
+                    objectParam, symbol.getName(),
+                    () -> {
+                        structuredMemberWriter.writeValidate(writer, objectParam);
+                    }
+            );
         });
     }
 }

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

@@ -15,22 +15,34 @@
 
 package software.amazon.smithy.typescript.codegen;
 
+import java.util.ArrayList;
 import java.util.Collection;
 import java.util.HashSet;
 import java.util.LinkedHashSet;
+import java.util.List;
 import java.util.Set;
 import software.amazon.smithy.codegen.core.CodegenException;
+import software.amazon.smithy.codegen.core.Symbol;
 import software.amazon.smithy.codegen.core.SymbolProvider;
 import software.amazon.smithy.model.Model;
 import software.amazon.smithy.model.shapes.CollectionShape;
 import software.amazon.smithy.model.shapes.MapShape;
 import software.amazon.smithy.model.shapes.MemberShape;
 import software.amazon.smithy.model.shapes.Shape;
+import software.amazon.smithy.model.shapes.ShapeId;
 import software.amazon.smithy.model.shapes.SimpleShape;
+import software.amazon.smithy.model.shapes.StringShape;
 import software.amazon.smithy.model.shapes.StructureShape;
+import software.amazon.smithy.model.traits.EnumTrait;
 import software.amazon.smithy.model.traits.IdempotencyTokenTrait;
+import software.amazon.smithy.model.traits.LengthTrait;
+import software.amazon.smithy.model.traits.PatternTrait;
+import software.amazon.smithy.model.traits.RangeTrait;
+import software.amazon.smithy.model.traits.RequiredTrait;
 import software.amazon.smithy.model.traits.SensitiveTrait;
 import software.amazon.smithy.model.traits.StreamingTrait;
+import software.amazon.smithy.model.traits.Trait;
+import software.amazon.smithy.model.traits.UniqueItemsTrait;
 import software.amazon.smithy.utils.SmithyInternalApi;
 
 /**
@@ -266,4 +278,153 @@ private String getSanitizedMemberName(MemberShape member) {
     private boolean isRequiredMember(MemberShape member) {
         return member.isRequired() && !member.hasTrait(IdempotencyTokenTrait.class);
     }
+
+    /**
+     * Writes a const map of member validators into the namespace for use by the validate method.
+     *
+     * @param writer the writer for the type, currently positioned in the type's exported namespace
+     */
+    void writeMemberValidators(TypeScriptWriter writer) {
+        writer.openBlock("const memberValidators = {", "};", () -> {
+            for (MemberShape member : members) {
+                final Shape targetShape = model.expectShape(member.getTarget());
+                Collection<Trait> constraintTraits = getConstraintTraits(member);
+                writer.writeInline("$L: ", getSanitizedMemberName(member));
+                writeShapeValidator(writer, targetShape, constraintTraits);
+            }
+        });
+    }
+
+    private void writeShapeValidator(TypeScriptWriter writer, Shape shape, Collection<Trait> constraintTraits) {
+        if (shape.isStructureShape() || shape.isUnionShape()) {
+            writer.addImport("CompositeStructureValidator",
+                    "__CompositeStructureValidator",
+                    "@aws-smithy/server-common");
+            writer.openBlock("new __CompositeStructureValidator<$T>(", "),",
+                symbolProvider.toSymbol(shape),
+                () -> {
+                    writeCompositeValidator(writer, shape, constraintTraits);
+                    writer.write("$T.validate,", symbolProvider.toSymbol(shape));
+                }
+            );
+        } else if (shape.isListShape() || shape.isSetShape()) {
+            writer.addImport("CompositeCollectionValidator",
+                    "__CompositeCollectionValidator",
+                    "@aws-smithy/server-common");
+            MemberShape collectionMemberShape = ((CollectionShape) shape).getMember();
+            Shape collectionMemberTargetShape = model.expectShape(collectionMemberShape.getTarget());
+            writer.openBlock("new __CompositeCollectionValidator<$T>(", "),",
+                    symbolProvider.toSymbol(collectionMemberTargetShape),
+                    () -> {
+                        writeCompositeValidator(writer, shape, constraintTraits);
+                        writeShapeValidator(writer,
+                                            collectionMemberTargetShape,
+                                            getConstraintTraits(collectionMemberShape));
+                    });
+        } else if (shape.isMapShape()) {
+            writer.addImport("CompositeMapValidator",
+                    "__CompositeMapValidator",
+                    "@aws-smithy/server-common");
+            MapShape mapShape = (MapShape) shape;
+            final MemberShape keyShape = mapShape.getKey();
+            final MemberShape valueShape = mapShape.getValue();
+            writer.openBlock("new __CompositeMapValidator<$T>(", "),",
+                    symbolProvider.toSymbol(model.expectShape(valueShape.getTarget())),
+                    () -> {
+                        writeCompositeValidator(writer, mapShape, constraintTraits);
+                        writeShapeValidator(writer,
+                                            model.expectShape(keyShape.getTarget()),
+                                            getConstraintTraits(keyShape));
+                        writeShapeValidator(writer,
+                                            model.expectShape(valueShape.getTarget()),
+                                            getConstraintTraits(valueShape));
+                    });
+        } else if (shape instanceof SimpleShape) {
+            writeCompositeValidator(writer, shape, constraintTraits);
+        } else {
+            throw new IllegalArgumentException(
+                    String.format("Unsupported shape found when generating validator: %s", shape));
+        }
+    }
+
+    private void writeCompositeValidator(TypeScriptWriter writer,
+                                         Shape shape,
+                                         Collection<Trait> constraints) {
+        if (constraints.isEmpty()) {
+            writer.addImport("NoOpValidator", "__NoOpValidator", "@aws-smithy/server-common");
+            writer.write("new __NoOpValidator(),");
+            return;
+        }
+        writer.addImport("CompositeValidator",
+                "__CompositeValidator",
+                "@aws-smithy/server-common");
+
+        Symbol symbol;
+        if (shape instanceof StringShape) {
+            // Don't let the TypeScript type for an enum narrow our validator's type too much
+            symbol = symbolProvider.toSymbol(model.expectShape(ShapeId.from("smithy.api#String")));
+        } else {
+            symbol = symbolProvider.toSymbol(shape);
+        }
+
+        writer.openBlock("new __CompositeValidator<$T>([", "]),", symbol,
+            () -> {
+                for (Trait t : constraints) {
+                    writeValidator(writer, t);
+                }
+            }
+        );
+    }
+
+    void writeValidate(TypeScriptWriter writer, String param) {
+        writer.openBlock("return [", "];", () -> {
+            for (MemberShape member : members) {
+                writer.write("...memberValidators.$1L.validate($2L.$1L, $3S),",
+                        getSanitizedMemberName(member), param, member.getMemberName());
+            }
+        });
+    }
+
+    private void writeValidator(TypeScriptWriter writer, Trait trait) {
+        if (trait instanceof RequiredTrait) {
+            writer.addImport("RequiredValidator", "__RequiredValidator", "@aws-smithy/server-common");
+            writer.write("new __RequiredValidator(),");
+        } else if (trait instanceof EnumTrait) {
+            writer.addImport("EnumValidator", "__EnumValidator", "@aws-smithy/server-common");
+            writer.openBlock("new __EnumValidator([", "]),", () -> {
+                for (String e : ((EnumTrait) trait).getEnumDefinitionValues()) {
+                    writer.write("$S,", e);
+                }
+            });
+        } else if (trait instanceof LengthTrait) {
+            LengthTrait lengthTrait = (LengthTrait) trait;
+            writer.addImport("LengthValidator", "__LengthValidator", "@aws-smithy/server-common");
+            writer.write("new __LengthValidator($L, $L),",
+                    lengthTrait.getMin().map(Object::toString).orElse("undefined"),
+                    lengthTrait.getMax().map(Object::toString).orElse("undefined"));
+        } else if (trait instanceof PatternTrait) {
+            writer.addImport("PatternValidator", "__PatternValidator", "@aws-smithy/server-common");
+            writer.write("new __PatternValidator($S),", ((PatternTrait) trait).getValue());
+        } else if (trait instanceof RangeTrait) {
+            RangeTrait rangeTrait = (RangeTrait) trait;
+            writer.addImport("RangeValidator", "__RangeValidator", "@aws-smithy/server-common");
+            writer.write("new __RangeValidator($L, $L),",
+                    rangeTrait.getMin().map(Object::toString).orElse("undefined"),
+                    rangeTrait.getMax().map(Object::toString).orElse("undefined"));
+        } else if (trait instanceof UniqueItemsTrait) {
+            writer.addImport("UniqueItemsValidator", "__UniqueItemsValidator", "@aws-smithy/server-common");
+            writer.write("new __UniqueItemsValidator(),");
+        }
+    }
+
+    private Collection<Trait> getConstraintTraits(MemberShape member) {
+        List<Trait> traits = new ArrayList<>();
+        member.getTrait(RequiredTrait.class).ifPresent(traits::add);
+        member.getMemberTrait(model, EnumTrait.class).ifPresent(traits::add);
+        member.getMemberTrait(model, LengthTrait.class).ifPresent(traits::add);
+        member.getMemberTrait(model, PatternTrait.class).ifPresent(traits::add);
+        member.getMemberTrait(model, RangeTrait.class).ifPresent(traits::add);
+        member.getMemberTrait(model, UniqueItemsTrait.class).ifPresent(traits::add);
+        return traits;
+    }
 }

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

@@ -132,13 +132,26 @@ final class UnionGenerator implements Runnable {
     private final Symbol symbol;
     private final UnionShape shape;
     private final Map<String, String> variantMap;
+    private final boolean includeValidation;
 
+    /**
+     * sets 'includeValidation' to 'false' for backwards compatibility.
+     */
     UnionGenerator(Model model, SymbolProvider symbolProvider, TypeScriptWriter writer, UnionShape shape) {
+        this(model, symbolProvider, writer, shape, false);
+    }
+
+    UnionGenerator(Model model,
+                   SymbolProvider symbolProvider,
+                   TypeScriptWriter writer,
+                   UnionShape shape,
+                   boolean includeValidation) {
         this.shape = shape;
         this.symbol = symbolProvider.toSymbol(shape);
         this.model = model;
         this.symbolProvider = symbolProvider;
         this.writer = writer;
+        this.includeValidation = includeValidation;
 
         variantMap = new TreeMap<>();
         for (MemberShape member : shape.getAllMembers().values()) {
@@ -165,6 +178,9 @@ public void run() {
             writeVisitorType();
             writeVisitorFunction();
             writeFilterSensitiveLog();
+            if (includeValidation) {
+                writeValidate();
+            }
         });
     }
 
@@ -245,4 +261,19 @@ private void writeFilterSensitiveLog() {
             }
         );
     }
+
+    private void writeValidate() {
+        StructuredMemberWriter structuredMemberWriter = new StructuredMemberWriter(
+                model, symbolProvider, shape.getAllMembers().values());
+
+        structuredMemberWriter.writeMemberValidators(writer);
+
+        writer.addImport("ValidationFailure", "__ValidationFailure", "@aws-smithy/server-common");
+        writer.openBlock("export const validate = ($L: $L): __ValidationFailure[] => {", "}",
+                "obj", symbol.getName(),
+                () -> {
+                    structuredMemberWriter.writeValidate(writer, "obj");
+                }
+        );
+    }
 }