@hyperjump/json-schema 1.16.2 → 1.16.4

package/annotations/index.d.ts

@@ -1,6 +1,6 @@
-import type { OutputFormat, OutputUnit, ValidationOptions } from "../lib/index.js";
+import type { OutputFormat, Output, ValidationOptions } from "../lib/index.js";
 import type { CompiledSchema } from "../lib/experimental.js";
-import type { JsonNode } from "../lib/json-node.js";
+import type { JsonNode } from "../lib/instance.js";
 import type { Json } from "@hyperjump/json-pointer";
 
 
@@ -15,7 +15,7 @@ export type Annotator = (value: Json, options?: OutputFormat | ValidationOptions
 export const interpret: (compiledSchema: CompiledSchema, value: JsonNode, options?: OutputFormat | ValidationOptions) => JsonNode;
 
 export class ValidationError extends Error {
-  public output: OutputUnit;
+  public output: Output & { valid: false };
 
-  public constructor(output: OutputUnit);
+  public constructor(output: Output);
 }

package/lib/experimental.d.ts

@@ -1,12 +1,12 @@
 import type { Browser, Document } from "@hyperjump/browser";
-import type { Validator, OutputUnit, OutputFormat, SchemaObject } from "./index.js";
+import type { Validator, Output, OutputUnit, OutputFormat, SchemaObject } from "./index.js";
 import type { JsonNode } from "./instance.js";
 
 
 // Compile/interpret
 export const compile: (schema: Browser<SchemaDocument>) => Promise<CompiledSchema>;
 export const interpret: (
-  (compiledSchema: CompiledSchema, value: JsonNode, outputFormat?: OutputFormat) => OutputUnit
+  (compiledSchema: CompiledSchema, value: JsonNode, outputFormat?: OutputFormat) => Output
 ) & (
   (compiledSchema: CompiledSchema) => Validator
 );

package/lib/index.d.ts

@@ -23,12 +23,19 @@ export type ValidationOptions = {
 };
 
 export const validate: (
-  (url: string, value: Json, options?: OutputFormat | ValidationOptions) => Promise<OutputUnit>
+  (url: string, value: Json, options?: OutputFormat | ValidationOptions) => Promise<Output>
 ) & (
   (url: string) => Promise<Validator>
 );
 
-export type Validator = (value: Json, options?: OutputFormat | ValidationOptions) => OutputUnit;
+export type Validator = (value: Json, options?: OutputFormat | ValidationOptions) => Output;
+
+export type Output = {
+  valid: true;
+} | {
+  valid: false;
+  errors?: OutputUnit[];
+};
 
 export type OutputUnit = {
   keyword: string;
@@ -49,7 +56,7 @@ export const setShouldValidateSchema: (isEnabled: boolean) => void;
 export const getShouldValidateSchema: () => boolean;
 
 export class InvalidSchemaError extends Error {
-  public output: OutputUnit;
+  public output: Output & { valid: false };
 
-  public constructor(output: OutputUnit);
+  public constructor(output: Output);
 }

package/lib/keywords/unevaluatedItems.js

@@ -1,31 +1,17 @@
-import { canonicalUri, Validation } from "../experimental.js";
+import { Validation } from "../experimental.js";
 import * as Instance from "../instance.js";
 
 
 const id = "https://json-schema.org/keyword/unevaluatedItems";
 
-const compile = async (schema, ast, parentSchema) => {
-  return [canonicalUri(parentSchema), await Validation.compile(schema, ast)];
-};
+const compile = (schema, ast) => Validation.compile(schema, ast);
 
-const interpret = ([schemaUrl, unevaluatedItems], instance, context) => {
+const interpret = (unevaluatedItems, instance, context) => {
   if (Instance.typeOf(instance) !== "array") {
     return true;
   }
 
-  // Because order matters, we re-evaluate this schema skipping this keyword
-  // just to collect all the evalauted items.
-  if (context.rootSchema === schemaUrl) {
-    return true;
-  }
-  const evaluatedItemsPlugin = new EvaluatedItemsPlugin(schemaUrl);
-  if (!Validation.interpret(schemaUrl, instance, {
-    ...context,
-    plugins: [...context.ast.plugins, evaluatedItemsPlugin]
-  })) {
-    return true;
-  }
-  const evaluatedItems = evaluatedItemsPlugin.evaluatedItems;
+  const evaluatedItems = context.schemaEvaluatedItems;
 
   let isValid = true;
   let index = 0;
@@ -46,38 +32,32 @@ const interpret = ([schemaUrl, unevaluatedItems], instance, context) => {
 
 const simpleApplicator = true;
 
-class EvaluatedItemsPlugin {
-  constructor(rootSchema) {
-    this.rootSchema = rootSchema;
-  }
-
-  beforeSchema(_url, _instance, context) {
+const plugin = {
+  beforeSchema(_url, instance, context) {
     context.evaluatedItems ??= new Set();
-    context.schemaEvaluatedItems ??= new Set();
-  }
+    context.schemaEvaluatedItems = new Set();
+    context.instanceLocation ??= Instance.uri(instance);
+  },
 
-  beforeKeyword(_node, _instance, context) {
-    context.rootSchema = this.rootSchema;
+  beforeKeyword(_node, instance, context, schemaContext) {
     context.evaluatedItems = new Set();
-  }
+    context.schemaEvaluatedItems = schemaContext.schemaEvaluatedItems;
+    context.instanceLocation = Instance.uri(instance);
+  },
 
-  afterKeyword(_node, _instance, context, valid, schemaContext) {
-    if (valid) {
-      for (const index of context.evaluatedItems) {
-        schemaContext.schemaEvaluatedItems.add(index);
-      }
+  afterKeyword(_node, _instance, context, _valid, schemaContext) {
+    for (const property of context.evaluatedItems) {
+      schemaContext.schemaEvaluatedItems.add(property);
     }
-  }
+  },
 
-  afterSchema(_url, _instance, context, valid) {
-    if (valid) {
-      for (const index of context.schemaEvaluatedItems) {
-        context.evaluatedItems.add(index);
+  afterSchema(_node, instance, context, valid) {
+    if (valid && Instance.uri(instance) === context.instanceLocation) {
+      for (const property of context.schemaEvaluatedItems) {
+        context.evaluatedItems.add(property);
       }
     }
-
-    this.evaluatedItems = context.evaluatedItems;
   }
-}
+};
 
-export default { id, compile, interpret, simpleApplicator };
+export default { id, compile, interpret, simpleApplicator, plugin };

package/lib/keywords/unevaluatedProperties.js

@@ -1,31 +1,17 @@
-import { Validation, canonicalUri } from "../experimental.js";
+import { Validation } from "../experimental.js";
 import * as Instance from "../instance.js";
 
 
 const id = "https://json-schema.org/keyword/unevaluatedProperties";
 
-const compile = async (schema, ast, parentSchema) => {
-  return [canonicalUri(parentSchema), await Validation.compile(schema, ast)];
-};
+const compile = (schema, ast) => Validation.compile(schema, ast);
 
-const interpret = ([schemaUrl, unevaluatedProperties], instance, context) => {
+const interpret = (unevaluatedProperties, instance, context) => {
   if (Instance.typeOf(instance) !== "object") {
     return true;
   }
 
-  // Because order matters, we re-evaluate this schema skipping this keyword
-  // just to collect all the evalauted properties.
-  if (context.rootSchema === schemaUrl) {
-    return true;
-  }
-  const evaluatedPropertiesPlugin = new EvaluatedPropertiesPlugin(schemaUrl);
-  if (!Validation.interpret(schemaUrl, instance, {
-    ...context,
-    plugins: [...context.ast.plugins, evaluatedPropertiesPlugin]
-  })) {
-    return true;
-  }
-  const evaluatedProperties = evaluatedPropertiesPlugin.evaluatedProperties;
+  const evaluatedProperties = context.schemaEvaluatedProperties;
 
   let isValid = true;
   for (const [propertyNameNode, property] of Instance.entries(instance)) {
@@ -46,38 +32,32 @@ const interpret = ([schemaUrl, unevaluatedProperties], instance, context) => {
 
 const simpleApplicator = true;
 
-class EvaluatedPropertiesPlugin {
-  constructor(rootSchema) {
-    this.rootSchema = rootSchema;
-  }
-
-  beforeSchema(_url, _instance, context) {
+const plugin = {
+  beforeSchema(_url, instance, context) {
     context.evaluatedProperties ??= new Set();
-    context.schemaEvaluatedProperties ??= new Set();
-  }
+    context.schemaEvaluatedProperties = new Set();
+    context.instanceLocation ??= Instance.uri(instance);
+  },
 
-  beforeKeyword(_node, _instance, context) {
-    context.rootSchema = this.rootSchema;
+  beforeKeyword(_node, instance, context, schemaContext) {
     context.evaluatedProperties = new Set();
-  }
+    context.schemaEvaluatedProperties = schemaContext.schemaEvaluatedProperties;
+    context.instanceLocation = Instance.uri(instance);
+  },
 
-  afterKeyword(_node, _instance, context, valid, schemaContext) {
-    if (valid) {
-      for (const property of context.evaluatedProperties) {
-        schemaContext.schemaEvaluatedProperties.add(property);
-      }
+  afterKeyword(_node, _instance, context, _valid, schemaContext) {
+    for (const property of context.evaluatedProperties) {
+      schemaContext.schemaEvaluatedProperties.add(property);
     }
-  }
+  },
 
-  afterSchema(_url, _instance, context, valid) {
-    if (valid) {
+  afterSchema(_node, instance, context, valid) {
+    if (valid && Instance.uri(instance) === context.instanceLocation) {
       for (const property of context.schemaEvaluatedProperties) {
         context.evaluatedProperties.add(property);
       }
     }
-
-    this.evaluatedProperties = context.evaluatedProperties;
   }
-}
+};
 
-export default { id, compile, interpret, simpleApplicator };
+export default { id, compile, interpret, simpleApplicator, plugin };

package/lib/keywords/validation.js

@@ -28,23 +28,36 @@ const compile = async (schema, ast) => {
       throw Error(`No schema found at '${url}'`);
     }
 
-    ast[url] = typeof schemaValue === "boolean" ? schemaValue : await pipe(
-      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];
-      }),
-      asyncCollectArray
-    );
+    if (typeof schemaValue === "boolean") {
+      ast[url] = schemaValue;
+    } else {
+      ast[url] = await pipe(
+        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];
+        }),
+        asyncCollectArray
+      );
+
+      // Keyword order shouldn't matter, but the unevaluated keywords are an exception :-(
+      ast[url].sort(keywordComparator);
+    }
   }
 
   return url;
 };
 
+const lastKeywords = new Set([
+  "https://json-schema.org/keyword/unevaluatedProperties",
+  "https://json-schema.org/keyword/unevaluatedItems"
+]);
+const keywordComparator = (_a, b) => lastKeywords.has(b[0]) ? -1 : 1;
+
 const interpret = (url, instance, context) => {
   let valid = true;
 

package/package.json

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