@hyperjump/json-schema 1.3.0 → 1.4.0

package/annotations/tests/validation.json

@@ -0,0 +1,328 @@
+[
+  {
+    "title": "`const` doesn't produce annotations",
+    "schema": {
+      "const": "foo"
+    },
+    "subjects": [
+      {
+        "instance": "foo",
+        "assertions": [
+          {
+            "location": "#",
+            "keyword": "const",
+            "expected": []
+          }
+        ]
+      }
+    ]
+  },
+  {
+    "title": "`dependentRequired` doesn't produce annotations",
+    "schema": {
+      "dependentRequired": {
+        "foo": ["bar"]
+      }
+    },
+    "subjects": [
+      {
+        "instance": { "foo": 1, "bar": 2 },
+        "assertions": [
+          {
+            "location": "#",
+            "keyword": "dependentRequired",
+            "expected": []
+          }
+        ]
+      }
+    ]
+  },
+  {
+    "title": "`enum` doesn't produce annotations",
+    "schema": {
+      "enum": ["foo"]
+    },
+    "subjects": [
+      {
+        "instance": "foo",
+        "assertions": [
+          {
+            "location": "#",
+            "keyword": "enum",
+            "expected": []
+          }
+        ]
+      }
+    ]
+  },
+  {
+    "title": "`exclusiveMaximum` doesn't produce annotations",
+    "schema": {
+      "exclusiveMaximum": 50
+    },
+    "subjects": [
+      {
+        "instance": 42,
+        "assertions": [
+          {
+            "location": "#",
+            "keyword": "exclusiveMaximum",
+            "expected": []
+          }
+        ]
+      }
+    ]
+  },
+  {
+    "title": "`exclusiveMinimum` doesn't produce annotations",
+    "schema": {
+      "exclusiveMinimum": 5
+    },
+    "subjects": [
+      {
+        "instance": 42,
+        "assertions": [
+          {
+            "location": "#",
+            "keyword": "exclusiveMinimum",
+            "expected": []
+          }
+        ]
+      }
+    ]
+  },
+  {
+    "title": "`maxItems` doesn't produce annotations",
+    "schema": {
+      "maxItems": 42
+    },
+    "subjects": [
+      {
+        "instance": ["foo"],
+        "assertions": [
+          {
+            "location": "#",
+            "keyword": "maxItems",
+            "expected": []
+          }
+        ]
+      }
+    ]
+  },
+  {
+    "title": "`maxLength` doesn't produce annotations",
+    "schema": {
+      "maxLength": 42
+    },
+    "subjects": [
+      {
+        "instance": "foo",
+        "assertions": [
+          {
+            "location": "#",
+            "keyword": "maxLength",
+            "expected": []
+          }
+        ]
+      }
+    ]
+  },
+  {
+    "title": "`maxProperties` doesn't produce annotations",
+    "schema": {
+      "maxProperties": 42
+    },
+    "subjects": [
+      {
+        "instance": { "foo": 42 },
+        "assertions": [
+          {
+            "location": "#",
+            "keyword": "maxProperties",
+            "expected": []
+          }
+        ]
+      }
+    ]
+  },
+  {
+    "title": "`maximum` doesn't produce annotations",
+    "schema": {
+      "maximum": 50
+    },
+    "subjects": [
+      {
+        "instance": 42,
+        "assertions": [
+          {
+            "location": "#",
+            "keyword": "maximum",
+            "expected": []
+          }
+        ]
+      }
+    ]
+  },
+  {
+    "title": "`minItems` doesn't produce annotations",
+    "schema": {
+      "minItems": 2
+    },
+    "subjects": [
+      {
+        "instance": ["a", "b"],
+        "assertions": [
+          {
+            "location": "#",
+            "keyword": "minItems",
+            "expected": []
+          }
+        ]
+      }
+    ]
+  },
+  {
+    "title": "`minLength` doesn't produce annotations",
+    "schema": {
+      "minLength": 2
+    },
+    "subjects": [
+      {
+        "instance": "foo",
+        "assertions": [
+          {
+            "location": "#",
+            "keyword": "minLength",
+            "expected": []
+          }
+        ]
+      }
+    ]
+  },
+  {
+    "title": "`minProperties` doesn't produce annotations",
+    "schema": {
+      "minProperties": 2
+    },
+    "subjects": [
+      {
+        "instance": { "foo": 42, "bar": 24 },
+        "assertions": [
+          {
+            "location": "#",
+            "keyword": "minProperties",
+            "expected": []
+          }
+        ]
+      }
+    ]
+  },
+  {
+    "title": "`minimum` doesn't produce annotations",
+    "schema": {
+      "minimum": 42
+    },
+    "subjects": [
+      {
+        "instance": 50,
+        "assertions": [
+          {
+            "location": "#",
+            "keyword": "minimum",
+            "expected": []
+          }
+        ]
+      }
+    ]
+  },
+  {
+    "title": "`multipleOf` doesn't produce annotations",
+    "schema": {
+      "multipleOf": 2
+    },
+    "subjects": [
+      {
+        "instance": 42,
+        "assertions": [
+          {
+            "location": "#",
+            "keyword": "multipleOf",
+            "expected": []
+          }
+        ]
+      }
+    ]
+  },
+  {
+    "title": "`pattern` doesn't produce annotations",
+    "schema": {
+      "pattern": ".*"
+    },
+    "subjects": [
+      {
+        "instance": "foo",
+        "assertions": [
+          {
+            "location": "#",
+            "keyword": "pattern",
+            "expected": []
+          }
+        ]
+      }
+    ]
+  },
+  {
+    "title": "`required` doesn't produce annotations",
+    "schema": {
+      "required": ["foo"]
+    },
+    "subjects": [
+      {
+        "instance": { "foo": 42 },
+        "assertions": [
+          {
+            "location": "#",
+            "keyword": "required",
+            "expected": []
+          }
+        ]
+      }
+    ]
+  },
+  {
+    "title": "`type` doesn't produce annotations",
+    "schema": {
+      "type": "string"
+    },
+    "subjects": [
+      {
+        "instance": "foo",
+        "assertions": [
+          {
+            "location": "#",
+            "keyword": "type",
+            "expected": []
+          }
+        ]
+      }
+    ]
+  },
+  {
+    "title": "`uniqueItems` doesn't produce annotations",
+    "schema": {
+      "uniqueItems": true
+    },
+    "subjects": [
+      {
+        "instance": ["foo", "bar"],
+        "assertions": [
+          {
+            "location": "#",
+            "keyword": "uniqueItems",
+            "expected": []
+          }
+        ]
+      }
+    ]
+  }
+]

