Implemented JsonSchemaParser and several new validation rules

maherp1 · maherp1 · commit 52b747efab0a · 2023-12-19T19:44:50.000+01:00
diff --git a/src/main/java/org/javawebstack/abstractdata/schema/AbstractArraySchema.java b/src/main/java/org/javawebstack/abstractdata/schema/AbstractArraySchema.java
@@ -2,18 +2,19 @@
 
 import org.javawebstack.abstractdata.AbstractArray;
 import org.javawebstack.abstractdata.AbstractElement;
+import org.javawebstack.abstractdata.AbstractObject;
 import org.javawebstack.abstractdata.AbstractPath;
 
-import java.util.ArrayList;
-import java.util.List;
-import java.util.Locale;
+import java.util.*;
 
 public class AbstractArraySchema implements AbstractSchema {
 
     private AbstractSchema itemSchema;
     private Integer min;
     private Integer max;
     private boolean allowNull = false;
+
+    private boolean unique;
     private final List<CustomValidation<AbstractArray>> customValidations = new ArrayList<>();
 
     public AbstractArraySchema itemSchema(AbstractSchema schema) {
@@ -35,6 +36,10 @@ public AbstractArraySchema allowNull() {
         this.allowNull = true;
         return this;
     }
+    public AbstractArraySchema unique(){
+        this.unique = true;
+        return this;
+    }
 
     public AbstractArraySchema customValidation(CustomValidation<AbstractArray> validation) {
         customValidations.add(validation);
@@ -57,6 +62,25 @@ public List<CustomValidation<AbstractArray>> getCustomValidations() {
         return customValidations;
     }
 
+    @Override
+    public AbstractObject toJsonSchema() {
+        AbstractObject obj = new AbstractObject();
+        obj.set("type","array");
+        if(min != null){
+            obj.set("minItems",min);
+        }
+        if(max != null){
+            obj.set("maxItems",max);
+        }
+        if(itemSchema != null){
+            obj.set("items",itemSchema.toJsonSchema());
+        }
+        if(unique) {
+            obj.set("uniqueItems","true");
+        }
+        return obj;
+    }
+
     public List<SchemaValidationError> validate(AbstractPath path, AbstractElement value) {
         List<SchemaValidationError> errors = new ArrayList<>();
         if(value.getType() != AbstractElement.Type.ARRAY) {
@@ -70,10 +94,11 @@ public List<SchemaValidationError> validate(AbstractPath path, AbstractElement v
         if(max != null && array.size() > max) {
             errors.add(new SchemaValidationError(path, "too_many_items").meta("max", String.valueOf(max)).meta("actual", String.valueOf(array.size())));
         }
-        if(itemSchema != null) {
-            for(int i=0; i<array.size(); i++) {
-                AbstractElement item = array.get(i);
-                AbstractPath itemPath = path.subPath(String.valueOf(i));
+        List<AbstractElement> seen = new ArrayList<>();
+        for(int i=0; i<array.size(); i++) {
+            AbstractElement item = array.get(i);
+            AbstractPath itemPath = path.subPath(String.valueOf(i));
+            if(itemSchema != null) {
                 if(item.isNull()) {
                     if(!allowNull) {
                         errors.add(new SchemaValidationError(itemPath, "null_not_allowed"));
@@ -82,7 +107,21 @@ public List<SchemaValidationError> validate(AbstractPath path, AbstractElement v
                 }
                 errors.addAll(itemSchema.validate(itemPath, array.get(i)));
             }
+
+            if(unique){
+                if(seen.contains(item)){
+                    int originalIndex = seen.indexOf(item);
+                    AbstractPath originalPath = path.subPath(String.valueOf(originalIndex));
+                    errors.add(new SchemaValidationError(itemPath,"duplicate_array_value")
+                            .meta("value",item.toJsonString())
+                            .meta("first",originalPath.toString()));
+                }
+                seen.add(item);
+            }
+
         }
+
+
         for(CustomValidation<AbstractArray> validation : customValidations) {
             errors.addAll(validation.validate(path, array));
         }
diff --git a/src/main/java/org/javawebstack/abstractdata/schema/AbstractBooleanSchema.java b/src/main/java/org/javawebstack/abstractdata/schema/AbstractBooleanSchema.java
@@ -1,6 +1,7 @@
 package org.javawebstack.abstractdata.schema;
 
 import org.javawebstack.abstractdata.AbstractElement;
+import org.javawebstack.abstractdata.AbstractObject;
 import org.javawebstack.abstractdata.AbstractPath;
 import org.javawebstack.abstractdata.AbstractPrimitive;
 
@@ -31,6 +32,16 @@ public List<CustomValidation<AbstractPrimitive>> getCustomValidations() {
         return customValidations;
     }
 
+    @Override
+    public AbstractObject toJsonSchema() {
+        AbstractObject obj = new AbstractObject()
+                .set("type","boolean");
+        if(staticValue != null){
+            obj.set("const",staticValue);
+        }
+        return obj;
+    }
+
     public List<SchemaValidationError> validate(AbstractPath path, AbstractElement value) {
         List<SchemaValidationError> errors = new ArrayList<>();
         if(value.getType() != AbstractElement.Type.BOOLEAN) {
diff --git a/src/main/java/org/javawebstack/abstractdata/schema/AbstractNumberSchema.java b/src/main/java/org/javawebstack/abstractdata/schema/AbstractNumberSchema.java
@@ -1,6 +1,7 @@
 package org.javawebstack.abstractdata.schema;
 
 import org.javawebstack.abstractdata.AbstractElement;
+import org.javawebstack.abstractdata.AbstractObject;
 import org.javawebstack.abstractdata.AbstractPath;
 import org.javawebstack.abstractdata.AbstractPrimitive;
 
@@ -14,18 +15,36 @@ public class AbstractNumberSchema implements AbstractSchema {
     private boolean integerOnly = false;
     private Number min;
     private Number max;
+    private boolean minExclusive = false;
+    private boolean maxExclusive = false;
+    private Number step;
     private final List<CustomValidation<AbstractPrimitive>> customValidations = new ArrayList<>();
 
     public AbstractNumberSchema min(Number min) {
+        return min(min,false);
+    }
+
+    public AbstractNumberSchema max(Number max) {
+        return max(max,false);
+    }
+
+    public AbstractNumberSchema min(Number min, boolean exclusive) {
+        this.minExclusive = exclusive;
         this.min = min;
         return this;
     }
 
-    public AbstractNumberSchema max(Number max) {
+    public AbstractNumberSchema max(Number max, boolean exclusive) {
+        this.maxExclusive = exclusive;
         this.max = max;
         return this;
     }
 
+    public AbstractNumberSchema step(Number step){
+        this.step = step;
+        return this;
+    }
+
     public AbstractNumberSchema integerOnly() {
         this.integerOnly = true;
         return this;
@@ -52,6 +71,36 @@ public List<CustomValidation<AbstractPrimitive>> getCustomValidations() {
         return customValidations;
     }
 
+    @Override
+    public AbstractObject toJsonSchema() {
+        AbstractObject obj = new AbstractObject();
+
+        obj.set("type",integerOnly ? "integer" : "number");
+        if(min != null && max != null && !minExclusive && !maxExclusive){
+            BigDecimal dMin = (min instanceof Float || min instanceof Double) ? BigDecimal.valueOf(min.doubleValue()) : BigDecimal.valueOf(min.longValue());
+            BigDecimal dMax = (max instanceof Float || max instanceof Double) ? BigDecimal.valueOf(max.doubleValue()) : BigDecimal.valueOf(max.longValue());
+
+            if(dMin.compareTo(dMax)==0){
+                obj.set("const",min);
+            }
+
+        }
+        if(!obj.has("const")) {
+            if (min != null) {
+                obj.set(minExclusive ? "exclusiveMinimum" : "minimum", min);
+            }
+            if (max != null) {
+                obj.set(maxExclusive ? "exclusiveMaximum" : "maximum", max);
+            }
+            if (step != null) {
+                obj.set("multipleOf", step);
+            }
+        }
+
+
+        return obj;
+    }
+
     public List<SchemaValidationError> validate(AbstractPath path, AbstractElement value) {
         List<SchemaValidationError> errors = new ArrayList<>();
         if(value.getType() != AbstractElement.Type.NUMBER) {
@@ -66,16 +115,27 @@ public List<SchemaValidationError> validate(AbstractPath path, AbstractElement v
         }
         if(min != null) {
             BigDecimal dMin = (min instanceof Float || min instanceof Double) ? BigDecimal.valueOf(min.doubleValue()) : BigDecimal.valueOf(min.longValue());
-            if(dN.compareTo(dMin) < 0) {
+            if(!(dN.compareTo(dMin) > (minExclusive ? 0 : -1))) {
                 errors.add(new SchemaValidationError(path, "number_smaller_than_min").meta("min", dMin.toPlainString()).meta("actual", dN.toPlainString()));
             }
         }
         if(max != null) {
-            BigDecimal dMax = (max instanceof Float || min instanceof Double) ? BigDecimal.valueOf(max.doubleValue()) : BigDecimal.valueOf(max.longValue());
-            if(dN.compareTo(dMax) > 0) {
+            BigDecimal dMax = (max instanceof Float || max instanceof Double) ? BigDecimal.valueOf(max.doubleValue()) : BigDecimal.valueOf(max.longValue());
+            if(!(dN.compareTo(dMax) < (maxExclusive ? 0 : 1))) {
                 errors.add(new SchemaValidationError(path, "number_larger_than_max").meta("max", dMax.toPlainString()).meta("actual", dN.toPlainString()));
             }
         }
+        if(step != null) {
+            if(min != null && minExclusive){
+                throw new UnsupportedOperationException("Step is not supported together with an exclusive minimum");
+            }
+            BigDecimal dMin = min == null ? BigDecimal.ZERO : (min instanceof Float || min instanceof Double) ? BigDecimal.valueOf(min.doubleValue()) : BigDecimal.valueOf(min.longValue());
+            BigDecimal dStep =  (step instanceof Float || step instanceof Double) ? BigDecimal.valueOf(step.doubleValue()) : BigDecimal.valueOf(step.longValue());
+
+            if(dN.subtract(dMin).remainder(dStep).compareTo(BigDecimal.ZERO) != 0) {
+                errors.add(new SchemaValidationError(path, "number_not_within_step").meta("step", dStep.toPlainString()).meta("actual", dN.toPlainString()).meta("start",dMin.toPlainString()));
+            }
+        }
         for(CustomValidation<AbstractPrimitive> validation : customValidations) {
             errors.addAll(validation.validate(path, value.primitive()));
         }
diff --git a/src/main/java/org/javawebstack/abstractdata/schema/AbstractObjectSchema.java b/src/main/java/org/javawebstack/abstractdata/schema/AbstractObjectSchema.java
@@ -1,5 +1,6 @@
 package org.javawebstack.abstractdata.schema;
 
+import org.javawebstack.abstractdata.AbstractArray;
 import org.javawebstack.abstractdata.AbstractElement;
 import org.javawebstack.abstractdata.AbstractObject;
 import org.javawebstack.abstractdata.AbstractPath;
@@ -41,6 +42,30 @@ public AbstractObjectSchema additionalProperties(AbstractSchema schema) {
         return this;
     }
 
+    @Override
+    public AbstractObject toJsonSchema() {
+        AbstractObject obj = new AbstractObject();
+        obj.set("type","object");
+        AbstractObject properties = new AbstractObject();
+        this.properties.forEach((key, value)->{
+            properties.set(key,value.toJsonSchema());
+        });
+        obj.set("properties",properties);
+
+        if(!requiredProperties.isEmpty()){
+            AbstractArray required = new AbstractArray();
+            requiredProperties.forEach(required::add);
+            obj.set("required",required);
+        }
+        if(!allowAdditionalProperties){
+            obj.set("additionalProperties",false);
+        }else if(additionalPropertySchema != null){
+            obj.set("additionalProperties",additionalPropertySchema.toJsonSchema());
+        }
+
+        return obj;
+    }
+
     public List<SchemaValidationError> validate(AbstractPath path, AbstractElement value) {
         List<SchemaValidationError> errors = new ArrayList<>();
         if(value.getType() != AbstractElement.Type.OBJECT) {
diff --git a/src/main/java/org/javawebstack/abstractdata/schema/AbstractSchema.java b/src/main/java/org/javawebstack/abstractdata/schema/AbstractSchema.java
@@ -7,6 +7,7 @@
 import java.util.List;
 
 public interface AbstractSchema {
+    AbstractObject toJsonSchema();
 
     default List<SchemaValidationError> validate(AbstractElement value) {
         return validate(AbstractPath.ROOT, value);
diff --git a/src/main/java/org/javawebstack/abstractdata/schema/AbstractStringSchema.java b/src/main/java/org/javawebstack/abstractdata/schema/AbstractStringSchema.java
@@ -1,8 +1,6 @@
 package org.javawebstack.abstractdata.schema;
 
-import org.javawebstack.abstractdata.AbstractElement;
-import org.javawebstack.abstractdata.AbstractPath;
-import org.javawebstack.abstractdata.AbstractPrimitive;
+import org.javawebstack.abstractdata.*;
 
 import java.util.*;
 import java.util.regex.Matcher;
@@ -73,6 +71,30 @@ public List<CustomValidation<AbstractPrimitive>> getCustomValidations() {
         return customValidations;
     }
 
+    @Override
+    public AbstractObject toJsonSchema() {
+        AbstractObject obj = new AbstractObject();
+        obj.set("type","string");
+        if(minLength != null){
+            obj.set("minLength",minLength);
+        }
+        if(maxLength != null){
+            obj.set("maxLength",maxLength);
+        }
+        if(staticValue != null) {
+            obj.set("const",staticValue);
+        }
+        if(regex != null) {
+            obj.set("pattern",regex);
+        }
+        if(enumValues != null) {
+            AbstractArray arr = new AbstractArray(enumValues.toArray());
+            obj.set("enum",arr);
+        }
+
+        return obj;
+    }
+
     public List<SchemaValidationError> validate(AbstractPath path, AbstractElement value) {
         List<SchemaValidationError> errors = new ArrayList<>();
         if(value.getType() != AbstractElement.Type.STRING) {
diff --git a/src/main/java/org/javawebstack/abstractdata/schema/JsonSchemaParser.java b/src/main/java/org/javawebstack/abstractdata/schema/JsonSchemaParser.java
diff --git a/src/main/java/org/javawebstack/abstractdata/schema/OneOfSchema.java b/src/main/java/org/javawebstack/abstractdata/schema/OneOfSchema.java
diff --git a/src/main/java/org/javawebstack/abstractdata/schema/SchemaValidationError.java b/src/main/java/org/javawebstack/abstractdata/schema/SchemaValidationError.java
