Introduce custom constraints to extend the smithy validation rules

core/src/main/java/software/amazon/smithy/java/core/schema/CustomConstraint.java

@@ -0,0 +1,38 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package software.amazon.smithy.java.core.schema;
+
+import java.util.List;
+
+/**
+ * A custom constraint that extends Validation API.
+ *
+ * <p>Implementations are discovered via {@link java.util.ServiceLoader} and must be registered in
+ * {@code META-INF/services/software.amazon.smithy.java.core.schema.CustomConstraint}.
+ *
+ * @see Validator
+ * @see Validator.CustomConstraintProvider
+ * @see ValidationError.CustomValidationFailure
+ */
+public interface CustomConstraint {
+    /**
+     * Determines whether this rule applies to the given schema.
+     *
+     * @param schema the schema to check
+     * @return {@code true} if this rule should validate values of this schema
+     */
+    boolean appliesTo(Schema schema);
+
+    /**
+     * Validates the given value against this custom rule.
+     *
+     * @param schema the schema of the value being validated
+     * @param value the value to validate
+     * @param path the path to the value (e.g., "/user/address/zipCode")
+     * @return a list of validation errors, or an empty list if validation passes
+     */
+    List<ValidationError> validate(Schema schema, Object value, String path);
+}

core/src/main/java/software/amazon/smithy/java/core/schema/ValidationError.java

@@ -137,4 +137,6 @@ private static String createMessage(int position) {
             return "Conflicting list item found at position " + position;
         }
     }
+
+    record CustomValidationFailure(String path, Schema schema, String message) implements ValidationError {}
 }

core/src/main/java/software/amazon/smithy/java/core/schema/Validator.java

@@ -11,6 +11,7 @@
 import java.time.Instant;
 import java.util.ArrayList;
 import java.util.List;
+import java.util.ServiceLoader;
 import java.util.function.BiConsumer;
 import software.amazon.smithy.java.core.serde.ListSerializer;
 import software.amazon.smithy.java.core.serde.MapSerializer;
@@ -224,6 +225,7 @@ public void writeStruct(Schema schema, SerializableStruct struct) {
                 case UNION -> ValidatorOfUnion.validate(this, schema, struct);
                 default -> checkType(schema, ShapeType.STRUCTURE); // this is guaranteed to fail type checking.
             }
+            applyCustomConstraints(schema, struct);
             currentSchema = previousSchema;
             elementCount = previousCount;
         }
@@ -260,6 +262,7 @@ public <T> void writeList(Schema schema, T state, int size, BiConsumer<T, ShapeS
 
                 checkListLength(schema, count);
             }
+            applyCustomConstraints(schema, state);
         }
 
         private void checkListLength(Schema schema, int count) {
@@ -297,6 +300,7 @@ public <T> void writeMap(Schema schema, T state, int size, BiConsumer<T, MapSeri
                 elementCount = previousCount;
                 checkMapLength(schema, count);
             }
+            applyCustomConstraints(schema, state);
         }
 
         private void checkMapLength(Schema schema, int count) {
@@ -328,18 +332,21 @@ public <T> void writeEntry(
         @Override
         public void writeBoolean(Schema schema, boolean value) {
             checkType(schema, ShapeType.BOOLEAN);
+            applyCustomConstraints(schema, value);
         }
 
         @Override
         public void writeByte(Schema schema, byte value) {
             checkType(schema, ShapeType.BYTE);
             validateRange(schema, value, schema.minLongConstraint, schema.maxLongConstraint);
+            applyCustomConstraints(schema, value);
         }
 
         @Override
         public void writeShort(Schema schema, short value) {
             checkType(schema, ShapeType.SHORT);
             validateRange(schema, value, schema.minLongConstraint, schema.maxLongConstraint);
+            applyCustomConstraints(schema, value);
         }
 
         @Override
@@ -354,24 +361,28 @@ public void writeInteger(Schema schema, int value) {
                 }
                 default -> checkType(schema, ShapeType.INTEGER); // it's invalid.
             }
+            applyCustomConstraints(schema, value);
         }
 
         @Override
         public void writeLong(Schema schema, long value) {
             checkType(schema, ShapeType.LONG);
             validateRange(schema, value, schema.minLongConstraint, schema.maxLongConstraint);
+            applyCustomConstraints(schema, value);
         }
 
         @Override
         public void writeFloat(Schema schema, float value) {
             checkType(schema, ShapeType.FLOAT);
             validateRange(schema, value, schema.minDoubleConstraint, schema.maxDoubleConstraint);
+            applyCustomConstraints(schema, value);
         }
 
         @Override
         public void writeDouble(Schema schema, double value) {
             checkType(schema, ShapeType.DOUBLE);
             validateRange(schema, value, schema.minDoubleConstraint, schema.maxDoubleConstraint);
+            applyCustomConstraints(schema, value);
         }
 
         @Override
