Incorrectly Applying 'if-then' Condition to Nested Definition

[mfialaf]

Hi, I have following basic json-schema:

{
  "$schema": "http://json-schema.org/draft-07/schema#",
  "type": "object",
  "properties": {
    "version": {
      "type": "integer"
    },
    "tools": {
      "type": "array",
      "items": {
        "$ref": "#/definitions/tool"
      }
    }
  },
  "definitions": {
    "tool": {
      "type": "object",
      "properties": {
        "name": {
          "type": "string"
        },
        "type": {
          "type": "string"
        }
      },
      "required": [
        "type"
      ]
    }
  },
  "required": [
    "version",
    "tools"
  ]
}

I am trying to create a simple condition: If version is equal 1, then #/definitions/tool/properties/name must not be present.

I've tried multiple expansions of the schema like:
1.

    "required": [
      "version",
      "tools"
    ],
    "if": {
      "properties": {
        "version": {
          "const": 1
        }
      }
    },
    "then": {
      "properties": {
        "name": {
          "not": {}
        }
      }
    }
}

  "required": [
    "version",
    "tools"
  ],
  "if": {
    "properties": {
      "version": {
        "const": 1
      }
    }
  },
  "then": {
    "definitions": {
      "tool": {
        "properties": {
          "name": {
            "not": {}
          }
        }
      }
    }
  }
}

  "required": [
    "version",
    "tools"
  ],
  "if": {
    "properties": {
      "version": {
        "const": 1
      }
    }
  },
  "then": {
    "definitions": {
      "tool": {
        "not": {
          "required": ["name"]
        }
      }
    }
  }
}

Here are some examples of valid json:

// A
{
  "version": 2,
  "tools": [
    {
      "name": "Tool1",
      "type": "TypeA"
    },
    {
      "type": "TypeB"
    }
  ]
}

// B
{
  "version": 1,
  "tools": [
    {
      "type": "TypeA"
    },
    {
      "type": "TypeB"
    }
  ]
}

And some of the invalid json:

// A
{
  "version": 1,
  "tools": [
    {
      "name": "Tool1",
      "type": "TypeA"
    },
    {
      "type": "TypeB"
    }
  ]
}

The if clause works fine, and recognizes the change, but the else clause is either not being recognized or refers to required list of the root (where "version" and "tools" is specified).

I discovered that the condition works smoothly if the nested tool data structure is in the root properties keyword. But since it is a standalone data structure in definitions, the condition is unable to see there.

It may be my bad, in that case, please help me to figure this out. In other case take this as a reported bug.

Thanks for your help, Marek

[Relequestual]

No problem, we got you.
This becomes easier to understand when you think about applicability and applicators.
Both if and then are applicator keywords, as is properties and items.

You got close on your second try. What you have to consider is you need to define if and then at the level at which it can see down to all locations in the instance it needs to know about.

Your then clause needs to look like this:

"then": {
  "properties": {
    "tools": {
      "items": {
        "not": {
          "required": [
            "name"
          ]
        }
      }
    }
  }
}

You can see it working here: https://jsonschema.dev/s/Z8UqI

If you want to understand more about how to think with applicators, we have an article about that: https://json-schema.org/blog/posts/applicability-json-schema-fundamentals-part-1

[mfialaf]

@Relequestual Thank you so much. After your explanation I understood how the tree structure works, and I have a working schema!

If I may have a follow-up question.

This is my working condition:

  "if":{
    "properties":{
      "version":{
        "const":1
      }
    }
  },
  "then":{
    "properties":{
      "tools":{
        "items":{
          "properties":{
            "versions":{
              "items":{
                "allOf":[
                  {
                    "properties":{
                      "InfoA":{
                        "not":{
                          "required":[
                            "name"
                          ]
                        }
                      }
                    }
                  },
                  {
                    "properties":{
                      "InfoB":{
                        "not":{
                          "required":[
                            "name"
                          ]
                        }
                      }
                    }
                  },
                  {
                    "properties":{
                      "InfoC":{
                        "not":{
                          "required":[
                            "name"
                          ]
                        }
                      }
                    }
                  }
                ]
              }
            }
          }
        }
      }
    }
  }

But it is quite long. In real case, it has even more items in the allOf list.
My question is: Is there a way to shorten my code?

To give you more context

// Schema that references items that apply in "items" allOf
"versionInfo":{
    "type":"object",
    "properties":{
      "name":{
        "description":"Version ...",
        "type":"string"
      },
      "InfoA":{
        "$ref":"#/definitions/DownloadInfo"
      },
      "InfoB":{
        "$ref":"#/definitions/DownloadInfo"
      },
      "InfoC":{
        "$ref":"#/definitions/DownloadInfo"
      }
    }
  }

// Schema that references in each Info(A,B,C)
// #/definitions/DownloadInfo
"DownloadInfo": {
    "description": "Info about download ...",
    "type": "object",
    "properties": {
      "type": {
        "type": "string",
        "description": "Download type"
      },
      "name": {
        "type": "string",
        "description": "Download name"
      }
    },
    "required": [
      "type"
    ]
  }

Thanks again, with helping me!

[Relequestual]

Well you could combine that allOf into a single schema. properties keyword can have multiple properties, just like normal.

I'm not sure otherwise. If you can share the full real schema, a few real example instances, and explain the rules you need to check, I may be able to help further.

Sometimes things omitted in providing simplified versions are actually important 😅. No promises, but we can look.

[mfialaf]

Hi @Relequestual , so I uploaded here: https://jsonschema.dev/s/HFTtn the schema with an passing example. Basically the condition is the same: If version is 1, field "rename_dist" must not be present in any of the version items.

It works as it should now (passes and fails if version is 1). But the condition is incredibly long. Can you please take a look if it may be shortened?

[Relequestual]

It looks like you want ANY object to not include that specific key ("rename_dist").
So, you could use additionalProperties, as this applies to all properties if properties and patternProperties are not used in the same schema object.

Like this... (https://jsonschema.dev/s/F4kyK)

"then": {
    "properties": {
      "tools": {
        "items": {
          "properties": {
            "versions": {
              "items": {
                "additionalProperties": {
                  "not": {
                    "required": [
                      "rename_dist"
                    ]
                  }
                }
              }
            }
          }
        }
      }
    }
  }

[mfialaf]

Thank you again! For helping me with the initial request and also solving my issues further.

Just to finish this Q&A so it can be closed.
You figured out how to shorten the condition, but your suggestion did not work correctly. It showed an error even when none of the #/definitions/versionInfo contained rename_dist. It was some false positive error complaining about name and status properties.
The error:

I figured out to implement a workaround with patternProperties, so properties name and status are not being counted in the condition.

Like this: https://jsonschema.dev/s/0tvLp. Now it complains only about properties it should.

  "then":{
    "properties":{
      "tools":{
        "items":{
          "properties":{
            "versions":{
              "items":{
                "patternProperties":{
                  "^name":{},
                  "^status":{}
                },
                "additionalProperties":{
                  "not":{
                    "required":[
                      "rename_dist"
                    ]
                  }
                }
              }
            }
          }
        }
      }
    }
  }
}

This Q&A can be closed now from my site.

[Relequestual]

Took me a moment, but you could get round this by adding "type": "object" to the not subschema. You wouldn't then need patternProperties.