Contains not working as expected with array of objects

[alessio-greco]

Using the following schema:

{
  "$schema": "http://json-schema.org/draft-07/schema",
  "properties": {
    "elements": {
      "type": "array",
      "items": {
        "type": "object"
      },
      "contains": {
        "properties": {
          "somePropertyA": {
            "type": "string",
            "enum": [
              "true"
            ]
          }
        }
      }
    }
  },
  "required":["elements"],
}

the following object is considered valid

{
  "elements": [
    {
      "somePropertyB": "false"
    },
    {
      "somePropertyA": "false"
    }
  ]
}

despite the schema saying "elements should contain a "somePropertyA":"true" object.

Is this the normal behaviour? most validators I tried will consider it valid (despite being intended not to be valid). The only way to make this work is passing an array with just the "intended" property, like

{
  "elements": [
    {
      "somePropertyA": "false"
    }
  ]
}

this will correctly be considered invalid.

[Relequestual]

JSON Schema is constraints based, and so anything you don't prohibit is allowed and considered valid.

You haven't constrained additional properties using the additionalProperties keyword, so any key in the elements array objects are considered valid.

You need to add "additionalProperties" : false.

See https://json-schema.org/understanding-json-schema/reference/object.html#additional-properties for more info.

[alessio-greco]

but my constraint was that the list of objects should have contained {"somePropertiesA":true} ( it's not my project, but some external constraints for the job i'm in ), not that it should contain only that element or such.

I'm receiving a list of object and i should check if one of those elements is precisely {"somePropertiesA":true}.
This works when there's only 1 element, but stops working when there's more than one.
It's constraint-based, but one of my constrains isn't being respected either

[alessio-greco]

this is invalid, but is reported as valid

{
  "elements": [
    {
      "somePropertyB": "false"
    },
    {
      "somePropertyA": "false"
    }
  ]
}

this is valid, correctly

{
  "elements": [
    {
      "somePropertyB": "false"
    },
    {
      "somePropertyA": "true"
    }
  ]
}

This is invalid, and is reported correctly as invalid

{
  "elements": [
    {
      "somePropertyA": "false"
    }
  ]
}

This is valid, and is reported as valid

{
  "elements": [
    {
      "somePropertyA": "false"
    }
  ]
}

I have no idea why the API i'm working with was implemented like that, but if i don't find any solution i'll just check it in the code directly which seems easier

[karenetheridge]

Because you don't say that "somePropertyA" is required. The first item passes the "contains" constraint because there is no "somePropertyA" to apply the schema to.

add "required": ["somePropertyA"] to your "contains" subschema and things will work as you expect.

[alessio-greco]

Ok, I added the additional property inside the contain, this creates 1 question.

Why this was considered invalid

{
  "elements": [
    {
      "somePropertyA": "false"
    }
  ]
}

and this was not

{
  "elements": [
    {
      "somePropertyB": "false"
    },
    {
      "somePropertyA": "false"
    }
  ]
}

since in both case they would validate a contain without the additionalProperties

[barasztamas]

Your condition was: there should be one element in the list, for which "if somePropertyA exists its value should be true" is true.
In the second case, the first element of the list satisfied this condition.