@@ -383,6 +394,7 @@ public void writeBigInteger(Schema schema, BigInteger value) {
                     schema.maxRangeConstraint.toBigInteger()) > 0) {
                 emitRangeError(schema, value);
             }
+            applyCustomConstraints(schema, value);
         }
 
         @Override
@@ -393,6 +405,7 @@ public void writeBigDecimal(Schema schema, BigDecimal value) {
             } else if (schema.maxRangeConstraint != null && value.compareTo(schema.maxRangeConstraint) > 0) {
                 emitRangeError(schema, value);
             }
+            applyCustomConstraints(schema, value);
         }
 
         @Override
@@ -429,6 +442,7 @@ public void writeString(Schema schema, String value) {
                 }
                 default -> checkType(schema, ShapeType.STRING); // it's invalid, and calling this adds an error.
             }
+            applyCustomConstraints(schema, value);
         }
 
         @Override
@@ -438,16 +452,19 @@ public void writeBlob(Schema schema, ByteBuffer value) {
             if (length < schema.minLengthConstraint || length > schema.maxLengthConstraint) {
                 addError(new ValidationError.LengthValidationFailure(createPath(), length, schema));
             }
+            applyCustomConstraints(schema, value);
         }
 
         @Override
         public void writeTimestamp(Schema schema, Instant value) {
             checkType(schema, ShapeType.TIMESTAMP);
+            applyCustomConstraints(schema, value);
         }
 
         @Override
         public void writeDocument(Schema schema, Document document) {
             checkType(schema, ShapeType.DOCUMENT);
+            applyCustomConstraints(schema, document);
         }
 
         @Override
@@ -488,5 +505,58 @@ private void checkType(Schema schema, ShapeType type) {
                 throw new ValidationShortCircuitException();
             }
         }
+
+        private void applyCustomConstraints(Schema schema, Object value) {
+            if (!CustomConstraintProvider.HAS_CUSTOM_CONSTRAINTS) {
+                return;
+            }
+            var customConstraints = schema.getExtension(CustomConstraintProvider.CUSTOM_CONSTRAINT_EXTENSION_KEY);
+            if (customConstraints == null) {
+                return;
+            }
+            for (var rule: customConstraints) {
+                var validationErrors = rule.validate(schema, value, createPath());
+                for (var error: validationErrors) {
+                    addError(error);
+                }
+            }
+        }
+    }
+
+    /**
+     * Registers a new schema extension for a list of {@link CustomConstraint}
+     */
+    public static class CustomConstraintProvider implements SchemaExtensionProvider<List<CustomConstraint>> {
+        private static final SchemaExtensionKey<List<CustomConstraint>> CUSTOM_CONSTRAINT_EXTENSION_KEY =
+            new SchemaExtensionKey<>();
+        private static final List<CustomConstraint> CUSTOM_CONSTRAINT_LIST = new ArrayList<>();
+        private static final boolean HAS_CUSTOM_CONSTRAINTS;
+
+        public CustomConstraintProvider() {}
+
+        static {
+            // loading all custom constraints at once at startup
+            var loader = ServiceLoader.load(CustomConstraint.class, CustomConstraint.class.getClassLoader());
+            for (var customRule: loader) {
+                CUSTOM_CONSTRAINT_LIST.add(customRule);
+            }
+            HAS_CUSTOM_CONSTRAINTS = !CUSTOM_CONSTRAINT_LIST.isEmpty();
+        }
+
+        @Override
+        public SchemaExtensionKey<List<CustomConstraint>> key() {
+            return CUSTOM_CONSTRAINT_EXTENSION_KEY;
+        }
+
+        @Override
+        public List<CustomConstraint> provide(Schema schema) {
+            var rulesForThisSchema = new ArrayList<CustomConstraint>();
+            for (var rule: CUSTOM_CONSTRAINT_LIST) {
+                if (rule.appliesTo(schema)) {
+                    rulesForThisSchema.add(rule);
+                }
+            }
+            return rulesForThisSchema;
+        }
     }
 }

