@hyperjump/json-schema 1.13.0 → 1.14.0

package/lib/keywords/properties.js

@@ -18,36 +18,20 @@ const interpret = (properties, instance, context) => {
   }
 
   let isValid = true;
-  for (const [propertyNameNode, property] of Instance.entries(instance)) {
-    const propertyName = Instance.value(propertyNameNode);
-    if (propertyName in properties && !Validation.interpret(properties[propertyName], property, context)) {
-      isValid = false;
-    }
-  }
-
-  return isValid;
-};
-
-const simpleApplicator = true;
-
-const collectEvaluatedProperties = (properties, instance, context) => {
-  if (Instance.typeOf(instance) !== "object") {
-    return false;
-  }
-
-  const evaluatedPropertyNames = new Set();
   for (const [propertyNameNode, property] of Instance.entries(instance)) {
     const propertyName = Instance.value(propertyNameNode);
     if (propertyName in properties) {
       if (!Validation.interpret(properties[propertyName], property, context)) {
-        return false;
+        isValid = false;
       }
 
-      evaluatedPropertyNames.add(propertyName);
+      context.evaluatedProperties?.add(propertyName);
     }
   }
 
-  return evaluatedPropertyNames;
+  return isValid;
 };
 
-export default { id, compile, interpret, simpleApplicator, collectEvaluatedProperties };
+const simpleApplicator = true;
+
+export default { id, compile, interpret, simpleApplicator };

package/lib/keywords/propertyDependencies.js

