fix: validate literal JSON property names consistently

src/SchemaNode.ts

@@ -140,7 +140,9 @@ export interface SchemaNode extends SchemaNodeMethodsType {
 
     // parsed schema properties (registered by parsers)
     $id?: string;
+    /** Modern definitions, or an alias of definitions when only the legacy keyword is present. */
     $defs?: Record<string, SchemaNode>;
+    definitions?: Record<string, SchemaNode>;
     $ref?: string;
     additionalProperties?: SchemaNode;
     allOf?: SchemaNode[];

src/draft04/keywords/$ref.ts

@@ -34,9 +34,7 @@ function parseRef(node: SchemaNode) {
     node.resolveRef = resolveRef;
 
     // store this node for retrieval by id
-    if (node.context.refs[currentId as string] == null) {
-        node.context.refs[currentId as string] = node;
-    }
+    register(node, currentId ?? "#");
 
     const idChanged = currentId !== node.parent?.$id;
     if (idChanged) {
@@ -82,9 +80,9 @@ function getRef(node: SchemaNode, $ref = node?.$ref): SchemaNode | JsonError | u
     }
 
     // resolve $ref by json-evaluationPath
-    if (node.context.refs[$ref]) {
-        // console.log(`ref resolve ${$ref} from refs`, node.context.refs[$ref].ref);
-        return compileNext(node.context.refs[$ref], node.evaluationPath);
+    const referencedNode = node.context.refs[$ref];
+    if (referencedNode) {
+        return compileNext(referencedNode, node.evaluationPath);
     }
 
     if (node.context.anchors[$ref]) {

src/draft2019-09/keywords/$ref.ts

@@ -51,7 +51,7 @@ export function parseRef(node: SchemaNode) {
     if (node.schema.$ref) {
         node.$ref = resolveUri(currentId, node.schema.$ref);
         if (node.$ref.startsWith("/")) {
-            node.$ref = `#${node.$ref}`;
+            node.$ref = resolveUri(`#${node.$ref}`);
         }
     }
 }
@@ -207,9 +207,8 @@ export default function getRef(node: SchemaNode, $ref = node?.$ref): SchemaNode
             // @todo add utility to resolve schema-pointer to schema
             let currentNode = parentNode;
             for (const item of path) {
-                const property = item === "definitions" ? "$defs" : item;
                 // @ts-expect-error random path
-                currentNode = currentNode[property];
+                currentNode = currentNode[item];
                 if (currentNode == null) {
                     // console.error("REF: FAILED RESOLVING ref json-pointer", fragments[1]);
                     return node.createError("ref-error", {

src/keywords/$defs.ts

@@ -1,3 +1,4 @@
+import { join } from "@sagold/json-pointer";
 import { collectValidationErrors } from "src/utils/collectValidationErrors";
 import { Keyword, ValidationAnnotation } from "../Keyword";
 import { SchemaNode } from "../types";
@@ -23,12 +24,13 @@ export function parseDefs(node: SchemaNode) {
                 })
             );
         } else {
-            node.$defs = node.$defs ?? {};
+            node.$defs = node.$defs ?? Object.create(null);
             Object.keys(node.schema.$defs).forEach((property) => {
+                const propertyPointer = join([property], true).slice(1);
                 node.$defs![property] = node.compileSchema(
                     node.schema.$defs[property],
-                    `${node.evaluationPath}/$defs/${urlEncodeJsonPointerProperty(property)}`,
-                    `${node.schemaLocation}/$defs/${property}`
+                    `${node.evaluationPath}/$defs${propertyPointer}`,
+                    `${node.schemaLocation}/$defs${propertyPointer}`
                 );
                 collectValidationErrors(errors, node.$defs![property]);
             });
@@ -45,22 +47,20 @@ export function parseDefs(node: SchemaNode) {
                 })
             );
         }
-        node.$defs = node.$defs ?? {};
+        const definitions: Record<string, SchemaNode> = node.definitions ?? Object.create(null);
+        node.definitions = definitions;
+        // Keep the legacy alias only when there is no modern definition dictionary.
+        node.$defs = node.$defs ?? definitions;
         Object.keys(node.schema.definitions).forEach((property) => {
-            node.$defs![property] = node.compileSchema(
+            const propertyPointer = join([property], true).slice(1);
+            definitions[property] = node.compileSchema(
                 node.schema.definitions[property],
-                `${node.evaluationPath}/definitions/${urlEncodeJsonPointerProperty(property)}`,
-                `${node.schemaLocation}/definitions/${urlEncodeJsonPointerProperty(property)}`
+                `${node.evaluationPath}/definitions${propertyPointer}`,
+                `${node.schemaLocation}/definitions${propertyPointer}`
             );
-            collectValidationErrors(errors, node.$defs![property]);
+            collectValidationErrors(errors, definitions[property]);
         });
     }
 
     return errors;
 }
-
-function urlEncodeJsonPointerProperty(property: string) {
-    property = property.replace(/~/g, "~0");
-    property = property.replace(/\//g, "~1");
-    return encodeURIComponent(property);
-}

src/keywords/$ref.ts

@@ -70,12 +70,12 @@ export function parseRef(node: SchemaNode) {
     if (node.schema.$ref) {
         node.$ref = resolveUri(currentId, node.schema.$ref);
         if (node.$ref.startsWith("/")) {
-            node.$ref = `#${node.$ref}`;
+            node.$ref = resolveUri(`#${node.$ref}`);
         }
     }
 
     // validate simple ref to definitions
-    if (node.$ref?.startsWith("#/$defs/")) {
+    if (node.$ref && /^#\/(?:\$|%24)defs\//.test(node.$ref)) {
         if (get(node.getNodeRoot().schema, node.$ref) == null) {
             return node.createError("schema-error", {
                 pointer: `${node.schemaLocation}/$ref`,
@@ -272,9 +272,8 @@ export function getRef(node: SchemaNode, $ref = node?.$ref): SchemaNode | JsonEr
             // @todo add utility to resolve schema-pointer to schema
             let currentNode = parentNode;
             for (const item of path) {
-                const property = item === "definitions" ? "$defs" : item;
                 // @ts-expect-error random path
-                currentNode = currentNode[property];
+                currentNode = currentNode[item];
                 if (currentNode == null) {
                     // console.error("REF: FAILED RESOLVING ref json-pointer", fragments[1]);
                     return node.createError("ref-error", {

src/keywords/dependencies.ts

@@ -1,3 +1,4 @@
+import { join } from "@sagold/json-pointer";
 import { isBooleanSchema, isJsonSchema, isSchemaNode, SchemaNode } from "../types";
 import { Keyword, JsonSchemaReducerParams, JsonSchemaValidatorParams, ValidationAnnotation } from "../Keyword";
 import { isObject } from "../utils/isObject";
@@ -37,15 +38,17 @@ export function parseDependencies(node: SchemaNode) {
     for (const property of Object.keys(dependencies)) {
         const schema = dependencies[property] as string[];
         if (isJsonSchema(schema) || isBooleanSchema(schema)) {
-            node.dependentSchemas = node.dependentSchemas ?? {};
+            const propertyPointer = join([property], true).slice(1);
+            node.dependentSchemas =
+                node.dependentSchemas ?? (Object.create(null) as Record<string, SchemaNode | boolean>);
             node.dependentSchemas[property] = node.compileSchema(
                 schema,
-                `${node.evaluationPath}/${KEYWORD}/${property}`,
-                `${node.schemaLocation}/${KEYWORD}/${property}`
+                `${node.evaluationPath}/${KEYWORD}${propertyPointer}`,
+                `${node.schemaLocation}/${KEYWORD}${propertyPointer}`
             );
             collectValidationErrors(errors, node.dependentSchemas[property]);
         } else if (isListOfStrings(schema)) {
-            node.dependentRequired = node.dependentRequired ?? {};
+            node.dependentRequired = node.dependentRequired ?? (Object.create(null) as Record<string, string[]>);
             node.dependentRequired[property] = schema;
         } else {
             errors.push(

src/keywords/dependentRequired.ts

@@ -1,3 +1,4 @@
+import { join } from "@sagold/json-pointer";
 import { Keyword, JsonSchemaValidatorParams, ValidationReturnType, ValidationAnnotation } from "../Keyword";
 import { JsonError, SchemaNode } from "../types";
 import { isListOfStrings } from "../utils/isListOfStrings";
@@ -28,15 +29,15 @@ export function parseDependentRequired(node: SchemaNode) {
     }
 
     const errors: ValidationAnnotation[] = [];
-    node.dependentRequired = {};
+    node.dependentRequired = Object.create(null) as Record<string, string[]>;
     for (const propertyName of Object.keys(schema[KEYWORD])) {
         const list = schema[KEYWORD][propertyName];
         if (isListOfStrings(list)) {
             node.dependentRequired[propertyName] = list;
         } else {
             errors.push(
                 node.createError("schema-error", {
-                    pointer: `${node.schemaLocation}/${KEYWORD}/${propertyName}`,
+                    pointer: `${node.schemaLocation}/${KEYWORD}${join([propertyName], true).slice(1)}`,
                     schema,
                     value: list,
                     message: `Keyword '${KEYWORD}[string]' must be a string[] - received '${typeof list}'`

src/keywords/dependentSchemas.ts

@@ -1,3 +1,4 @@
+import { join } from "@sagold/json-pointer";
 import { mergeSchema } from "../utils/mergeSchema";
 import { isObject } from "../utils/isObject";
 import { isSchemaNode, SchemaNode, JsonSchema, isBooleanSchema } from "../types";
@@ -38,22 +39,23 @@ export function parseDependentSchemas(node: SchemaNode) {
     }
 
     const errors: ValidationAnnotation[] = [];
-    const parsedSchemas: Record<string, boolean | SchemaNode> = {};
+    const parsedSchemas: Record<string, boolean | SchemaNode> = Object.create(null);
     for (const property of Object.keys(dependentSchemas)) {
+        const propertyPointer = join([property], true).slice(1);
         const schema = dependentSchemas[property];
         if (isObject(schema)) {
             parsedSchemas[property] = node.compileSchema(
                 schema,
-                `${node.evaluationPath}/${KEYWORD}/${property}`,
-                `${node.schemaLocation}/${KEYWORD}/${property}`
+                `${node.evaluationPath}/${KEYWORD}${propertyPointer}`,
+                `${node.schemaLocation}/${KEYWORD}${propertyPointer}`
             );
             collectValidationErrors(errors, parsedSchemas[property]);
         } else if (isBooleanSchema(schema)) {
             parsedSchemas[property] = schema;
         } else {
             errors.push(
                 node.createError("schema-error", {
-                    pointer: `${node.schemaLocation}/${KEYWORD}/${property}`,
+                    pointer: `${node.schemaLocation}/${KEYWORD}${propertyPointer}`,
                     schema: node.schema,
                     value: schema,
                     message: `Keyword '${KEYWORD}[string]' must be a valid JSON Schema'`
@@ -79,7 +81,7 @@ export function reduceDependentSchemas({ node, data }: JsonSchemaReducerParams)
         if (dependentSchemas[propertyName] == null) {
             return;
         }
-        mergedSchema = mergedSchema ?? { properties: {} };
+        mergedSchema = mergedSchema ?? { properties: Object.create(null) };
         if (isSchemaNode(dependentSchemas[propertyName])) {
             mergedSchema = mergeSchema(mergedSchema, dependentSchemas[propertyName].schema);
         } else {

src/keywords/patternProperties.ts

@@ -1,3 +1,4 @@
+import { join } from "@sagold/json-pointer";
 import { mergeSchema } from "../utils/mergeSchema";
 import { JsonSchema, SchemaNode } from "../types";
 import { isObject } from "../utils/isObject";
@@ -10,6 +11,7 @@ import {
     ValidationAnnotation
 } from "../Keyword";
 import { getValue } from "../utils/getValue";
+import { hasProperty } from "../utils/hasProperty";
 import { validateNode } from "../validateNode";
 import settings from "../settings";
 import { collectValidationErrors } from "src/utils/collectValidationErrors";
@@ -38,15 +40,18 @@ export function parsePatternProperties(node: SchemaNode) {
         return;
     }
 
-    node.patternProperties = patterns.map((pattern) => ({
-        name: pattern,
-        pattern: new RegExp(pattern, schema.regexFlags ?? REGEX_FLAGS),
-        node: node.compileSchema(
-            schema.patternProperties[pattern],
-            `${node.evaluationPath}/patternProperties/${pattern}`,
-            `${node.schemaLocation}/patternProperties/${pattern}`
-        )
-    }));
+    node.patternProperties = patterns.map((pattern) => {
+        const propertyPointer = join([pattern], true).slice(1);
+        return {
+            name: pattern,
+            pattern: new RegExp(pattern, schema.regexFlags ?? REGEX_FLAGS),
+            node: node.compileSchema(
+                schema.patternProperties[pattern],
+                `${node.evaluationPath}/patternProperties${propertyPointer}`,
+                `${node.schemaLocation}/patternProperties${propertyPointer}`
+            )
+        };
+    });
 
     return collectValidationErrors([], ...node.patternProperties.map(({ node }) => node));
 }
@@ -75,11 +80,13 @@ function reducePatternProperties({ node, data, key }: JsonSchemaReducerParams) {
             return;
         }
         // build schema of property
-        let propertySchema = node.schema.properties?.[propertyName] ?? {};
+        let propertySchema = hasProperty(node.schema.properties ?? {}, propertyName)
+            ? node.schema.properties[propertyName]
+            : {};
         const matchingPatterns = patternProperties.filter((property) => property.pattern.test(propertyName));
         matchingPatterns.forEach((pp) => (propertySchema = mergeSchema(propertySchema, pp.node.schema)));
         if (matchingPatterns.length > 0) {
-            mergedSchema = mergedSchema ?? { properties: {} };
+            mergedSchema = mergedSchema ?? { properties: Object.create(null) };
             mergedSchema.properties[propertyName] = propertySchema;
             dynamicId += `${matchingPatterns.map(({ name }) => `patternProperties/${name}`).join(",")}`;
         }
@@ -109,7 +116,7 @@ function validatePatternProperties({ node, data, pointer, path }: JsonSchemaVali
         const matchingPatterns = patternProperties!.filter((property) => property.pattern.test(key));
         matchingPatterns.forEach(({ node }) => errors.push(...validateNode(node, value, `${pointer}/${key}`, path)));
 
-        if (properties[key]) {
+        if (hasProperty(properties, key)) {
             return;
         }
 

src/keywords/properties.ts

@@ -1,3 +1,4 @@
+import { join } from "@sagold/json-pointer";
 import { getValue } from "../utils/getValue";
 import { SchemaNode } from "../types";
 import {
@@ -41,12 +42,13 @@ export function parseProperties(node: SchemaNode) {
     }
 
     const errors: ValidationAnnotation[] = [];
-    const parsedProperties: Record<string, SchemaNode> = {};
+    const parsedProperties: Record<string, SchemaNode> = Object.create(null);
     Object.keys(schema.properties).forEach((propertyName) => {
+        const propertyPointer = join([propertyName], true).slice(1);
         const propertyNode = node.compileSchema(
             schema.properties[propertyName],
-            `${evaluationPath}/properties/${propertyName}`,
-            `${schemaLocation}/properties/${propertyName}`
+            `${evaluationPath}/properties${propertyPointer}`,
+            `${schemaLocation}/properties${propertyPointer}`
         );
         parsedProperties[propertyName] = propertyNode;
         collectValidationErrors(errors, parsedProperties[propertyName]);

src/keywords/propertyDependencies.ts

@@ -1,3 +1,4 @@
+import { join } from "@sagold/json-pointer";
 import { collectValidationErrors } from "src/utils/collectValidationErrors";
 import {
     Keyword,
@@ -86,11 +87,12 @@ function parsePropertyDependencies(node: SchemaNode) {
     const parsed: Record<string, Record<string, SchemaNode>> = Object.create(null);
     const errors: ValidationAnnotation[] = [];
     Object.keys(propertyDependencies).map((propertyName) => {
+        const propertyPointer = join([propertyName], true).slice(1);
         const values = propertyDependencies[propertyName];
         if (!isObject(values)) {
             errors.push(
                 node.createError("schema-error", {
-                    pointer: `${node.schemaLocation}/${KEYWORD}/${propertyName}`,
+                    pointer: `${node.schemaLocation}/${KEYWORD}${propertyPointer}`,
                     schema: node.schema,
                     value: propertyDependencies,
                     message: `Keyword '${KEYWORD}[string]' must be an object - received '${typeof propertyDependencies}'`
@@ -99,11 +101,12 @@ function parsePropertyDependencies(node: SchemaNode) {
             return;
         }
         Object.keys(values).forEach((value) => {
+            const schemaPointer = `${propertyPointer}${join([value], true).slice(1)}`;
             const schema = values[value];
             if (!(isJsonSchema(schema) || isBooleanSchema(schema))) {
                 errors.push(
                     node.createError("schema-error", {
-                        pointer: `${node.schemaLocation}/${KEYWORD}/${propertyName}/${value}`,
+                        pointer: `${node.schemaLocation}/${KEYWORD}${schemaPointer}`,
                         schema: node.schema,
                         value: schema,
                         message: `Keyword '${KEYWORD}[string][string]' must be a valid JSON Schema - received '${typeof schema}'`
@@ -114,8 +117,8 @@ function parsePropertyDependencies(node: SchemaNode) {
             parsed[propertyName] = parsed[propertyName] ?? Object.create(null);
             parsed[propertyName][value] = node.compileSchema(
                 schema,
-                `${node.evaluationPath}/${KEYWORD}/${propertyName}/${value}`,
-                `${node.schemaLocation}/${KEYWORD}/${propertyName}/${value}`
+                `${node.evaluationPath}/${KEYWORD}${schemaPointer}`,
+                `${node.schemaLocation}/${KEYWORD}${schemaPointer}`
             );
             collectValidationErrors(errors, parsed[propertyName][value]);
         });

src/mergeNode.test.ts

@@ -46,6 +46,36 @@ describe("mergeNode", () => {
         assert.deepEqual(errors.length, 1);
     });
 
+    it("keeps modern and legacy definitions separate when merging nodes", () => {
+        const node = mergeNode(
+            compileSchema({ definitions: { item: { type: "string", maxLength: 2 } } }),
+            compileSchema({ $defs: { item: { type: "string", minLength: 3 } } })
+        );
+        assert.ok(node);
+        assert.equal(node.$defs?.item.validate("text").valid, true);
+        assert.equal(node.$defs?.item.validate(2).valid, false);
+        assert.equal(node.$defs?.item.validate("ab").valid, false);
+        assert.equal(node.definitions?.item.validate("ab").valid, true);
+        assert.equal(node.definitions?.item.validate("text").valid, false);
+        assert.equal(node.definitions?.item.validate(2).valid, false);
+        assert.deepEqual(node.toSchemaNodes(), [node, node.$defs?.item, node.definitions?.item]);
+    });
+
+    it("merges legacy dictionaries without duplicating their compatibility alias", () => {
+        const node = mergeNode(
+            compileSchema({ definitions: { first: { type: "string" } } }),
+            compileSchema({ definitions: { second: { type: "number" } } })
+        );
+        assert.ok(node);
+        assert.deepEqual(Object.keys(node.definitions ?? {}), ["first", "second"]);
+        assert.equal(node.$defs, node.definitions);
+        assert.deepEqual(node.toSchemaNodes(), [node, node.definitions?.first, node.definitions?.second]);
+        assert.equal(node.definitions?.first.validate("text").valid, true);
+        assert.equal(node.definitions?.first.validate(7).valid, false);
+        assert.equal(node.definitions?.second.validate(7).valid, true);
+        assert.equal(node.definitions?.second.validate("text").valid, false);
+    });
+
     describe("omit", () => {
         it("should omit oneOf node- and schema-property", () => {
             const a = compileSchema({