If-Then for various forms of an Address

[alc-aardvark]

I have been trying to work out how to write the json-schema using If-Then and OneOf so that I can vary the Address property based on IsoCountryCode

example data (for a Canadian Address format

{
  "Name": "Test",
  "Email": "[email protected]",
  "Phone": "011111111111",
  "IsoCountryCode": "CA",
  "Address": {
    "AddressMultiline": "123 Avalon Street",
    "City": "123 Avalon street",
    "Region": "South Zone",
    "PostalCode": "12345"
  }
}

There are different Address objects for US, UK, CA etc with each having differences in their properties, Enums, regex patterns etc.

Here is an example of an attempt at it

{
  "type": "object",
  "properties": {
    "Name": {
      "type": "string",
      "maxLength": 195,
      "pattern": "^[a-zA-Z0-9 ]\u002B$"
    },
    "Email": {
      "type": "string",
      "format": "email",
      "maxLength": 255
    },
    "Phone": {
      "type": "string",
      "pattern": "^[a-zA-Z0-9 ]\u002B$"
    },
    "IsoCountryCode": {
      "type": "string",
      "minLength": 2,
      "maxLength": 2
    }
  },
  "oneOf": [
    {
      "if": {
        "properties": {
          "IsoCountryCode": {
            "const": "CA"
          }
        }
      },
      "then": {
        "properties": {
          "Address": {
            "description": "Canada Address",
            "type": "object",
            "properties": {
              "AddressMultiline": {
                "type": "string",
                "maxLength": 500,
                "pattern": "^[a-zA-Z0-9 ]\u002B$"
              },
              "City": {
                "type": "string",
                "maxLength": 255,
                "pattern": "^[a-zA-Z0-9 ]\u002B$"
              },
              "Region": {
                "type": "string",
                "maxLength": 255
              },
              "PostalCode": {
                "type": "string",
                "maxLength": 50,
                "pattern": "^[a-zA-Z0-9 ]\u002B$"
              }
            },
            "required": [
              "AddressMultiline",
              "Region"
            ]
          }
        }
      }
    },
    {
      "if": {
        "properties": {
          "IsoCountryCode": {
            "const": "GB"
          }
        }
      },
      "then": {
        "properties": {
          "Address": {
            "description": "United Kingdom Address",
            "type": "object",
            "properties": {
              "AddressMultiline": {
                "type": "string",
                "maxLength": 500,
                "pattern": "^[a-zA-Z0-9 ]\u002B$"
              },
              "City": {
                "type": "string",
                "maxLength": 255,
                "pattern": "^[a-zA-Z0-9 ]\u002B$"
              },
              "PostalCode": {
                "type": "string",
                "maxLength": 50,
                "pattern": "^[a-zA-Z0-9 ]\u002B$"
              }
            },
            "required": [
              "AddressMultiline",
              "City",
              "PostalCode"
            ]
          }
        }
      }
    },
    {
      "if": {
        "properties": {
          "IsoCountryCode": {
            "const": "US"
          }
        }
      },
      "then": {
        "properties": {
          "Address": {
            "description": "United States Address",
            "type": "object",
            "properties": {
              "AddressMultiline": {
                "type": "string",
                "maxLength": 500,
                "pattern": "^[a-zA-Z0-9 ]\u002B$"
              },
              "City": {
                "type": "string",
                "maxLength": 255,
                "pattern": "^[a-zA-Z0-9 ]\u002B$"
              },
              "Region": {
                "type": "string",
                "maxLength": 255
              },
              "PostalCode": {
                "type": "string",
                "maxLength": 50,
                "pattern": "^[a-zA-Z0-9 ]\u002B$"
              }
            },
            "required": [
              "AddressMultiline",
              "City",
              "Region",
              "PostalCode"
            ]
          }
        }
      }
    }
  ],
  "required": [
    "Name",
    "Email",
    "Phone",
    "IsoCountryCode",
    "Address"
  ],
  "additionalProperties": false
}

NB. I have not attempted to add a Default Address in this example to keep it from becoming too complex.

Behavior

1. Expect Valid
   If I validate the above (Good) data against the schema using JsonSchema.Net, then it says that the result.IsValid is FALSE and there are no Errors. The Details node is also empty so no errors in any lower level nodes.

2. Expect Invalid and 1 Error
   If I change the data and put invalid characters into the Address.City (e.g. <> chars) and Validate it, then I get result.IsValid is FALSE (as expected), but I also get 5 errors when i am only expecting to get the one pattern error for the Address.City.

The 5 errors are

• "oneOf" :: Expected 1 matching subschema but found 2 (for the InstanceLocation: )
• "pattern" :: The string value is not a match for the indicated regular expression (for the InstanceLocation: /Address/City)
• "const" :: Expected "GB" (for the InstanceLocation: /IsoCountryCode)
• "const" :: Expected "US" (for the InstanceLocation: /IsoCountryCode)
• "" :: All values fail against the false schema (for the instanceLocation: /Address )

[gregsdennis]

Can you update your question with what's not working for you? Are there examples of data that should pass but don't, or data that should fail but don't?

[jdesrosiers]

You need to use allOf, not oneOf. When the if fails, the schema doesn't fail. It's only used to determine whether or not the then applies. That means the schema only fails if the if passes and the then fails. So, assuming the JSON instance has "IsoCountryCode": "CA" and a valid Canadian address, the first schema will pass because if = pass and then = pass, the second and third schema will pass because if = fail and there's no else. That means your oneOf evaluates as "oneOf": [true, true, true], which fails because there's more than one schema passing and oneOf only allows one schema to be passing.

[jdesrosiers]

You use "additionalProperties": false, but "Address" isn't declared at the same level as additionalProperties. I'm sure that's what that last error message is telling you. You can add "Address": true to your top level properties so additionalProperties knows that property is allowed.

[alc-aardvark]

Hey @jdesrosiers That is getting really close to my desired result now (Thanks!).

The Success test now passes.

The invalid chars test now has 3 errors (1 expected and 2 not expected)

Expected

• "pattern" :: The string value is not a match for the indicated regular expression (for the InstanceLocation: /Address/City)

Not Expected

• "const" :: Expected "GB" (for the InstanceLocation: /IsoCountryCode)
• "const" :: Expected "US" (for the InstanceLocation: /IsoCountryCode)

[jdesrosiers]

These extra errors are a quirk of the specific JSON Schema implementation you're using. I don't expect that most implementations would return those errors. There's nothing wrong with your schema that's causing them. You'll need to inquire with the maintainer(s) of that implementation if you want something done about that.

[alc-aardvark]

So if I do a test where City is Null (and not sent in the json data at all), then as City is not mandatory for the Canadian address, then I expect it to be Valid. But I get the two validation errors

• "const" :: Expected "GB" (for the InstanceLocation: /IsoCountryCode)
• "const" :: Expected "US" (for the InstanceLocation: /IsoCountryCode)

[jdesrosiers]

Again, that seem to be a quirk of whatever JSON Schema library you're using. You'll need to ask them. However, it does lead me to something else I can bring to your attention. Try a test where there is no "IsoCountryCode". All of your if schemas will pass leading to all of the then schemas getting evaluated. This won't effect the pass/fail result of the validation, but it can effect the error messages you get. For this reason, you should always include required and type in your if schemas so they fail if the property isn't present.

"if": {
  "type": "object",
  "properties": {
    "IsoCountryCode": { "const": "CA"}
  },
  "required": ["IsoCountryCode"]
}

This if schema will fail if the "IsoCountryCode" schema isn't present or if the JSON instance isn't even an object. That's the behavior we want in this case. If there's no "IsoCountryCode" none of the thens should be applied.

[alc-aardvark]

I have recreated the test scenario in a clone of the JsonScema.Net repo. Debugging the scenario shows me that when it tests the If condition then for the ones that fail, it creates an error and marks the entire validation as failed. I would have expected it to simply return from this 'IF branch' as it is FALSE.

snippet of one of the If branches that causes a validation error (when processing a 'CA' IsoCountryCode

      "if": {
        "properties": {
          "IsoCountryCode": {
            "const": "GB"
          }
        }
      }

[jdesrosiers]

This might help you understand the output a little better, https://json-schema.org/blog/posts/interpreting-output

[alc-aardvark]

After a bit of team mobbing, we now understand the api a little bit better. I have more testing to do but it looks good if used correctly.

It runs in 3 modes (Flag, List, Hierarchical) and based on this mode the error information is either Not given (Flag), Flattened (List) or in the Node hierarchy (Hierarchical).

Now what was not so obvious is that when in the Hierarchical mode, then you cant simply hoover up all of the errors after recursing through the nodes. You need to stop recursing if any node says that it IsValid = true. Now there may be error nodes below this Valid node but you should not include them as they are these additional errors that I am seeing.

If in List mode, then you see all of the errors including these false positive errors. In Flag mode then there is no error information.