SchemaSafe JSON Safe Parser & Schema Validator

The unevaluatedProperties keyword allows you to restrict an object to only the properties that were evaluated by subschemas (like properties, patternProperties, or additionalProperties). When nesting unevaluatedProperties within allOf or other combinators, the behavior depends on whether the outer or inner schema controls the restriction.

Nested: Outer false, Inner true

If the outer schema sets unevaluatedProperties: false and an inner allOf branch sets unevaluatedProperties: true, the outer restriction typically dominates the final validation result for the object.

Nested: Outer true, Inner false

If the outer schema sets unevaluatedProperties: true but an inner branch in allOf sets unevaluatedProperties: false, the inner branch will restrict the object to only the properties defined within that specific branch.

Cousin schemas in allOf

When using allOf, multiple schemas act as 'cousins'. If one branch defines properties and another branch sets unevaluatedProperties: false, the resulting validation will only allow properties that satisfy the requirements of the branches that actually evaluated them.

{
  "type": "object",
  "allOf": [
    {
      "properties": { "foo": { "type": "string" } },
      "unevaluatedProperties": false
    }
  ],
  "unevaluatedProperties": true
}

The dependencies keyword allows you to specify that if a certain property is present in the data, other properties must also be present. This can be used with simple arrays of property names or with complex subschemas.

Single Dependency

If property bar exists, property foo must also exist.

Multiple Dependents

If property quux exists, both foo and bar must also exist.

Boolean Subschemas

You can use boolean values within dependencies. For example, setting a dependency to false effectively means that if the key is present, validation fails (often used to forbid certain keys). Note that using true as a subschema may trigger strong mode notices depending on your configuration.

// Single dependency: if 'bar' exists, 'foo' must exist
{ "dependencies": { "bar": ["foo"] } }

// Multiple dependents: if 'quux' exists, 'foo' and 'bar' must exist
{ "dependencies": { "quux": ["foo", "bar"] } }

// Boolean subschemas
{ "dependencies": { "foo": true, "bar": false } }

When using patternProperties in an object schema, the regex patterns are applied to the object keys. Be aware of the following behaviors:

1. Unicode Semantics: Patterns like \p{Letter} will use Unicode semantics if the u flag is present.
2. \w behavior: The \w shorthand matches [A-Za-z0-9_] and does not match Unicode letters.
3. \d behavior: The \d shorthand matches [0-9] and does not match Unicode digits (use \p{digit} for Unicode digits).
4. Anchoring: For predictable key validation, it is recommended to anchor patterns with ^ and $ (e.g., ^\p{Letter}cole$).

Strong mode notices:

• [requireValidation] schema = true is not allowed when using certain patterns in patternProperties.
• [complexityChecks] maxLength should be specified for complex patterns.

{
  "type": "object",
  "patternProperties": { "\\p{Letter}cole": true },
  "additionalProperties": false
}

You can reference external JSON schemas using the $ref keyword with a URI. This allows for modular schema design where parts of a schema are hosted at different locations.

Remote Reference Types

1. Full Remote Reference: Points to an entire external schema file.

   • Schema: { "$ref": "http://localhost:1234/integer.json" }

2. Fragment within Remote Reference: Points to a specific definition or fragment inside an external schema file using a hash (#).

   • Schema: { "$ref": "http://localhost:1234/subSchemas.json#/definitions/integer" }

3. Nested Reference: A remote reference that points to a fragment which itself contains further references.

   • Schema: { "$ref": "http://localhost:1234/subSchemas.json#/definitions/refToInteger" }

4. Root Ref in Remote Ref: A schema that uses an id to establish its own base URI, then uses $ref to point to a fragment in another remote file.

   • Schema:

     {
       "id": "http://localhost:1234/object",
       "type": "object",
       "properties": { "name": { "$ref": "name.json#/definitions/orNull" } }
     }

The dependentRequired keyword (from the JSON Schema Draft 2019-09 specification) is used to specify that if a certain property is present in an object, then other specific properties must also be present.

Single Dependency

To require that if bar exists, foo must also exist:

{ "dependentRequired": { "bar": ["foo"] } }

Multiple Dependents

To require that if quux exists, both foo and bar must also exist:

{ "dependentRequired": { "quux": ["foo", "bar"] } }

Empty Dependents

If the array of required properties is empty, the validation always passes (it effectively does nothing):

{ "dependentRequired": { "bar": [] } }

Dependencies with Escaped Characters

dependentRequired supports property names containing escaped characters like newlines or quotes:

{ "dependentRequired": { "foo\nbar": ["foo\rbar"], "foo\"bar": ["foo'bar"] } }

When using JSON Schema pattern or patternProperties, the generated validation logic uses ECMA 262 (JavaScript) regular expression semantics. This includes specific behaviors for special characters and shorthand classes:

• The $ anchor: In ECMA 262, $ does not match a trailing newline. To ensure a strict match of the entire string, use ^ and $ anchors.
• Whitespace: \t is converted to a horizontal tab.
• Control Codes: Control codes can be escaped using \cC (upper case) or \cc (lower case).
• Shorthand Classes:
  • \d matches ASCII digits [0-9], not Unicode digits.
  • \D matches everything except ASCII digits.
  • \w matches ASCII letters, digits, and underscores [A-Za-z0-9_], not Unicode letters.
  • \W matches everything except ASCII [A-Za-z0-9_].
  • \s matches whitespace.
  • \S matches everything except whitespace.
• Unicode Support: To use Unicode properties (e.g., \p{Letter} or \p{digit}), ensure the pattern is compatible with Unicode semantics. The generated code uses the u flag in new RegExp(pattern, "u") to support this.