Resolve sub schema node only if really needed

a JsonNode that contains a json schema and was supposed to be validated previously lead to a call to the url - but the url was possibly not yet correctly defined because the schema was not validated... so we need to do the id-based fetching only if actually needed

Author: Klas Kalaß

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

@@ -29,23 +29,24 @@ public abstract class BaseJsonValidator implements JsonValidator {
     private String schemaPath;
     private JsonNode schemaNode;
     private JsonSchema parentSchema;
-    private JsonSchema subSchema;
+    private boolean suppressSubSchemaRetrieval;
     private ValidatorTypeCode validatorType;
     private ErrorMessageType errorMessageType;
 
+    
     public BaseJsonValidator(String schemaPath, JsonNode schemaNode, JsonSchema parentSchema,
                              ValidatorTypeCode validatorType, ValidationContext validationContext) {
-    	this(schemaPath, schemaNode, parentSchema, validatorType, obainSubSchemaNode(schemaNode, validationContext) );
+    	this(schemaPath, schemaNode, parentSchema, validatorType, false );
     }
 
     public BaseJsonValidator(String schemaPath, JsonNode schemaNode, JsonSchema parentSchema,
-                             ValidatorTypeCode validatorType, JsonSchema subSchema) {
+                             ValidatorTypeCode validatorType, boolean suppressSubSchemaRetrieval) {
         this.errorMessageType = validatorType;
         this.schemaPath = schemaPath;
         this.schemaNode = schemaNode;
         this.parentSchema = parentSchema;
         this.validatorType = validatorType;
-        this.subSchema = subSchema;
+        this.suppressSubSchemaRetrieval = suppressSubSchemaRetrieval;
     }
 
     protected String getSchemaPath() {
@@ -60,15 +61,12 @@ protected JsonSchema getParentSchema() {
         return parentSchema;
     }
 
-    protected JsonSchema getSubSchema() {
-        return subSchema;
+    protected JsonSchema fetchSubSchemaNode(ValidationContext validationContext) {
+        return suppressSubSchemaRetrieval ? null : obtainSubSchemaNode(schemaNode, validationContext);
     }
 
-    protected boolean hasSubSchema() {
-        return subSchema != null;
-    }
 
-    protected static JsonSchema obainSubSchemaNode(JsonNode schemaNode, ValidationContext validationContext){
+    private static JsonSchema obtainSubSchemaNode(JsonNode schemaNode, ValidationContext validationContext){
         JsonNode node = schemaNode.get("id");
         if(node == null) return null;
     	if(node.equals(schemaNode.get("$schema"))) return null;

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

@@ -46,18 +46,18 @@ public class JsonSchema extends BaseJsonValidator {
 
     JsonSchema(ValidationContext validationContext,  String schemaPath, JsonNode schemaNode,
                JsonSchema parent) {
-        this(validationContext,  schemaPath, schemaNode, parent, obainSubSchemaNode(schemaNode, validationContext));
+        this(validationContext,  schemaPath, schemaNode, parent, false);
     }
 
     JsonSchema(ValidationContext validatorFactory,  String schemaPath, JsonNode schemaNode,
-               JsonSchema parent, JsonSchema subSchema) {
-        super(schemaPath, schemaNode, parent, null, subSchema);
+               JsonSchema parent, boolean suppressSubSchemaRetrieval) {
+        super(schemaPath, schemaNode, parent, null, suppressSubSchemaRetrieval);
         this.validationContext = validatorFactory;
         this.validators = Collections.unmodifiableMap(this.read(schemaNode));
     }
 
-    public JsonSchema(ValidationContext validationContext,  JsonNode schemaNode, JsonSchema subSchema) {
-        this(validationContext, "#", schemaNode, null, subSchema);
+    public JsonSchema(ValidationContext validationContext,  JsonNode schemaNode, boolean suppressSubSchemaRetrieval) {
+        this(validationContext, "#", schemaNode, null, suppressSubSchemaRetrieval);
     }
 
     /**
@@ -84,8 +84,11 @@ public JsonNode getRefSchemaNode(String ref) {
                 } else {
                     node = node.get(key);
                 }
-                if (node == null && schema.hasSubSchema()){
-                    node = schema.getSubSchema().getRefSchemaNode(ref);
+                if (node == null){
+                    JsonSchema subSchema = schema.fetchSubSchemaNode(validationContext);
+                    if (subSchema != null) {
+                        node = subSchema.getRefSchemaNode(ref);
+                    }
                 }
                 if (node == null){
                     break;

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

@@ -189,7 +189,7 @@ public JsonSchema getSchema(URL schemaURL) {
 
                 if (idMatchesSourceUrl(jsonMetaSchema, schemaNode, schemaURL)) {
 
-                    return new JsonSchema(new ValidationContext(jsonMetaSchema, this), schemaNode, null);
+                    return new JsonSchema(new ValidationContext(jsonMetaSchema, this), schemaNode, true /*retrieved via id, resolving will not change anything*/);
                 }
 
                 return newJsonSchema(schemaNode);