core/src/main/resources/META-INF/services/software.amazon.smithy.java.core.schema.SchemaExtensionProvider

@@ -0,0 +1 @@
+software.amazon.smithy.java.core.schema.Validator$CustomConstraintProvider

core/src/test/java/software/amazon/smithy/java/core/schema/TestCustomConstraints.java

@@ -0,0 +1,95 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package software.amazon.smithy.java.core.schema;
+
+import java.util.List;
+import software.amazon.smithy.model.shapes.ShapeType;
+
+public final class TestCustomConstraints {
+
+    private TestCustomConstraints() {}
+
+    public static class AlwaysFailsConstraint implements CustomConstraint {
+        @Override
+        public boolean appliesTo(Schema schema) {
+            return schema.id().getNamespace().contains("CustomTest");
+        }
+
+        @Override
+        public List<ValidationError> validate(Schema schema, Object value, String path) {
+            return List.of(new ValidationError.CustomValidationFailure(
+                    path,
+                    schema,
+                    "Custom constraint failed"));
+        }
+    }
+
+    public static class StringOnlyConstraint implements CustomConstraint {
+        @Override
+        public boolean appliesTo(Schema schema) {
+            return schema.type() == ShapeType.STRING
+                    && schema.id().getNamespace().contains("CustomTest");
+        }
+
+        @Override
+        public List<ValidationError> validate(Schema schema, Object value, String path) {
+            return List.of(new ValidationError.CustomValidationFailure(
+                    path,
+                    schema,
+                    "String-only constraint violated"));
+        }
+    }
+
+    public static class ListOnlyConstraint implements CustomConstraint {
+        @Override
+        public boolean appliesTo(Schema schema) {
+            return schema.type() == ShapeType.LIST
+                    && schema.id().getNamespace().contains("CustomTest");
+        }
+
+        @Override
+        public List<ValidationError> validate(Schema schema, Object value, String path) {
+            return List.of(new ValidationError.CustomValidationFailure(
+                    path,
+                    schema,
+                    "List-only constraint violated"));
+        }
+    }
+
+    public static class StructOnlyConstraint implements CustomConstraint {
+
+        @Override
+        public boolean appliesTo(Schema schema) {
+            return schema.type() == ShapeType.STRUCTURE
+                && schema.id().getNamespace().contains("CustomTest");
+        }
+
+        @Override
+        public List<ValidationError> validate(Schema schema, Object value, String path) {
+            return List.of(new ValidationError.CustomValidationFailure(
+                path,
+                schema,
+                "Struct-only constraint violated"));
+        }
+    }
+
+    public static class UnionOnlyConstraint implements CustomConstraint {
+
+        @Override
+        public boolean appliesTo(Schema schema) {
+            return schema.type() == ShapeType.UNION
+                && schema.id().getNamespace().contains("CustomTest");
+        }
+
+        @Override
+        public List<ValidationError> validate(Schema schema, Object value, String path) {
+            return List.of(new ValidationError.CustomValidationFailure(
+                path,
+                schema,
+                "Union-only constraint violated"));
+        }
+    }
+}