@@ -43,23 +43,4 @@ const interpret = (propertyDependencies, instance, context) => {
 
 const simpleApplicator = true;
 
-const collectEvaluatedProperties = (propertyDependencies, instance, context) => {
-  const evaluatedPropertyNames = new Set();
-  for (const propertyName in propertyDependencies) {
-    const propertyValue = Instance.value(instance)[propertyName];
-
-    const valueMappings = propertyDependencies[propertyName];
-    if (Instance.has(propertyName, instance) && propertyValue in valueMappings) {
-      const propertyNames = Validation.collectEvaluatedProperties(valueMappings[propertyValue], instance, context);
-      if (!propertyNames) {
-        return false;
-      }
-
-      propertyNames.forEach(evaluatedPropertyNames.add, evaluatedPropertyNames);
-    }
-  }
-
-  return evaluatedPropertyNames;
-};
-
-export default { id, compile, interpret, simpleApplicator, collectEvaluatedProperties };
+export default { id, compile, interpret, simpleApplicator };

package/lib/keywords/propertyNames.js

@@ -13,7 +13,7 @@ const interpret = (propertyNames, instance, context) => {
 
   let isValid = true;
   for (const key of Instance.keys(instance)) {
-    if (!Validation.interpret(propertyNames, key, { ...context, annotations: [] })) {
+    if (!Validation.interpret(propertyNames, key, context)) {
       isValid = false;
     }
   }

package/lib/keywords/ref.js

@@ -5,9 +5,7 @@ const id = "https://json-schema.org/keyword/ref";
 
 const compile = (...args) => Validation.compile(...args);
 const interpret = (...args) => Validation.interpret(...args);
-const collectEvaluatedProperties = (...args) => Validation.collectEvaluatedProperties(...args);
-const collectEvaluatedItems = (...args) => Validation.collectEvaluatedItems(...args);
 
 const simpleApplicator = true;
 
-export default { id, compile, interpret, simpleApplicator, collectEvaluatedProperties, collectEvaluatedItems };
+export default { id, compile, interpret, simpleApplicator };

package/lib/keywords/then.js

@@ -1,5 +1,4 @@
 import * as Browser from "@hyperjump/browser";
-import { FLAG } from "../index.js";
 import { getKeywordName, Validation } from "../experimental.js";
 
 
@@ -17,26 +16,10 @@ const compile = async (schema, ast, parentSchema) => {
 
 const interpret = ([ifSchema, thenSchema], instance, context) => {
   return ifSchema === undefined
-    || !Validation.interpret(ifSchema, instance, { ...context, errors: [], annotations: [], outputFormat: FLAG })
+    || !Validation.interpret(ifSchema, instance, { ...context, plugins: context.ast.plugins })
     || Validation.interpret(thenSchema, instance, context);
 };
 
 const simpleApplicator = true;
 
-const collectEvaluatedProperties = ([ifSchema, thenSchema], instance, context) => {
-  if (ifSchema === undefined || !Validation.interpret(ifSchema, instance, context)) {
-    return new Set();
-  }
-
-  return Validation.collectEvaluatedProperties(thenSchema, instance, context);
-};
-
-const collectEvaluatedItems = ([ifSchema, thenSchema], instance, context) => {
-  if (ifSchema === undefined || !Validation.interpret(ifSchema, instance, context)) {
-    return new Set();
-  }
-
-  return Validation.collectEvaluatedItems(thenSchema, instance, context);
-};
-
-export default { id, compile, interpret, simpleApplicator, collectEvaluatedProperties, collectEvaluatedItems };
+export default { id, compile, interpret, simpleApplicator };

package/lib/keywords/unevaluatedItems.js

@@ -1,5 +1,3 @@
-import { zip, range } from "@hyperjump/pact";
-import { FLAG } from "../index.js";
 import { canonicalUri, Validation } from "../experimental.js";
 import * as Instance from "../instance.js";
 
@@ -15,17 +13,33 @@ const interpret = ([schemaUrl, unevaluatedItems], instance, context) => {
     return true;
   }
 
-  const keywordContext = { ...context, errors: [], annotations: [], outputFormat: FLAG };
-  const itemIndexes = Validation.collectEvaluatedItems(schemaUrl, instance, keywordContext, true);
-  if (itemIndexes === false) {
+  if (context.rootSchema === schemaUrl) {
+    return true;
+  }
+
+  // Because order matters, we re-evaluate this schema skipping this keyword
+  // just to collect all the evalauted items.
+  const keywordContext = {
+    ...context,
+    plugins: [...context.ast.plugins, unevaluatedPlugin],
+    rootSchema: schemaUrl
+  };
+  if (!Validation.interpret(schemaUrl, instance, keywordContext)) {
     return true;
   }
 
   let isValid = true;
-  for (const [item, index] of zip(Instance.iter(instance), range(0))) {
-    if (!itemIndexes.has(index) && !Validation.interpret(unevaluatedItems, item, context)) {
-      isValid = false;
+  let index = 0;
+  for (const item of Instance.iter(instance)) {
+    if (!keywordContext.evaluatedItems.has(index)) {
+      if (!Validation.interpret(unevaluatedItems, item, context)) {
+        isValid = false;
+      }
+
+      context.evaluatedItems?.add(index);
     }
+
+    index++;
   }
 
   return isValid;
@@ -33,19 +47,29 @@ const interpret = ([schemaUrl, unevaluatedItems], instance, context) => {
 
 const simpleApplicator = true;
 
-const collectEvaluatedItems = (keywordValue, instance, context) => {
-  const itemIndexes = Validation.collectEvaluatedItems(keywordValue[0], instance, context, true);
-  if (!itemIndexes) {
-    return false;
-  }
-
-  const evaluatedIndexes = new Set();
-  for (let ndx = 0; ndx < Instance.length(instance); ndx++) {
-    if (!itemIndexes.has(ndx)) {
-      evaluatedIndexes.add(ndx);
+const unevaluatedPlugin = {
+  beforeSchema(_url, _instance, context) {
+    context.evaluatedItems ??= new Set();
+    context.schemaEvaluatedItems ??= new Set();
+  },
+  beforeKeyword(_node, _instance, context, schemaContext) {
+    context.rootSchema = schemaContext.rootSchema;
+    context.evaluatedItems = new Set();
+  },
+  afterKeyword(_node, _instance, context, valid, schemaContext) {
+    if (valid) {
+      for (const index of context.evaluatedItems) {
+        schemaContext.schemaEvaluatedItems.add(index);
+      }
+    }
+  },
+  afterSchema(_url, _instance, context, valid) {
+    if (valid) {
+      for (const index of context.schemaEvaluatedItems) {
+        context.evaluatedItems.add(index);
+      }
     }
   }
-  return evaluatedIndexes;
 };
 
-export default { id, compile, interpret, simpleApplicator, collectEvaluatedItems };
+export default { id, compile, interpret, simpleApplicator };

package/lib/keywords/unevaluatedProperties.js

@@ -1,4 +1,3 @@
-import { FLAG } from "../index.js";
 import { Validation, canonicalUri } from "../experimental.js";
 import * as Instance from "../instance.js";
 
@@ -14,18 +13,33 @@ const interpret = ([schemaUrl, unevaluatedProperties], instance, context) => {
     return true;
   }
 
-  const keywordContext = { ...context, errors: [], annotations: [], outputFormat: FLAG };
-  const evaluatedPropertyNames = Validation.collectEvaluatedProperties(schemaUrl, instance, keywordContext, true);
-  if (evaluatedPropertyNames === false) {
+  if (context.rootSchema === schemaUrl) {
+    return true;
+  }
+
+  // Because order matters, we re-evaluate this schema skipping this keyword
+  // just to collect all the evalauted properties.
+  const keywordContext = {
+    ...context,
+    plugins: [...context.ast.plugins, unevaluatedPlugin],
+    rootSchema: schemaUrl
+  };
+  if (!Validation.interpret(schemaUrl, instance, keywordContext)) {
     return true;
   }
 
   let isValid = true;
   for (const [propertyNameNode, property] of Instance.entries(instance)) {
     const propertyName = Instance.value(propertyNameNode);
-    if (!evaluatedPropertyNames.has(propertyName) && !Validation.interpret(unevaluatedProperties, property, context)) {
+    if (keywordContext.evaluatedProperties.has(propertyName)) {
+      continue;
+    }
+
+    if (!Validation.interpret(unevaluatedProperties, property, context)) {
       isValid = false;
     }
+
+    context.evaluatedProperties?.add(propertyName);
   }
 
   return isValid;
@@ -33,29 +47,29 @@ const interpret = ([schemaUrl, unevaluatedProperties], instance, context) => {
 
 const simpleApplicator = true;
 
-const collectEvaluatedProperties = ([schemaUrl, unevaluatedProperties], instance, context) => {
-  if (Instance.typeOf(instance) !== "object") {
-    return true;
-  }
-
-  const evaluatedPropertyNames = Validation.collectEvaluatedProperties(schemaUrl, instance, context, true);
-
-  if (!evaluatedPropertyNames) {
-    return false;
-  }
-
-  for (const [propertyNameNode, property] of Instance.entries(instance)) {
-    const propertyName = Instance.value(propertyNameNode);
-    if (!evaluatedPropertyNames.has(propertyName)) {
-      if (!Validation.interpret(unevaluatedProperties, property, context)) {
-        return false;
+const unevaluatedPlugin = {
+  beforeSchema(_url, _instance, context) {
+    context.evaluatedProperties ??= new Set();
+    context.schemaEvaluatedProperties ??= new Set();
+  },
+  beforeKeyword(_node, _instance, context, schemaContext) {
+    context.rootSchema = schemaContext.rootSchema;
+    context.evaluatedProperties = new Set();
+  },
+  afterKeyword(_node, _instance, context, valid, schemaContext) {
+    if (valid) {
+      for (const property of context.evaluatedProperties) {
+        schemaContext.schemaEvaluatedProperties.add(property);
+      }
+    }
+  },
+  afterSchema(_url, _instance, context, valid) {
+    if (valid) {
+      for (const property of context.schemaEvaluatedProperties) {
+        context.evaluatedProperties.add(property);
       }
-
-      evaluatedPropertyNames.add(propertyName);
     }
   }
-
-  return evaluatedPropertyNames;
 };
 
-export default { id, compile, interpret, simpleApplicator, collectEvaluatedProperties };
+export default { id, compile, interpret, simpleApplicator };

package/lib/keywords/validation.js

@@ -2,10 +2,7 @@ import { value, entries } from "@hyperjump/browser";
 import { pipe, asyncMap, asyncCollectArray } from "@hyperjump/pact";
 import { append as pointerAppend } from "@hyperjump/json-pointer";
 import { publishAsync } from "../pubsub.js";
-import * as Instance from "../instance.js";
-import { toAbsoluteUri } from "../common.js";
-import { canonicalUri, getKeyword, getKeywordByName, BASIC, DETAILED } from "../experimental.js";
-import { FLAG } from "../index.js";
+import { canonicalUri, getKeyword, getKeywordByName } from "../experimental.js";
 
 
 const id = "https://json-schema.org/evaluation/validate";
@@ -35,6 +32,9 @@ const compile = async (schema, ast) => {
       entries(schema),
       asyncMap(async ([keyword, keywordSchema]) => {
         const keywordHandler = getKeywordByName(keyword, schema.document.dialectId);
+        if (keywordHandler.plugin) {
+          ast.plugins.add(keywordHandler.plugin);
+        }
         const keywordAst = await keywordHandler.compile(keywordSchema, ast, schema);
         return [keywordHandler.id, pointerAppend(keyword, canonicalUri(schema)), keywordAst];
       }),
@@ -45,140 +45,42 @@ const compile = async (schema, ast) => {
   return url;
 };
 
-const interpret = (url, instance, { ast, dynamicAnchors, errors, annotations, outputFormat }) => {
-  dynamicAnchors = { ...ast.metaData[toAbsoluteUri(url)].dynamicAnchors, ...dynamicAnchors };
+const interpret = (url, instance, context) => {
+  let valid = true;
 
-  if (typeof ast[url] === "boolean") {
-    if (ast[url]) {
-      return true;
-    } else {
-      errors.push({
-        keyword: id,
-        absoluteKeywordLocation: url,
-        instanceLocation: Instance.uri(instance)
-      });
-      return false;
-    }
-  } else {
-    const schemaAnnotations = [];
+  for (const plugin of context.plugins) {
+    plugin.beforeSchema(url, instance, context);
+  }
 
-    let isSchemaValid = true;
-    for (const [keywordId, schemaUri, keywordValue] of ast[url]) {
-      const context = { ast, dynamicAnchors, errors: [], annotations: [], outputFormat };
-      const keywordHandler = getKeyword(keywordId);
-      const isKeywordValid = keywordHandler.interpret(keywordValue, instance, context);
+  if (typeof context.ast[url] === "boolean") {
+    valid = context.ast[url];
+  } else {
+    for (const node of context.ast[url]) {
+      const [keywordId, , keywordValue] = node;
+      const keyword = getKeyword(keywordId);
+
+      const keywordContext = {
+        ast: context.ast,
+        plugins: context.plugins
+      };
+      for (const plugin of context.plugins) {
+        plugin.beforeKeyword(node, instance, keywordContext, context, keyword);
+      }
+      const isKeywordValid = keyword.interpret(keywordValue, instance, keywordContext);
       if (!isKeywordValid) {
-        isSchemaValid = false;
+        valid = false;
       }
 
-      switch (outputFormat) {
-        case FLAG:
-          break;
-        case BASIC:
-          if (!isKeywordValid) {
-            if (!keywordHandler.simpleApplicator) {
-              errors.push({
-                keyword: keywordId,
-                absoluteKeywordLocation: schemaUri,
-                instanceLocation: Instance.uri(instance)
-              });
-            }
-            errors.push(...context.errors);
-          } else {
-            const annotation = keywordHandler.annotation?.(keywordValue, instance);
-            if (annotation !== undefined) {
-              schemaAnnotations.unshift({
-                keyword: keywordId,
-                absoluteKeywordLocation: schemaUri,
-                instanceLocation: Instance.uri(instance),
-                annotation: annotation
-              });
-            }
-            for (const contextAnnotation of context.annotations) {
-              schemaAnnotations.unshift(contextAnnotation);
-            }
-          }
-          break;
-        case DETAILED: {
-          if (!isKeywordValid) {
-            const outputUnit = {
-              keyword: keywordId,
-              absoluteKeywordLocation: schemaUri,
-              instanceLocation: Instance.uri(instance)
-            };
-
-            errors.push(outputUnit);
-            if (context.errors.length > 0) {
-              outputUnit.errors = context.errors;
-            }
-          }
-          break;
-        }
-        default:
-          throw Error(`Unsupported output format '${outputFormat}'`);
+      for (const plugin of context.plugins) {
+        plugin.afterKeyword(node, instance, keywordContext, isKeywordValid, context, keyword);
       }
     }
-
-    if (outputFormat === BASIC && isSchemaValid) {
-      annotations.push(...schemaAnnotations);
-    }
-
-    return isSchemaValid;
-  }
-};
-
-const emptyPropertyNames = new Set();
-const collectEvaluatedProperties = (url, instance, context, isTop = false) => {
-  if (typeof context.ast[url] === "boolean") {
-    return context.ast[url] ? emptyPropertyNames : false;
-  }
-
-  const accumulatedPropertyNames = new Set();
-  for (const [keywordId, , keywordValue] of context.ast[url]) {
-    if (isTop && keywordId === "https://json-schema.org/keyword/unevaluatedProperties") {
-      continue;
-    }
-
-    const keywordHandler = getKeyword(keywordId);
-    const propertyNames = "collectEvaluatedProperties" in keywordHandler
-      ? keywordHandler.collectEvaluatedProperties(keywordValue, instance, context, isTop)
-      : keywordHandler.interpret(keywordValue, instance, context) && emptyPropertyNames;
-
-    if (propertyNames === false) {
-      return false;
-    }
-
-    propertyNames.forEach(accumulatedPropertyNames.add, accumulatedPropertyNames);
   }
 
-  return accumulatedPropertyNames;
-};
-
-const emptyItemIndexes = new Set();
-const collectEvaluatedItems = (url, instance, context, isTop = false) => {
-  if (typeof context.ast[url] === "boolean") {
-    return context.ast[url] ? emptyItemIndexes : false;
+  for (const plugin of context.plugins) {
+    plugin.afterSchema(url, instance, context, valid);
   }
-
-  const accumulatedItemIndexes = new Set();
-  for (const [keywordId, , keywordValue] of context.ast[url]) {
-    if (isTop && keywordId === "https://json-schema.org/keyword/unevaluatedItems") {
-      continue;
-    }
-
-    const keywordHandler = getKeyword(keywordId);
-    const itemIndexes = "collectEvaluatedItems" in keywordHandler
-      ? keywordHandler.collectEvaluatedItems(keywordValue, instance, context, isTop)
-      : keywordHandler.interpret(keywordValue, instance, context) && emptyItemIndexes;
-
-    if (itemIndexes === false) {
-      return false;
-    }
-
-    itemIndexes.forEach(accumulatedItemIndexes.add, accumulatedItemIndexes);
-  }
-
-  return accumulatedItemIndexes;
+  return valid;
 };
 
-export default { id, compile, interpret, collectEvaluatedProperties, collectEvaluatedItems };
+export default { id, compile, interpret };

package/lib/keywords.js

@@ -35,17 +35,19 @@ export const defineVocabulary = (id, keywords) => {
 };
 
 const _dialects = {};
-const _allowUnknownKeywords = {};
-const _persistentDialects = {};
 
-export const getKeywordId = (keyword, dialectId) => getDialect(dialectId)?.[keyword]
-  || (_allowUnknownKeywords[dialectId] || keyword.startsWith("x-"))
-  && `https://json-schema.org/keyword/unknown#${keyword}`;
+export const getKeywordId = (keyword, dialectId) => {
+  const dialect = getDialect(dialectId);
+  return dialect.keywords[keyword]
+    ?? ((dialect.allowUnknownKeywords || keyword.startsWith("x-"))
+      ? `https://json-schema.org/keyword/unknown#${keyword}`
+      : undefined);
+};
 
 export const getKeywordName = (dialectId, keywordId) => {
   const dialect = getDialect(dialectId);
-  for (const keyword in dialect) {
-    if (dialect[keyword] === keywordId) {
+  for (const keyword in dialect.keywords) {
+    if (dialect.keywords[keyword] === keywordId) {
       return keyword;
     }
   }
@@ -62,33 +64,31 @@ const getDialect = (dialectId) => {
 export const hasDialect = (dialectId) => dialectId in _dialects;
 
 export const loadDialect = (dialectId, dialect, allowUnknownKeywords = false, isPersistent = true) => {
-  _allowUnknownKeywords[dialectId] = allowUnknownKeywords;
-  _persistentDialects[dialectId] = _persistentDialects[dialectId] || isPersistent;
-
-  _dialects[dialectId] = {};
-  Object.entries(dialect)
-    .forEach(([vocabularyId, isRequired]) => {
-      if (vocabularyId in _vocabularies) {
-        Object.entries(_vocabularies[vocabularyId])
-          .forEach(([keyword, keywordId]) => {
-            if (!(keywordId in _keywords) && !isRequired) {
-              // Allow keyword to be ignored
-              keywordId = `https://json-schema.org/keyword/unknown#${keyword}`;
-            }
-            _dialects[dialectId][keyword] = keywordId;
-          });
-      } else if (!allowUnknownKeywords || isRequired) {
-        delete _dialects[dialectId];
-        delete _allowUnknownKeywords[dialectId];
-        delete _persistentDialects[dialectId];
-        throw Error(`Unrecognized vocabulary: ${vocabularyId}. You can define this vocabulary with the 'defineVocabulary' function.`);
+  _dialects[dialectId] = {
+    keywords: {},
+    allowUnknownKeywords: allowUnknownKeywords,
+    persistentDialects: _dialects[dialectId]?.persistentDialects || isPersistent
+  };
+
+  for (const vocabularyId in dialect) {
+    if (vocabularyId in _vocabularies) {
+      for (const keyword in _vocabularies[vocabularyId]) {
+        let keywordId = _vocabularies[vocabularyId][keyword];
+        if (!(keywordId in _keywords) && !dialect[vocabularyId]) {
+          // Allow keyword to be ignored
+          keywordId = `https://json-schema.org/keyword/unknown#${keyword}`;
+        }
+        _dialects[dialectId].keywords[keyword] = keywordId;
       }
-    });
+    } else if (!allowUnknownKeywords || dialect[vocabularyId]) {
+      delete _dialects[dialectId];
+      throw Error(`Unrecognized vocabulary: ${vocabularyId}. You can define this vocabulary with the 'defineVocabulary' function.`);
+    }
+  }
 };
 
 export const unloadDialect = (dialectId) => {
-  if (!_persistentDialects[dialectId]) {
-    delete _allowUnknownKeywords[dialectId];
+  if (!_dialects[dialectId]?.persistentDialects) {
     delete _dialects[dialectId];
   }
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hyperjump/json-schema",
-  "version": "1.13.0",
+  "version": "1.14.0",
   "description": "A JSON Schema validator with support for custom keywords, vocabularies, and dialects",
   "type": "module",
   "main": "./stable/index.js",