Enforce the required keys based on a regex pattern

[grmnz]

Hello everyone,

I am currently working on a project validating JSON data using JSON Schema. I've encountered a specific scenario for which I'm seeking guidance.

I have data on the following structure:

{"cards": {"Card test 1x": "value1", "another_key": "value2"}}

Here are my validation requirements:

1. The "cards" property can be null and still be considered valid.
2. If "cards" is an object, it must have at least one property.
3. At least one property in "cards" should match the pattern ^Card.* (1|2|3|4|1/4)x$.
4. Other properties in "cards" are allowed but should not match the specified pattern.

I have attempted to create a JSON Schema for this, but I'm facing challenges. Here's the current schema:

{
    "$schema": "http://json-schema.org/draft-07/schema#",
    "type": "object",
    "properties": {
        "cards": {
            "type": [
                "object",
                "null"
            ],
            "minProperties": 1,
            "patternProperties": {
                "^Card.* (1|2|3|4|1/4)x$": {
                    "type": "string"
                }
            }
        }
    }
}

However, it seems that the current schema allows data like {"cards": {"none_pattern_key": "value"}}, which should ideally be considered invalid.

I'm particularly looking for insights or corrections to the schema that would help enforce the required keys based on a regex pattern. Any help or suggestions would be greatly appreciated.

Thanks

[jdesrosiers]

The last constraint isn't possible to express in JSON Schema. There isn't a way to limit how many properties patternProperties can match.

[Reskov]

You may try to achieve one of the pattern properties required by using double negation here.
First, use a negative lookahead regex to validate that the schema does not consist only from properties that are not matched, and after that, use a "not" keyword.

{
    "$schema": "http://json-schema.org/draft-07/schema#",
    "type": "object",
    "properties": {
        "assets": {
            "anyOf": [
                {"type": "null"},
                {
                    "allOf": [
                        {
                            "not": {
                                "propertyNames": {
                                    "pattern": "^(?!Card.* (1|2|3|4|1/4)x$)",
                                }
                            }
                        },
                        {
                            "patternProperties": {
                                ".*": {"type": "string"}
                            },
                        },
                    ]
                },
            ]
        }
    },
}

[gregsdennis]

use a negative lookahead regex

Lookaheads aren't universally supported, so you might have some problems with interoperability (if that matters to you).

[Reskov]

@grmnz @jdesrosiers is right. Suggested schema does not verify the last constraint "Other properties in "cards" are allowed but should not match the specified pattern."

[uzogoduyah]

True

[grmnz]

I assumed that at least one property in 'cards' should match the pattern and other properties (those that do not match the pattern) are allowed. I appreciate the discussion and want to confirm that the provided schema aligns with my expectations.
Thank you for your assistance!

[jdesrosiers]

Great! In that case, here's another approach that uses the double negation trick, but doesn't rely on regex lookaheads and therefore may have wider compatibility across implementations.

{
  "type": ["object", "null"],
  "minProperties": 1,
  "not": {
    "patternProperties": {
      "^Card.* (1|2|3|4|1/4)x$": false
    }
  },
  "patternProperties": {
    "": { "type": "string" }
  }
}

[gladykov]

Came here looking for the same answer. This would make sense to me.