Validation of nested arrays

[simkoo98]

Hi all,
I have a list of objects. These objects also have a array with objects. The number of the objects of the second list can variate. Depending of a value of a property of this object, I want to evaluate other properties. If all arrays have the same number of objects, everything is fine. If the number of objects changes, no more properties are evaluated with my if/else clause.
I use the following json schema:

{
  "type": "array",
  "items": {
    "type": "object",
    "unevaluatedProperties": false,
    "properties": {
      "Children": {
        "type": "array",
        "items": {
          "type": "object",
          "unevaluatedProperties": false,
          "if": {
            "properties": {
              "Name": {
                "const": "Actual"
              }
            }
          },
          "then": {
            "properties": {
              "Test1": {
                "type": "string"
              }
            }
          },
          "else": {
            "not": {}
          }
        }
      }
    }
  }
}

My failing json input is the following:

[
  {
    "Element1": "Test",
    "Children": [
      {
        "Name": "Actual",
        "Test1": "Test1",
        "Test2": "Test2"
      },
      {
        "Name": "Actual",
        "Test1": "Test1",
        "Test2": "Test2"
      },
      {
        "Name": "Dummy",
        "Test1": "Test1",
        "Test2": "Test2"
      }
    ]
  },
  {
    "Element2": "Test",
    "Children": [
      {
        "Name": "Actual",
        "Test1": "Test1",
        "Test2": "Test2"
      },
      {
        "Name": "Dummy",
        "Test1": "Test1",
        "Test2": "Test2"
      }
    ]
  },
  {
    "Element3": "Test",
    "Children": [
      {
        "Name": "Actual",
        "Test1": "Test1",
        "Test2": "Test2"
      },
      {
        "Name": "Dummy",
        "Test1": "Test1",
        "Test2": "Test2"
      },
      {
        "Name": "Actual",
        "Test1": "Test1",
        "Test2": "Test2"
      }
    ]
  }
]

At "Element1" everything works as expected. If the number of elements of the array "Children" changes to two elements. The object with property "name" with value "Actual" is not valid anymore. All following elements will also not be validated again.

With this json input everything works as intended:

[
  {
    "Element1": "Test",
    "Children": [
      {
        "Name": "Actual",
        "Test1": "Test1",
        "Test2": "Test2"
      },
      {
        "Name": "Actual",
        "Test1": "Test1",
        "Test2": "Test2"
      },
      {
        "Name": "Dummy",
        "Test1": "Test1",
        "Test2": "Test2"
      }
    ]
  },
  {
    "Element2": "Test",
    "Children": [
      {
        "Name": "Actual",
        "Test1": "Test1",
        "Test2": "Test2"
      },
      {
        "Name": "Dummy",
        "Test1": "Test1",
        "Test2": "Test2"
      },
      {
        "Name": "Dummy",
        "Test1": "Test1",
        "Test2": "Test2"
      }
    ]
  },
  {
    "Element3": "Test",
    "Children": [
      {
        "Name": "Actual",
        "Test1": "Test1",
        "Test2": "Test2"
      },
      {
        "Name": "Dummy",
        "Test1": "Test1",
        "Test2": "Test2"
      },
      {
        "Name": "Actual",
        "Test1": "Test1",
        "Test2": "Test2"
      }
    ]
  }
]

Could you kindly advise me?
Thanks!

[jdesrosiers]

I'm not entirely clear what you're trying to do, but I can help explain what your schema is doing and hopefully that will help.

To start with let's isolate the part of the schema doing the complex work. The rest is trivial and inconsequential.

{
  "type": "object",
  "unevaluatedProperties": false,
  "if": {
    "properties": {
      "Name": {
        "const": "Actual"
      }
    }
  },
  "then": {
    "properties": {
      "Test1": {
        "type": "string"
      }
    }
  },
  "else": {
    "not": {}
  }
}

To start with, make sure whatever validator you're using supports JSON Schema version 2019-09 or higher. The unevaluatedProperties keyword didn't exist before then.

Here's the "Actual" case.

{
  "Name": "Actual",
  "Test1": "Test1"
}

The if schema passes, so "Name" is considered evaluated. The then schema passes, so "Test1" is considered evaluated. Therefore, all properties are evaluated and the unevaluatedProperties keyword passes. The JSON instance passes validation.

Now the "Dummy" case.

{
  "Name": "Dummy"
}

The if schema fails, so the else schema is validated. The else schema always fails, so the JSON instance fails validation. I don't think this was intended. Fixing this problem will require two steps. The first is to remove the else schema.

{
  "type": "object",
  "unevaluatedProperties": false,
  "if": { ... },
  "then": { ... }
}

Now the if can fail without causing the whole schema to fail. However, because the if schema fails, the "Name" property is not considered evaluated. Only schemas that pass validated contribute evaluated properties. That means that unevaluatedProperties will fail and the JSON instance fails validation. To fix this, you need to declare the "Name" property outside of the if.

