Merge remote-tracking branch 'upstream/master'

Author: JonasProgrammer

CHANGELOG.md

@@ -9,6 +9,28 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 
 ### Changed
 
+## 1.0.51 - 2021-03-30
+
+### Added
+
+### Changed
+
+- fixes #392 NPE due to concurrency bug. Thanks @Keymaster65
+- fixes #391 override default EmailValidator, if set custom email format. Thanks @whirosan
+- fixes #390 Add discriminator support. Thanks @FWiesner
+
+## 1.0.50 - 2021-03-18
+
+### Added
+
+### Changed
+
+- fixes #387 Resolve the test case errors for TypeFactoryTest
+- fixes #385 Fixing concurrency and compilation issues. Thanks @prashanthjos
+- fixes #383 Nested oneOf gives incorrect validation error. Thanks @JonasProgrammer
+- fixes #379 Add lossless narrowing convertion. Thanks @hkupty 
+- fixes #378 Upgrade Jackson to 2.12.1 and Undertow to 2.2.4.Final
+
 ## 1.0.49 - 2021-02-17
 
 ### Added

README.md

@@ -82,15 +82,15 @@ Maven:
 <dependency>
     <groupId>com.networknt</groupId>
     <artifactId>json-schema-validator</artifactId>
-    <version>1.0.49</version>
+    <version>1.0.51</version>
 </dependency>
 ```
 
 Gradle:
 
 ```
 dependencies {
-    compile(group: "com.networknt", name: "json-schema-validator", version: "1.0.49");
+    compile(group: "com.networknt", name: "json-schema-validator", version: "1.0.51");
 }
 ```
 

doc/openapi-discriminators.md

@@ -0,0 +1,191 @@
+[//]: # (Copyright 2021, Oracle and/or its affiliates.)
+
+## OpenAPI 3.x discriminator support
+
+Starting with `1.0.51`, `json-schema-validator` partly supports the use of discriminators as described under
+https://github.com/OAI/OpenAPI-Specification/blame/master/versions/3.0.3.md#L2693 and following.
+
+## How to use
+
+1. Configure `SchemaValidatorsConfig` accordingly:
+   ```java
+   class Demo{ 
+    void demo() {
+        SchemaValidatorsConfig config = new SchemaValidatorsConfig();
+        config.setOpenAPI3StyleDiscriminators(true); // defaults to false
+    }
+   }
+   ```
+2. Use the configured `SchemaValidatorsConfig` with the `JSONSchemaFactory` when creating the `JSONSchema`
+   ```java
+   class Demo{ 
+    void demo() {
+        SchemaValidatorsConfig config = new SchemaValidatorsConfig();
+        config.setOpenAPI3StyleDiscriminators(true); // defaults to false
+        JsonSchema schema = validatorFactory.getSchema(schemaURI, schemaJacksonJsonNode, config);
+    }
+   }
+   ```
+3. Ensure that the type field that you want to use as discriminator `propertyName` is required in your schema
+
+## Scope of Support
+
+Discriminators are unfortunately somewhat vague in their definition, especially in regard to JSON Schema validation. So, only
+those parts that are indisputable are considered at this moment.
+
+### Supported:
+
+* Polymorphism using `allOf` and `anyOf` with implicit and explicit `mapping`
+* `discriminator` on base types and types derived
+  thereof `A(with base discriminator) -> B(with optional additive discriminator) -> C(with optional additive discriminator)`
+
+### Not supported:
+
+* `propertyName` redefinition is prohibited on additive discriminators
+* `mapping` key redefinition is also prohibited on additive discriminators
+* `oneOf` ignores discriminators as today it is not clear from the spec whether `oneOf` + `discriminator` should be equal to
+  `anyOf` + `discriminator` or not. Especially if `oneOf` should respect the discriminator and skip the other schemas, it's
+  functionally not JSON Schema `oneOf` anymore as multiple matches would not make the validation fail anymore.
+* the specification indicates that inline properties should be ignored.
+  So, this example would respect `foo`
+    ```yaml
+    allOf:
+        - $ref: otherSchema
+        - type: object
+          properties:
+            foo:
+            type: string
+          required: ["foo"]
+    ```
+  while
+    ```yaml
+    properties:
+      foo:
+        type: string
+    required: ["foo"]
+    allOf:
+      - $ref: otherSchema
+    ```
+  should ignore `foo`. **Ignoring `foo` in the second example is currently not implemented**
+* You won't get a warning if your `discriminator` uses a field for `propertyName` that is not `required`
+
+## Schema Examples
+
+more examples in https://github.com/networknt/json-schema-validator/blob/master/src/test/resources/openapi3/discriminator.json
+
+### Base type and extended type (the `anyOf` forward references are required)
+
+#### the simplest example:
+
+```json
+{
+    "anyOf": [
+        {
+            "$ref": "#/components/schemas/Room"
+        },
+        {
+            "$ref": "#/components/schemas/BedRoom"
+        }
+    ],
+    "components": {
+        "schemas": {
+            "Room": {
+                "type": "object",
+                "properties": {
+                    "@type": {
+                        "type": "string"
+                    },
+                    "floor": {
+                        "type": "integer"
+                    }
+                },
+                "required": [
+                    "@type"
+                ],
+                "discriminator": {
+                    "propertyName": "@type"
+                }
+            },
+            "BedRoom": {
+                "type": "object",
+                "allOf": [
+                    {
+                        "$ref": "#/components/schemas/Room"
+                    },
+                    {
+                        "type": "object",
+                        "properties": {
+                            "numberOfBeds": {
+                                "type": "integer"
+                            }
+                        },
+                        "required": [
+                            "numberOfBeds"
+                        ]
+                    }
+                ]
+            }
+        }
+    }
+}
+```
+
+#### Here the default mapping key for `BedRoom` is overridden with `bed` from `Room`
+
+```json
+{
+    "anyOf": [
+        {
+            "$ref": "#/components/schemas/Room"
+        },
+        {
+            "$ref": "#/components/schemas/BedRoom"
+        }
+    ],
+    "components": {
+        "schemas": {
+            "Room": {
+                "type": "object",
+                "properties": {
+                    "@type": {
+                        "type": "string"
+                    },
+                    "floor": {
+                        "type": "integer"
+                    }
+                },
+                "required": [
+                    "@type"
+                ],
+                "discriminator": {
+                    "propertyName": "@type",
+                    "mapping": {
+                        "bed": "#/components/schemas/BedRoom"
+                    }
+                }
+            },
+            "BedRoom": {
+                "type": "object",
+                "allOf": [
+                    {
+                        "$ref": "#/components/schemas/Room"
+                    },
+                    {
+                        "type": "object",
+                        "properties": {
+                            "numberOfBeds": {
+                                "type": "integer"
+                            }
+                        },
+                        "required": [
+                            "numberOfBeds"
+                        ]
+                    }
+                ]
+            }
+        }
+    }
+}
+```
+
+###

doc/validators.md

@@ -80,3 +80,27 @@ You can use GroovyKeyword like below:
   }
 }
 ````
+
+### Override Email/UUID/DateTime Validator
+
+In this library, if the format keyword is "email", "uuid", "date", "date-time", default validator provided by the library will be used.
+
+If you want to override this behaivor, do as belows.
+
+```
+public JsonSchemaFactory mySchemaFactory() {
+    // base on JsonMetaSchema.V201909 copy code below
+    String URI = "https://json-schema.org/draft/2019-09/schema";
+    String ID = "$id";
+
+    JsonMetaSchema overrideEmailValidatorMetaSchema = new JsonMetaSchema.Builder(URI)
+            .idKeyword(ID)
+            // Override EmailValidator
+            .addFormat(new PatternFormat("email", "^[a-zA-Z0-9.!#$%&'*+\\/=?^_`{|}~-]+@[a-zA-Z0-9-]+(?:\\.[a-zA-Z0-9-]+)*$"))
+            .build();
+
+    return new JsonSchemaFactory.Builder().defaultMetaSchemaURI(overrideEmailValidatorMetaSchema.getUri())
+            .addMetaSchema(overrideEmailValidatorMetaSchema)
+            .build();
+}
+```

pom.xml

@@ -20,7 +20,7 @@
     <modelVersion>4.0.0</modelVersion>
     <groupId>com.networknt</groupId>
     <artifactId>json-schema-validator</artifactId>
-    <version>1.0.49</version>
+    <version>1.0.51</version>
     <packaging>bundle</packaging>
     <description>A json schema validator that supports draft v4, v6, v7 and v2019-09</description>
     <url>https://github.com/networknt/json-schema-validator</url>

src/main/java/com/networknt/schema/AdditionalPropertiesValidator.java

@@ -93,9 +93,9 @@ public Set<ValidationMessage> validate(JsonNode node, JsonNode rootNode, String
                     errors.add(buildValidationMessage(at, pname));
                 } else {
                     if (additionalPropertiesSchema != null) {
-                        ValidatorState state = validatorState.get();
+                        ValidatorState state = (ValidatorState) CollectorContext.getInstance().get(ValidatorState.VALIDATOR_STATE_KEY);
                         if (state != null && state.isWalkEnabled()) {
-                            errors.addAll(additionalPropertiesSchema.walk(node.get(pname), rootNode, at + "." + pname, state.isValidationEnabledWhileWalking()));
+                            errors.addAll(additionalPropertiesSchema.walk(node.get(pname), rootNode, at + "." + pname, state.isValidationEnabled()));
                         } else {
                             errors.addAll(additionalPropertiesSchema.validate(node.get(pname), rootNode, at + "." + pname));
                         }

src/main/java/com/networknt/schema/AllOfValidator.java

@@ -16,22 +16,34 @@
 
 package com.networknt.schema;
 
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Iterator;
+import java.util.LinkedHashSet;
+import java.util.List;
+import java.util.Set;
+
 import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.node.ObjectNode;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
-import java.util.*;
-
 public class AllOfValidator extends BaseJsonValidator implements JsonValidator {
     private static final Logger logger = LoggerFactory.getLogger(AllOfValidator.class);
 
-    private List<JsonSchema> schemas = new ArrayList<JsonSchema>();
-    
+    private final ValidationContext validationContext;
+    private final List<JsonSchema> schemas = new ArrayList<JsonSchema>();
+
     public AllOfValidator(String schemaPath, JsonNode schemaNode, JsonSchema parentSchema, ValidationContext validationContext) {
         super(schemaPath, schemaNode, parentSchema, ValidatorTypeCode.ALL_OF, validationContext);
+        this.validationContext = validationContext;
         int size = schemaNode.size();
         for (int i = 0; i < size; i++) {
-            schemas.add(new JsonSchema(validationContext, getValidatorType().getValue(), parentSchema.getCurrentUri(), schemaNode.get(i), parentSchema));
+            schemas.add(new JsonSchema(validationContext,
+                                       getValidatorType().getValue(),
+                                       parentSchema.getCurrentUri(),
+                                       schemaNode.get(i),
+                                       parentSchema));
         }
     }
 
@@ -42,20 +54,49 @@ public Set<ValidationMessage> validate(JsonNode node, JsonNode rootNode, String
 
         for (JsonSchema schema : schemas) {
             errors.addAll(schema.validate(node, rootNode, at));
+
+            if (config.isOpenAPI3StyleDiscriminators()) {
+                final Iterator<JsonNode> arrayElements = schemaNode.elements();
+                while (arrayElements.hasNext()) {
+                    final ObjectNode allOfEntry = (ObjectNode) arrayElements.next();
+                    final JsonNode $ref = allOfEntry.get("$ref");
+                    if (null != $ref) {
+                        final ValidationContext.DiscriminatorContext currentDiscriminatorContext = validationContext
+                                .getCurrentDiscriminatorContext();
+                        final ObjectNode discriminator = currentDiscriminatorContext
+                                .getDiscriminatorForPath(allOfEntry.get("$ref").asText());
+                        if (null != discriminator) {
+                            registerAndMergeDiscriminator(currentDiscriminatorContext, discriminator, parentSchema, at);
+                            // now we have to check whether we have hit the right target
+                            final String discriminatorPropertyName = discriminator.get("propertyName").asText();
+                            final String discriminatorPropertyValue = node.get(discriminatorPropertyName).textValue();
+
+                            final JsonSchema jsonSchema = parentSchema;
+                            checkDiscriminatorMatch(
+                                    currentDiscriminatorContext,
+                                    discriminator,
+                                    discriminatorPropertyValue,
+                                    jsonSchema);
+                        }
+                    }
+                }
+            }
         }
 
         return Collections.unmodifiableSet(errors);
     }
-    
-	@Override
-	public Set<ValidationMessage> walk(JsonNode node, JsonNode rootNode, String at, boolean shouldValidateSchema) {
-		Set<ValidationMessage> validationMessages = new LinkedHashSet<ValidationMessage>();
-
-		for (JsonSchema schema : schemas) {
-			// Walk through the schema
-			validationMessages.addAll(schema.walk(node, rootNode, at, shouldValidateSchema));
-		}
-		return Collections.unmodifiableSet(validationMessages);
-	}
+
+
+
+    @Override
+    public Set<ValidationMessage> walk(JsonNode node, JsonNode rootNode, String at, boolean shouldValidateSchema) {
+        Set<ValidationMessage> validationMessages = new LinkedHashSet<ValidationMessage>();
+
+        for (JsonSchema schema : schemas) {
+            // Walk through the schema
+            validationMessages.addAll(schema.walk(node, rootNode, at, shouldValidateSchema));
+        }
+        return Collections.unmodifiableSet(validationMessages);
+    }
 
 }