@hyperjump/json-schema 1.11.0 → 1.12.0

package/lib/keywords/unevaluatedProperties.js

@@ -1,3 +1,4 @@
+import { FLAG } from "../index.js";
 import { Validation, canonicalUri } from "../experimental.js";
 import * as Instance from "../instance.js";
 
@@ -8,12 +9,13 @@ const compile = async (schema, ast, parentSchema) => {
   return [canonicalUri(parentSchema), await Validation.compile(schema, ast)];
 };
 
-const interpret = ([schemaUrl, unevaluatedProperties], instance, ast, dynamicAnchors, quiet) => {
+const interpret = ([schemaUrl, unevaluatedProperties], instance, context) => {
   if (Instance.typeOf(instance) !== "object") {
     return true;
   }
 
-  const evaluatedPropertyNames = Validation.collectEvaluatedProperties(schemaUrl, instance, ast, dynamicAnchors, true);
+  const keywordContext = { ...context, errors: [], annotations: [], outputFormat: FLAG };
+  const evaluatedPropertyNames = Validation.collectEvaluatedProperties(schemaUrl, instance, keywordContext, true);
   if (evaluatedPropertyNames === false) {
     return true;
   }
@@ -21,7 +23,7 @@ const interpret = ([schemaUrl, unevaluatedProperties], instance, ast, dynamicAnc
   let isValid = true;
   for (const [propertyNameNode, property] of Instance.entries(instance)) {
     const propertyName = Instance.value(propertyNameNode);
-    if (!evaluatedPropertyNames.has(propertyName) && !Validation.interpret(unevaluatedProperties, property, ast, dynamicAnchors, quiet)) {
+    if (!evaluatedPropertyNames.has(propertyName) && !Validation.interpret(unevaluatedProperties, property, context)) {
       isValid = false;
     }
   }
@@ -29,12 +31,14 @@ const interpret = ([schemaUrl, unevaluatedProperties], instance, ast, dynamicAnc
   return isValid;
 };
 
-const collectEvaluatedProperties = ([schemaUrl, unevaluatedProperties], instance, ast, dynamicAnchors) => {
+const simpleApplicator = true;
+
+const collectEvaluatedProperties = ([schemaUrl, unevaluatedProperties], instance, context) => {
   if (Instance.typeOf(instance) !== "object") {
     return true;
   }
 
-  const evaluatedPropertyNames = Validation.collectEvaluatedProperties(schemaUrl, instance, ast, dynamicAnchors, true);
+  const evaluatedPropertyNames = Validation.collectEvaluatedProperties(schemaUrl, instance, context, true);
 
   if (!evaluatedPropertyNames) {
     return false;
@@ -43,7 +47,7 @@ const collectEvaluatedProperties = ([schemaUrl, unevaluatedProperties], instance
   for (const [propertyNameNode, property] of Instance.entries(instance)) {
     const propertyName = Instance.value(propertyNameNode);
     if (!evaluatedPropertyNames.has(propertyName)) {
-      if (!Validation.interpret(unevaluatedProperties, property, ast, dynamicAnchors, true)) {
+      if (!Validation.interpret(unevaluatedProperties, property, context)) {
         return false;
       }
 
@@ -54,4 +58,4 @@ const collectEvaluatedProperties = ([schemaUrl, unevaluatedProperties], instance
   return evaluatedPropertyNames;
 };
 
-export default { id, compile, interpret, collectEvaluatedProperties };
+export default { id, compile, interpret, simpleApplicator, collectEvaluatedProperties };

package/lib/keywords/unknown.js

@@ -1,5 +1,4 @@
 import * as Browser from "@hyperjump/browser";
-import * as Instance from "../../annotations/annotated-instance.js";
 import { pointerSegments } from "@hyperjump/json-pointer";
 
 
@@ -10,10 +9,7 @@ const compile = (schema) => {
   return [keywordName, Browser.value(schema)];
 };
 
-const interpret = ([keywordName, value], instance, _ast, _dynamicAnchors, _quiet, schemaLocation) => {
-  const keywordId = `${id}#${keywordName}`;
-  Instance.setAnnotation(instance, keywordId, schemaLocation, value);
-  return true;
-};
+const interpret = () => true;
+const annotation = ([, value]) => value;
 
-export default { id, compile, interpret };
+export default { id, compile, interpret, annotation };

package/lib/keywords/validation.js

@@ -2,8 +2,10 @@ 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 } from "../experimental.js";
+import { canonicalUri, getKeyword, getKeywordByName, BASIC, DETAILED } from "../experimental.js";
+import { FLAG } from "../index.js";
 
 
 const id = "https://json-schema.org/evaluation/validate";
@@ -43,48 +45,101 @@ const compile = async (schema, ast) => {
   return url;
 };
 
-const interpret = (url, instance, ast, dynamicAnchors, quiet = false) => {
+const interpret = (url, instance, { ast, dynamicAnchors, errors, annotations, outputFormat }) => {
   dynamicAnchors = { ...ast.metaData[toAbsoluteUri(url)].dynamicAnchors, ...dynamicAnchors };
 
-  let isSchemaValid = true;
   if (typeof ast[url] === "boolean") {
-    isSchemaValid = ast[url];
+    if (ast[url]) {
+      return true;
+    } else {
+      errors.push({
+        keyword: id,
+        absoluteKeywordLocation: url,
+        instanceLocation: Instance.uri(instance)
+      });
+      return false;
+    }
   } else {
-    for (const [keywordId, schemaUrl, keywordValue] of ast[url]) {
-      instance.valid = getKeyword(keywordId).interpret(keywordValue, instance, ast, dynamicAnchors, quiet, url);
-      if (!instance.valid) {
-        if (!quiet) {
-          instance.errors[schemaUrl] = keywordId;
-        }
+    const schemaAnnotations = [];
+
+    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 (!isKeywordValid) {
         isSchemaValid = 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 {
+            if (keywordHandler.annotation) {
+              schemaAnnotations.push({
+                keyword: keywordId,
+                absoluteKeywordLocation: schemaUri,
+                instanceLocation: Instance.uri(instance),
+                annotation: keywordHandler.annotation(keywordValue)
+              });
+            }
+            schemaAnnotations.push(...context.annotations);
+          }
+          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}'`);
+      }
     }
-  }
 
-  if (!isSchemaValid) {
-    instance.errors[url] = id;
-  }
+    if (outputFormat === BASIC && isSchemaValid) {
+      annotations.push(...schemaAnnotations);
+    }
 
-  instance.valid = isSchemaValid;
-  return isSchemaValid;
+    return isSchemaValid;
+  }
 };
 
 const emptyPropertyNames = new Set();
-const collectEvaluatedProperties = (url, instance, ast, dynamicAnchors, isTop = false) => {
-  if (typeof ast[url] === "boolean") {
-    return ast[url] ? new Set() : false;
+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 ast[url]) {
+  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, ast, dynamicAnchors, isTop)
-      : keywordHandler.interpret(keywordValue, instance, ast, dynamicAnchors, true) && emptyPropertyNames;
+      ? keywordHandler.collectEvaluatedProperties(keywordValue, instance, context, isTop)
+      : keywordHandler.interpret(keywordValue, instance, context) && emptyPropertyNames;
 
     if (propertyNames === false) {
       return false;
@@ -97,21 +152,21 @@ const collectEvaluatedProperties = (url, instance, ast, dynamicAnchors, isTop =
 };
 
 const emptyItemIndexes = new Set();
-const collectEvaluatedItems = (url, instance, ast, dynamicAnchors, isTop = false) => {
-  if (typeof ast[url] === "boolean") {
-    return ast[url] ? new Set() : false;
+const collectEvaluatedItems = (url, instance, context, isTop = false) => {
+  if (typeof context.ast[url] === "boolean") {
+    return context.ast[url] ? emptyItemIndexes : false;
   }
 
   const accumulatedItemIndexes = new Set();
-  for (const [keywordId, , keywordValue] of ast[url]) {
+  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, ast, dynamicAnchors, isTop)
-      : keywordHandler.interpret(keywordValue, instance, ast, dynamicAnchors, true) && emptyItemIndexes;
+      ? keywordHandler.collectEvaluatedItems(keywordValue, instance, context, isTop)
+      : keywordHandler.interpret(keywordValue, instance, context) && emptyItemIndexes;
 
     if (itemIndexes === false) {
       return false;

package/lib/keywords/writeOnly.js

@@ -1,14 +1,10 @@
 import * as Browser from "@hyperjump/browser";
-import * as Instance from "../../annotations/annotated-instance.js";
 
 
 const id = "https://json-schema.org/keyword/writeOnly";
 
 const compile = (schema) => Browser.value(schema);
+const interpret = () => true;
+const annotation = (writeOnly) => writeOnly;
 
-const interpret = (writeOnly, instance, _ast, _dynamicAnchors, _quiet, schemaLocation) => {
-  Instance.setAnnotation(instance, id, schemaLocation, writeOnly);
-  return true;
-};
-
-export default { id, compile, interpret };
+export default { id, compile, interpret, annotation };

package/openapi-3-0/discriminator.js

@@ -1,14 +1,10 @@
 import * as Browser from "@hyperjump/browser";
-import * as Instance from "../annotations/annotated-instance.js";
 
 
 const id = "https://spec.openapis.org/oas/3.0/keyword/discriminator";
 
 const compile = (schema) => Browser.value(schema);
+const interpret = () => true;
+const annotation = (discriminator) => discriminator;
 
-const interpret = (discriminator, instance, _ast, _dynamicAnchors, _quiet, schemaLocation) => {
-  Instance.setAnnotation(instance, id, schemaLocation, discriminator);
-  return true;
-};
-
-export default { id, compile, interpret };
+export default { id, compile, interpret, annotation };

package/openapi-3-0/example.js

@@ -1,14 +1,10 @@
 import * as Browser from "@hyperjump/browser";
-import * as Instance from "../annotations/annotated-instance.js";
 
 
 const id = "https://spec.openapis.org/oas/3.0/keyword/example";
 
 const compile = (schema) => Browser.value(schema);
+const interpret = () => true;
+const annotation = (example) => example;
 
-const interpret = (example, instance, _ast, _dynamicAnchors, _quiet, schemaLocation) => {
-  Instance.setAnnotation(instance, id, schemaLocation, example);
-  return true;
-};
-
-export default { id, compile, interpret };
+export default { id, compile, interpret, annotation };

package/openapi-3-0/externalDocs.js

@@ -1,14 +1,10 @@
 import * as Browser from "@hyperjump/browser";
-import * as Instance from "../annotations/annotated-instance.js";
 
 
 const id = "https://spec.openapis.org/oas/3.0/keyword/externalDocs";
 
 const compile = (schema) => Browser.value(schema);
+const interpret = () => true;
+const annotation = (externalDocs) => externalDocs;
 
-const interpret = (externalDocs, instance, _ast, _dynamicAnchors, _quiet, schemaLocation) => {
-  Instance.setAnnotation(instance, id, schemaLocation, externalDocs);
-  return true;
-};
-
-export default { id, compile, interpret };
+export default { id, compile, interpret, annotation };

package/openapi-3-0/index.d.ts

@@ -57,7 +57,7 @@ type Xml = {
   wrapped?: boolean;
 };
 
-type OpenApi = {
+export type OpenApi30 = {
   openapi: string;
   info: Info;
   externalDocs?: ExternalDocs;

package/openapi-3-0/xml.js

@@ -1,14 +1,10 @@
 import * as Browser from "@hyperjump/browser";
-import * as Instance from "../annotations/annotated-instance.js";
 
 
 const id = "https://spec.openapis.org/oas/3.0/keyword/xml";
 
 const compile = (schema) => Browser.value(schema);
+const interpret = () => true;
+const annotation = (xml) => xml;
 
-const interpret = (xml, instance, _ast, _dynamicAnchors, _quiet, schemaLocation) => {
-  Instance.setAnnotation(instance, id, schemaLocation, xml);
-  return true;
-};
-
-export default { id, compile, interpret };
+export default { id, compile, interpret, annotation };

package/package.json

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

package/lib/output.js

@@ -1,41 +0,0 @@
-import * as Instance from "./instance.js";
-
-
-const outputFormats = {};
-
-export const toOutputFormat = (node, outputFormat) => {
-  if (outputFormat in outputFormats) {
-    return outputFormats[outputFormat](node);
-  } else {
-    throw Error(`The '${outputFormat}' error format is not supported`);
-  }
-};
-
-outputFormats.FLAG = (instance) => {
-  return { valid: instance.valid };
-};
-
-outputFormats.BASIC = (instance) => {
-  const output = {
-    valid: instance.valid
-  };
-
-  if (!instance.valid) {
-    output.errors = [];
-
-    for (const child of Instance.allNodes(instance)) {
-      for (const [absoluteKeywordLocation, keyword] of Object.entries(child.errors).reverse()) {
-        if (keyword !== "https://json-schema.org/evaluation/validate" && !child.valid) {
-          output.errors.unshift({
-            keyword,
-            absoluteKeywordLocation,
-            instanceLocation: Instance.uri(child),
-            valid: child.valid
-          });
-        }
-      }
-    }
-  }
-
-  return output;
-};