{
  "type": "object",
  "properties": {
    "Name": { "type": "string" }
  },
  "unevaluatedProperties": false,
  "if": { ... },
  "then": { ... }
}

Now "Name" is evaluated regardless of whether if passes or not and the unevaluatedProperties keyword passes. The JSON instance passes validation.

Now the "Dummy" case with "Test1".

{
  "Name": "Dummy",
  "Test1": "Test1"
}

Because the if schema fails, the then schema is skipped and the "Test1" property isn't considered evaluated. That means the unevaluatedProperties keyword will fail and the JSON instance will fail validation. I believe that's the expected behavior 🎉.

Now the "Test2" case.

{
  "Name": "Actual",
  "Test1": "Test1",
  "Test2": "Test2"
}

I'm not sure what you're trying to do here, but "Test2" never appears in your schema, so it will always be considered unevaluated. The unevaluatedProperties keyword will fail and the JSON instance will fail validation no matter what else appears in the instance.

Now an edge case.

{
  "Test1": "Test1"
}

Because the if schema doesn't require "Name", it will pass if "Name" isn't present. Since if passes, then will be evaluated and "Test2" will be considered evaluated. The unevaluatedProperties keyword will pass and the JSON instance will pass validation. I don't think this was the intention. You can fix this by adding required in the if schema.

{
  "type": "object",
  "properties": { ... },
  "unevaluatedProperties": false,
  "if": {
    ...,
    "required": ["Name"]
  },
  "then": { ... }
}

Assuming I haven't made any incorrect assumptions about what you're trying to do, that should work if you're using a validator that supports all the keywords used in the schema.

[simkoo98]

What I want to do at the end is to filter with the Json schema. All unevaluated Properties will be removed in my code after the validation.
For the correct input I got the result as expected for all children elements where the name is "Actual":

[
  {
    "Children": [
      {
        "Name": "Actual",
        "Test1": "Test1",
      },
      {
        "Name": "Actual",
        "Test1": "Test1",
      },
      {
      }
    ]
  },
  {
    "Children": [
      {
        "Name": "Actual",
        "Test1": "Test1",
      },
      {
      },
      {
      }
    ]
  },
  {
    "Children": [
      {
        "Name": "Actual",
        "Test1": "Test1",
      },
      {
      },
      {
        "Name": "Actual",
        "Test1": "Test1",
      }
    ]
  }
]

If the name is not "Actual" it is correct that the subschema for the object fails completely and no property will be evaluated.

With the failing Json input I got the following result:

[
  {
    "Children": [
      {
        "Name": "Actual",
        "Test1": "Test1",
      },
      {
        "Name": "Actual",
        "Test1": "Test1",
      },
      {
      }
    ]
  },
  {
    "Children": [
      {
        "Name": "Actual",
        "Test1": "Test1"
      },
    ]
  },
  {
    "Children": [
      {
      },
      {
      },
      {
      }
    ]
  }
]

The examples show that if the object children always has the same number of sub objects everything works fine. If the number of sub objects variate, the validation fails as in the previous example. The output I expect for the currently failing Json is the following because I always want to get the object validated, where the name is "Actual". No matter how many sibling objects there are in the array.

[
  {
    "Children": [
      {
        "Name": "Actual",
        "Test1": "Test1",
      },
      {
        "Name": "Actual",
        "Test1": "Test1",
      },
      {
      }
    ]
  },
  {
    "Children": [
      {
        "Name": "Actual",
        "Test1": "Test1",
      },
      {
      },
      {
      }
    ]
  },
  {
    "Children": [
      {
        "Name": "Actual",
        "Test1": "Test1",
      },
      {
      },
      {
        "Name": "Actual",
        "Test1": "Test1",
      }
    ]
  }
]

I hope it is clearer for you what I want to do. If not I could also show it quickly to you in a live demo.
Thanks!

[jdesrosiers]

I'm still not following what you're trying to do.

All unevaluated Properties will be removed in my code after the validation.

If you're going to remove unevaluated properties, you don't want to include unevaluatedProperties: false. If you use unevaluatedProperties your schema won't validate if there are unevaluated properties. So, after validation, there wouldn't be anything to remove.

With the failing Json input I got the following result:

That statement doesn't seem to match the JSON that follows. Is that supposed to be the JSON input you expect to fail validation? If so, it does pass validation. If you are seeing that fail, there's a bug in whatever library you're using for validation.

The examples show that if the object children always has the same number of sub objects everything works fine. If the number of sub objects variate, the validation fails as in the previous example.

There's nothing in JSON Schema that can make that happen. Each value is validated independently. The number of elements in one array can't effect the validation of another. You couldn't even get JSON Schema to do that if you wanted to. It's not something JSON Schema is capable of. Either you're misunderstanding the result or the library you're using for validation has a very bizarre bug.