package/annotations/validation-error.d.ts

@@ -0,0 +1,8 @@
+import type { OutputUnit } from "../lib/core.js";
+
+
+export class ValidationError extends Error {
+  public output: OutputUnit;
+
+  public constructor(output: OutputUnit);
+}

package/annotations/validation-error.js

@@ -0,0 +1,7 @@
+export class ValidationError extends Error {
+  constructor(output) {
+    super("Validation Error");
+    this.name = this.constructor.name;
+    this.output = output;
+  }
+}

package/bundle/index.js

@@ -70,14 +70,13 @@ const collectExternalIds = async (uri, options) => {
 };
 
 Validation.collectExternalIds = (schemaUri, externalIds, ast, dynamicAnchors) => {
-  const nodes = ast[schemaUri][2];
-  if (externalIds.has(schemaUri) || typeof nodes === "boolean") {
+  if (externalIds.has(schemaUri) || typeof ast[schemaUri] === "boolean") {
     return;
   }
   externalIds.add(schemaUri);
 
   const id = toAbsoluteUri(schemaUri);
-  for (const [keywordId, , keywordValue] of nodes) {
+  for (const [keywordId, , keywordValue] of ast[schemaUri]) {
     const keyword = getKeyword(keywordId);
 
     if (keyword.collectExternalIds) {

package/lib/keywords/additionalProperties.js

@@ -18,18 +18,33 @@ const compile = async (schema, ast, parentSchema) => {
   return [propertyNames, propertyNamePatterns, await Validation.compile(schema, ast)];
 };
 
-const interpret = ([propertyNames, propertyNamePatterns, additionalProperties], instance, ast, dynamicAnchors) => {
+const interpret = ([propertyNames, propertyNamePatterns, additionalProperties], instance, ast, dynamicAnchors, quiet) => {
   if (!Instance.typeOf(instance, "object")) {
     return true;
   }
 
   return Instance.entries(instance)
     .filter(([propertyName]) => !propertyNames.includes(propertyName) && !propertyNamePatterns.some((pattern) => pattern.test(propertyName)))
-    .every(([, property]) => Validation.interpret(additionalProperties, property, ast, dynamicAnchors));
+    .every(([, property]) => Validation.interpret(additionalProperties, property, ast, dynamicAnchors, quiet));
 };
 
-const collectEvaluatedProperties = (keywordValue, instance, ast, dynamicAnchors) => {
-  return interpret(keywordValue, instance, ast, dynamicAnchors) && [new RegExp("")];
+const collectEvaluatedProperties = ([propertyNames, propertyNamePatterns, additionalProperties], instance, ast, dynamicAnchors) => {
+  if (!Instance.typeOf(instance, "object")) {
+    return true;
+  }
+
+  const evaluatedPropertyNames = new Set();
+  for (const [propertyName, property] of Instance.entries(instance)) {
+    if (!propertyNames.includes(propertyName) && !propertyNamePatterns.some((pattern) => pattern.test(propertyName))) {
+      if (!Validation.interpret(additionalProperties, property, ast, dynamicAnchors, true)) {
+        return false;
+      }
+
+      evaluatedPropertyNames.add(propertyName);
+    }
+  }
+
+  return evaluatedPropertyNames;
 };
 
 export default { id, compile, interpret, collectEvaluatedProperties };

package/lib/keywords/allOf.js

@@ -10,8 +10,8 @@ const compile = (schema, ast) => Pact.pipeline([
   Pact.all
 ], schema);
 
-const interpret = (allOf, instance, ast, dynamicAnchors) => {
-  return allOf.every((schemaUrl) => Validation.interpret(schemaUrl, instance, ast, dynamicAnchors));
+const interpret = (allOf, instance, ast, dynamicAnchors, quiet) => {
+  return allOf.every((schemaUrl) => Validation.interpret(schemaUrl, instance, ast, dynamicAnchors, quiet));
 };
 
 const collectEvaluatedProperties = (allOf, instance, ast, dynamicAnchors) => {

package/lib/keywords/anyOf.js

@@ -10,8 +10,8 @@ const compile = (schema, ast) => Pact.pipeline([
   Pact.all
 ], schema);
 
-const interpret = (anyOf, instance, ast, dynamicAnchors) => {
-  const matches = anyOf.filter((schemaUrl) => Validation.interpret(schemaUrl, instance, ast, dynamicAnchors));
+const interpret = (anyOf, instance, ast, dynamicAnchors, quiet) => {
+  const matches = anyOf.filter((schemaUrl) => Validation.interpret(schemaUrl, instance, ast, dynamicAnchors, quiet));
   return matches.length > 0;
 };
 

package/lib/keywords/contains.js

@@ -20,34 +20,34 @@ const compile = async (schema, ast, parentSchema) => {
   return { contains, minContains, maxContains };
 };
 
-const interpret = ({ contains, minContains, maxContains }, instance, ast, dynamicAnchors) => {
+const interpret = ({ contains, minContains, maxContains }, instance, ast, dynamicAnchors, quiet) => {
   if (!Instance.typeOf(instance, "array") && !Instance.typeOf(instance, "object")) {
     return true;
   }
 
   const matches = Instance.entries(instance).reduce((matches, [, item]) => {
-    return Validation.interpret(contains, item, ast, dynamicAnchors) ? matches + 1 : matches;
+    return Validation.interpret(contains, item, ast, dynamicAnchors, quiet) ? matches + 1 : matches;
   }, 0);
   return matches >= minContains && matches <= maxContains;
 };
 
-const collectEvaluatedItems = (keywordValue, instance, ast, dynamicAnchors) => {
-  return interpret(keywordValue, instance, ast, dynamicAnchors)
-    && Instance.typeOf(instance, "array")
-    && Instance.reduce((matchedIndexes, item, itemIndex) => {
-      return Validation.interpret(keywordValue.contains, item, ast, dynamicAnchors) ? matchedIndexes.add(itemIndex) : matchedIndexes;
-    }, new Set(), instance);
-};
-
 const collectEvaluatedProperties = (keywordValue, instance, ast, dynamicAnchors) => {
-  return interpret(keywordValue, instance, ast, dynamicAnchors)
+  return interpret(keywordValue, instance, ast, dynamicAnchors, true)
     && Instance.typeOf(instance, "object")
     && Instance.entries(instance).reduce((matchedPropertyNames, [propertyName, item]) => {
-      if (Validation.interpret(keywordValue.contains, item, ast, dynamicAnchors)) {
-        matchedPropertyNames.push(propertyName);
+      if (Validation.interpret(keywordValue.contains, item, ast, dynamicAnchors, true)) {
+        matchedPropertyNames.add(propertyName);
       }
       return matchedPropertyNames;
-    }, [], instance);
+    }, new Set(), instance);
+};
+
+const collectEvaluatedItems = (keywordValue, instance, ast, dynamicAnchors) => {
+  return interpret(keywordValue, instance, ast, dynamicAnchors, true)
+    && Instance.typeOf(instance, "array")
+    && Instance.reduce((matchedIndexes, item, itemIndex) => {
+      return Validation.interpret(keywordValue.contains, item, ast, dynamicAnchors, true) ? matchedIndexes.add(itemIndex) : matchedIndexes;
+    }, new Set(), instance);
 };
 
 export default { id, compile, interpret, collectEvaluatedItems, collectEvaluatedProperties };

package/lib/keywords/contentSchema.js

@@ -1,4 +1,9 @@
-import metaData from "./meta-data.js";
+import * as Schema from "../schema.js";
 
 
-export default { id: "https://json-schema.org/keyword/contentSchema", ...metaData };
+const id = "https://json-schema.org/keyword/contentSchema";
+
+const compile = (contentSchema) => Schema.uri(contentSchema);
+const interpret = () => true;
+
+export default { id, compile, interpret };

package/lib/keywords/dependentSchemas.js

@@ -12,23 +12,33 @@ const compile = (schema, ast) => Pact.pipeline([
   Pact.all
 ], schema);
 
-const interpret = (dependentSchemas, instance, ast, dynamicAnchors) => {
+const interpret = (dependentSchemas, instance, ast, dynamicAnchors, quiet) => {
   const value = Instance.value(instance);
 
   return !Instance.typeOf(instance, "object") || dependentSchemas.every(([propertyName, dependentSchema]) => {
-    return !(propertyName in value) || Validation.interpret(dependentSchema, instance, ast, dynamicAnchors);
+    return !(propertyName in value) || Validation.interpret(dependentSchema, instance, ast, dynamicAnchors, quiet);
   });
 };
 
 const collectEvaluatedProperties = (dependentSchemas, instance, ast, dynamicAnchors) => {
-  return dependentSchemas.reduce((acc, [propertyName, dependentSchema]) => {
-    if (!acc || !Instance.has(propertyName, instance)) {
-      return acc;
+  const value = Instance.value(instance);
+  if (!Instance.typeOf(instance, "object")) {
+    return false;
+  }
+
+  const evaluatedPropertyNames = new Set();
+  for (const [propertyName, dependentSchema] of dependentSchemas) {
+    if (propertyName in value) {
+      const propertyNames = Validation.collectEvaluatedProperties(dependentSchema, instance, ast, dynamicAnchors);
+      if (propertyNames === false) {
+        return false;
+      }
+
+      propertyNames.forEach(Set.prototype.add.bind(evaluatedPropertyNames));
     }
+  }
 
-    const propertyNames = Validation.collectEvaluatedProperties(dependentSchema, instance, ast, dynamicAnchors);
-    return propertyNames !== false && acc.concat(propertyNames);
-  }, []);
+  return evaluatedPropertyNames;
 };
 
 export default { id, compile, interpret, collectEvaluatedProperties };

package/lib/keywords/dynamicRef.js

@@ -7,11 +7,11 @@ const experimental = true;
 
 const compile = Schema.value;
 
-const interpret = (fragment, instance, ast, dynamicAnchors) => {
+const interpret = (fragment, instance, ast, dynamicAnchors, quiet) => {
   if (!(fragment in dynamicAnchors)) {
     throw Error(`No dynamic anchor found for "${fragment}"`);
   }
-  return Validation.interpret(dynamicAnchors[fragment], instance, ast, dynamicAnchors);
+  return Validation.interpret(dynamicAnchors[fragment], instance, ast, dynamicAnchors, quiet);
 };
 
 const collectEvaluatedProperties = Validation.collectEvaluatedProperties;

package/lib/keywords/else.js

@@ -1,5 +1,5 @@
 import * as Schema from "../schema.js";
-import { getKeywordName, getKeyword } from "../keywords.js";
+import { getKeywordName } from "../keywords.js";
 import Validation from "./validation.js";
 
 
@@ -15,33 +15,26 @@ const compile = async (schema, ast, parentSchema) => {
   }
 };
 
-const interpret = ([guard, block], instance, ast, dynamicAnchors) => {
-  return guard === undefined || quietInterpretSchema(guard, instance, ast, dynamicAnchors) || Validation.interpret(block, instance, ast, dynamicAnchors);
+const interpret = ([ifSchema, elseSchema], instance, ast, dynamicAnchors, quiet) => {
+  return ifSchema === undefined
+    || Validation.interpret(ifSchema, instance, ast, dynamicAnchors, true)
+    || Validation.interpret(elseSchema, instance, ast, dynamicAnchors, quiet);
 };
 
-// Interpret a schema without events being emitted
-const quietInterpretSchema = (url, instance, ast, dynamicAnchors) => {
-  const nodes = ast[url][2];
-
-  return typeof nodes === "boolean" ? nodes : nodes.every(([keywordId, , keywordValue]) => {
-    return getKeyword(keywordId).interpret(keywordValue, instance, ast, dynamicAnchors);
-  });
-};
-
-const collectEvaluatedProperties = ([guard, block], instance, ast, dynamicAnchors) => {
-  if (guard === undefined || quietInterpretSchema(guard, instance, ast, dynamicAnchors)) {
-    return [];
+const collectEvaluatedProperties = ([ifSchema, elseSchema], instance, ast, dynamicAnchors) => {
+  if (ifSchema === undefined || Validation.interpret(ifSchema, instance, ast, dynamicAnchors, true)) {
+    return new Set();
   }
 
-  return Validation.collectEvaluatedProperties(block, instance, ast, dynamicAnchors);
+  return Validation.collectEvaluatedProperties(elseSchema, instance, ast, dynamicAnchors);
 };
 
-const collectEvaluatedItems = ([guard, block], instance, ast, dynamicAnchors) => {
-  if (guard === undefined || quietInterpretSchema(guard, instance, ast, dynamicAnchors)) {
+const collectEvaluatedItems = ([ifSchema, elseSchema], instance, ast, dynamicAnchors) => {
+  if (ifSchema === undefined || Validation.interpret(ifSchema, instance, ast, dynamicAnchors, true)) {
     return new Set();
   }
 
-  return Validation.collectEvaluatedItems(block, instance, ast, dynamicAnchors);
+  return Validation.collectEvaluatedItems(elseSchema, instance, ast, dynamicAnchors);
 };
 
 export default { id, compile, interpret, collectEvaluatedProperties, collectEvaluatedItems };

package/lib/keywords/if.js

@@ -5,8 +5,8 @@ const id = "https://json-schema.org/keyword/if";
 
 const compile = (schema, ast) => Validation.compile(schema, ast);
 
-const interpret = (ifSchema, instance, ast, dynamicAnchors) => {
-  Validation.interpret(ifSchema, instance, ast, dynamicAnchors);
+const interpret = (ifSchema, instance, ast, dynamicAnchors, quiet) => {
+  Validation.interpret(ifSchema, instance, ast, dynamicAnchors, quiet);
   return true;
 };
 

package/lib/keywords/items.js

@@ -14,16 +14,16 @@ const compile = async (schema, ast, parentSchema) => {
   return [numberOfPrefixItems, await Validation.compile(schema, ast)];
 };
 
-const interpret = ([numberOfPrefixItems, items], instance, ast, dynamicAnchors) => {
+const interpret = ([numberOfPrefixItems, items], instance, ast, dynamicAnchors, quiet) => {
   if (!Instance.typeOf(instance, "array")) {
     return true;
   }
 
-  return Instance.every((item, ndx) => ndx < numberOfPrefixItems || Validation.interpret(items, item, ast, dynamicAnchors), instance);
+  return Instance.every((item, ndx) => ndx < numberOfPrefixItems || Validation.interpret(items, item, ast, dynamicAnchors, quiet), instance);
 };
 
 const collectEvaluatedItems = (keywordValue, instance, ast, dynamicAnchors) => {
-  if (!interpret(keywordValue, instance, ast, dynamicAnchors)) {
+  if (!interpret(keywordValue, instance, ast, dynamicAnchors, true)) {
     return false;
   }
 

package/lib/keywords/not.js

@@ -4,6 +4,6 @@ import Validation from "./validation.js";
 const id = "https://json-schema.org/keyword/not";
 
 const compile = Validation.compile;
-const interpret = (not, instance, ast, dynamicAnchors) => !Validation.interpret(not, instance, ast, dynamicAnchors);
+const interpret = (not, instance, ast, dynamicAnchors, quiet) => !Validation.interpret(not, instance, ast, dynamicAnchors, quiet);
 
 export default { id, compile, interpret };

package/lib/keywords/oneOf.js

@@ -9,10 +9,10 @@ const compile = async (schema, ast) => {
   return Promise.all(oneOf);
 };
 
-const interpret = (oneOf, instance, ast, dynamicAnchors) => {
+const interpret = (oneOf, instance, ast, dynamicAnchors, quiet) => {
   let validCount = 0;
   for (const schemaUrl of oneOf) {
-    if (Validation.interpret(schemaUrl, instance, ast, dynamicAnchors)) {
+    if (Validation.interpret(schemaUrl, instance, ast, dynamicAnchors, quiet)) {
       validCount++;
     }