Convert unevaluated and dynamic into evaluation plugins

Author: jdesrosiers

annotations/index.js

@@ -1,11 +1,16 @@
 import { FLAG } from "../lib/index.js";
 import { ValidationError } from "./validation-error.js";
-import { getSchema, compile, BASIC, DETAILED } from "../lib/experimental.js";
+import {
+  getSchema,
+  compile,
+  BASIC,
+  DETAILED,
+  annotationsPlugin,
+  basicOutputPlugin,
+  detailedOutputPlugin
+} from "../lib/experimental.js";
 import Validation from "../lib/keywords/validation.js";
 import * as Instance from "../lib/instance.js";
-import { annotationsPlugin } from "../lib/evaluation-plugins/annotations.js";
-import { basicOutputPlugin } from "../lib/evaluation-plugins/basic-output.js";
-import { detailedOutputPlugin } from "../lib/evaluation-plugins/detailed-output.js";
 
 
 export const annotate = async (schemaUri, json = undefined, outputFormat = undefined) => {
@@ -17,7 +22,7 @@ export const annotate = async (schemaUri, json = undefined, outputFormat = undef
 };
 
 export const interpret = ({ ast, schemaUri }, instance, outputFormat = BASIC) => {
-  const context = { ast, plugins: [annotationsPlugin], dynamicAnchors: {} };
+  const context = { ast, plugins: [annotationsPlugin, ...ast.plugins] };
 
   switch (outputFormat) {
     case FLAG:

bundle/generate-snapshots.js

@@ -1,15 +1,13 @@
 import { writeFile, mkdir, rm } from "node:fs/promises";
 import { isCompatible, md5, loadSchemas, testSuite, unloadSchemas } from "./test-utils.js";
-import { compile, getSchema, Validation } from "../lib/experimental.js";
+import { annotationsPlugin, compile, detailedOutputPlugin, getSchema, Validation } from "../lib/experimental.js";
 import "../stable/index.js";
 import "../draft-2020-12/index.js";
 import "../draft-2019-09/index.js";
 import "../draft-07/index.js";
 import "../draft-06/index.js";
 import "../draft-04/index.js";
 import * as Instance from "../lib/instance.js";
-import { detailedOutputPlugin } from "../lib/evaluation-plugins/detailed-output.js";
-import { annotationsPlugin } from "../lib/evaluation-plugins/annotations.js";
 
 
 const suite = testSuite("./bundle/tests");
@@ -30,11 +28,7 @@ const snapshotGenerator = async (version, dialect) => {
       const { ast, schemaUri } = await compile(schema);
 
       const instance = Instance.fromJs(test.instance);
-      const context = {
-        ast,
-        plugins: [detailedOutputPlugin, annotationsPlugin],
-        dynamicAnchors: {}
-      };
+      const context = { ast, plugins: [detailedOutputPlugin, annotationsPlugin, ...ast.plugins] };
       const valid = Validation.interpret(schemaUri, instance, context);
 
       const expectedOutput = {

bundle/test-suite.spec.ts

@@ -68,10 +68,7 @@ const testRunner = (version: number, dialect: string) => {
                 const instance = Instance.fromJs(test.instance);
                 const context = {
                   ast,
-                  plugins: [detailedOutputPlugin, annotationsPlugin],
-                  dynamicAnchors: {},
-                  errors: [],
-                  annotations: []
+                  plugins: [detailedOutputPlugin, annotationsPlugin, ...ast.plugins]
                 } as ValidationContext & ErrorsContext & AnnotationsContext;
                 const valid = Validation.interpret(schemaUri, instance, context);
 

draft-04/additionalItems.js

@@ -1,4 +1,4 @@
-import { pipe, drop, every } from "@hyperjump/pact";
+import { drop } from "@hyperjump/pact";
 import * as Browser from "@hyperjump/browser";
 import * as Instance from "../lib/instance.js";
 import { getKeywordName, Validation } from "../lib/experimental.js";
@@ -19,26 +19,20 @@ const interpret = ([numberOfItems, additionalItems], instance, context) => {
     return true;
   }
 
-  return pipe(
-    Instance.iter(instance),
-    drop(numberOfItems),
-    every((item) => Validation.interpret(additionalItems, item, context))
-  );
-};
-
-const simpleApplicator = true;
+  let isValid = true;
+  let index = numberOfItems;
+  for (const item of drop(numberOfItems, Instance.iter(instance))) {
+    if (!Validation.interpret(additionalItems, item, context)) {
+      isValid = false;
+    }
 
-const collectEvaluatedItems = (keywordValue, instance, context) => {
-  if (!interpret(keywordValue, instance, context)) {
-    return false;
+    context.evaluatedItems?.add(index);
+    index++;
   }
 
-  const evaluatedIndexes = new Set();
-  for (let ndx = keywordValue[0]; ndx < Instance.length(instance); ndx++) {
-    evaluatedIndexes.add(ndx);
-  }
-
-  return evaluatedIndexes;
+  return isValid;
 };
 
-export default { id, compile, interpret, simpleApplicator, collectEvaluatedItems };
+const simpleApplicator = true;
+
+export default { id, compile, interpret, simpleApplicator };

draft-04/items.js

@@ -1,4 +1,4 @@
-import { pipe, asyncMap, asyncCollectArray, every, zip, take, range, collectSet } from "@hyperjump/pact";
+import { pipe, asyncMap, asyncCollectArray, zip } from "@hyperjump/pact";
 import * as Browser from "@hyperjump/browser";
 import * as Instance from "../lib/instance.js";
 import { Validation } from "../lib/experimental.js";
@@ -23,23 +23,35 @@ const interpret = (items, instance, context) => {
     return true;
   }
 
+  let isValid = true;
+  let index = 0;
+
   if (typeof items === "string") {
-    return every((itemValue) => Validation.interpret(items, itemValue, context), Instance.iter(instance));
+    for (const item of Instance.iter(instance)) {
+      if (!Validation.interpret(items, item, context)) {
+        isValid = false;
+      }
+
+      context.evaluatedItems?.add(index++);
+    }
   } else {
-    return pipe(
-      zip(items, Instance.iter(instance)),
-      take(Instance.length(instance)),
-      every(([prefixItem, item]) => Validation.interpret(prefixItem, item, context))
-    );
+    for (const [tupleItem, tupleInstance] of zip(items, Instance.iter(instance))) {
+      if (!tupleInstance) {
+        break;
+      }
+
+      if (!Validation.interpret(tupleItem, tupleInstance, context)) {
+        isValid = false;
+      }
+
+      context.evaluatedItems?.add(index);
+      index++;
+    }
   }
+
+  return isValid;
 };
 
 const simpleApplicator = true;
 
-const collectEvaluatedItems = (items, instance, context) => {
-  return interpret(items, instance, context) && (typeof items === "string"
-    ? collectSet(range(0, Instance.length(instance)))
-    : collectSet(range(0, items.length)));
-};
-
-export default { id, compile, interpret, simpleApplicator, collectEvaluatedItems };
+export default { id, compile, interpret, simpleApplicator };

draft-2020-12/dynamicRef.js

@@ -1,6 +1,6 @@
 import * as Browser from "@hyperjump/browser";
 import { Validation, canonicalUri } from "../lib/experimental.js";
-import { uriFragment } from "../lib/common.js";
+import { toAbsoluteUri, uriFragment } from "../lib/common.js";
 
 
 const id = "https://json-schema.org/keyword/draft-2020-12/dynamicRef";
@@ -12,19 +12,31 @@ const compile = async (dynamicRef, ast) => {
   return [referencedSchema.document.baseUri, fragment, canonicalUri(referencedSchema)];
 };
 
-const evaluate = (strategy, [id, fragment, ref], instance, context) => {
+const interpret = ([id, fragment, ref], instance, context) => {
   if (fragment in context.ast.metaData[id].dynamicAnchors) {
     context.dynamicAnchors = { ...context.ast.metaData[id].dynamicAnchors, ...context.dynamicAnchors };
-    return strategy(context.dynamicAnchors[fragment], instance, context);
+    return Validation.interpret(context.dynamicAnchors[fragment], instance, context);
   } else {
-    return strategy(ref, instance, context);
+    return Validation.interpret(ref, instance, context);
   }
 };
 
 const simpleApplicator = true;
 
-const interpret = (...args) => evaluate(Validation.interpret, ...args);
-const collectEvaluatedProperties = (...args) => evaluate(Validation.collectEvaluatedProperties, ...args);
-const collectEvaluatedItems = (...args) => evaluate(Validation.collectEvaluatedItems, ...args);
+const plugin = {
+  beforeSchema(url, _instance, context) {
+    context.dynamicAnchors = {
+      ...context.ast.metaData[toAbsoluteUri(url)].dynamicAnchors,
+      ...context.dynamicAnchors
+    };
+  },
+  beforeKeyword(_url, _instance, context, schemaContext) {
+    context.dynamicAnchors = schemaContext.dynamicAnchors;
+  },
+  afterKeyword() {
+  },
+  afterSchema() {
+  }
+};
 
-export default { id, compile, interpret, simpleApplicator, collectEvaluatedProperties, collectEvaluatedItems };
+export default { id, compile, interpret, simpleApplicator, plugin };

lib/core.js

@@ -27,13 +27,13 @@ export const validate = async (url, value = undefined, outputFormat = undefined)
 };
 
 export const compile = async (schema) => {
-  const ast = { metaData: {} };
+  const ast = { metaData: {}, plugins: [] };
   const schemaUri = await Validation.compile(schema, ast);
   return { ast, schemaUri };
 };
 
 export const interpret = curry(({ ast, schemaUri }, instance, outputFormat = FLAG) => {
-  const context = { ast, plugins: [], dynamicAnchors: {} };
+  const context = { ast, plugins: [...ast.plugins] };
 
   switch (outputFormat) {
     case FLAG:

lib/evaluation-plugins/annotations.js

@@ -2,17 +2,17 @@ import * as Instance from "../instance.js";
 
 
 export const annotationsPlugin = {
-  beforeSchema(context) {
+  beforeSchema(_url, _instance, context) {
     context.annotations ??= [];
     context.schemaAnnotations = [];
   },
-  beforeKeyword(context) {
+  beforeKeyword(_node, _instance, context) {
     context.annotations = [];
   },
-  afterKeyword(node, instance, valid, keywordContext, schemaContext, keyword) {
+  afterKeyword(node, instance, context, valid, schemaContext, keyword) {
     if (valid) {
       const [keywordId, schemaUri, keywordValue] = node;
-      const annotation = keyword.annotation?.(keywordValue, instance, keywordContext);
+      const annotation = keyword.annotation?.(keywordValue, instance, context);
       if (annotation !== undefined) {
         schemaContext.schemaAnnotations.push({
           keyword: keywordId,
@@ -21,10 +21,10 @@ export const annotationsPlugin = {
           annotation: annotation
         });
       }
-      schemaContext.schemaAnnotations.push(...keywordContext.annotations);
+      schemaContext.schemaAnnotations.push(...context.annotations);
     }
   },
-  afterSchema(_schemaNode, _instanceNode, valid, context) {
+  afterSchema(_schemaNode, _instanceNode, context, valid) {
     if (valid) {
       context.annotations.push(...context.schemaAnnotations);
     }

lib/evaluation-plugins/basic-output.js

@@ -3,13 +3,13 @@ import * as Instance from "../instance.js";
 
 
 export const basicOutputPlugin = {
-  beforeSchema(schemaContext) {
-    schemaContext.errors ??= [];
+  beforeSchema(_url, _intance, context) {
+    context.errors ??= [];
   },
-  beforeKeyword(keywordContext) {
-    keywordContext.errors = [];
+  beforeKeyword(_node, _instance, context) {
+    context.errors = [];
   },
-  afterKeyword(node, instance, valid, keywordContext, schemaContext, keyword) {
+  afterKeyword(node, instance, context, valid, schemaContext, keyword) {
     if (!valid) {
       if (!keyword.simpleApplicator) {
         const [keywordId, schemaUri] = node;
@@ -19,12 +19,12 @@ export const basicOutputPlugin = {
           instanceLocation: Instance.uri(instance)
         });
       }
-      schemaContext.errors.push(...keywordContext.errors);
+      schemaContext.errors.push(...context.errors);
     }
   },
-  afterSchema(url, instance, valid, schemaContext) {
-    if (typeof schemaContext.ast[url] === "boolean" && !valid) {
-      schemaContext.errors.push({
+  afterSchema(url, instance, context, valid) {
+    if (typeof context.ast[url] === "boolean" && !valid) {
+      context.errors.push({
         keyword: Validation.id,
         absoluteKeywordLocation: url,
         instanceLocation: Instance.uri(instance)

lib/evaluation-plugins/detailed-output.js

@@ -3,13 +3,13 @@ import * as Instance from "../instance.js";
 
 
 export const detailedOutputPlugin = {
-  beforeSchema(schemaContext) {
-    schemaContext.errors ??= [];
+  beforeSchema(_url, _instance, context) {
+    context.errors ??= [];
   },
-  beforeKeyword(keywordContext) {
-    keywordContext.errors = [];
+  beforeKeyword(_node, _instance, context) {
+    context.errors = [];
   },
-  afterKeyword(node, instance, valid, keywordContext, schemaContext) {
+  afterKeyword(node, instance, context, valid, schemaContext) {
     if (!valid) {
       const [keywordId, schemaUri] = node;
       const outputUnit = {
@@ -19,14 +19,14 @@ export const detailedOutputPlugin = {
       };
 
       schemaContext.errors.push(outputUnit);
-      if (keywordContext.errors.length > 0) {
-        outputUnit.errors = keywordContext.errors;
+      if (context.errors.length > 0) {
+        outputUnit.errors = context.errors;
       }
     }
   },
-  afterSchema(url, instance, valid, schemaContext) {
-    if (typeof schemaContext.ast[url] === "boolean" && !valid) {
-      schemaContext.errors.push({
+  afterSchema(url, instance, context, valid) {
+    if (typeof context.ast[url] === "boolean" && !valid) {
+      context.errors.push({
         keyword: Validation.id,
         absoluteKeywordLocation: url,
         instanceLocation: Instance.uri(instance)

lib/experimental.d.ts

@@ -18,6 +18,7 @@ export type CompiledSchema = {
 
 type AST = {
   metaData: Record<string, MetaData>;
+  plugins: EvaluationPlugin<unknown>[];
 } & Record<string, Node<unknown>[] | boolean>;
 
 type Node<A> = [keywordId: string, schemaUri: string, keywordValue: A];
@@ -70,23 +71,20 @@ export type Keyword<A> = {
   compile: (schema: Browser<SchemaDocument>, ast: AST, parentSchema: Browser<SchemaDocument>) => Promise<A>;
   interpret: (compiledKeywordValue: A, instance: JsonNode, context: ValidationContext) => boolean;
   simpleApplicator: boolean;
-  collectEvaluatedProperties?: (compiledKeywordValue: A, instance: JsonNode, context: ValidationContext, isTop?: boolean) => Set<string> | false;
-  collectEvaluatedItems?: (compiledKeywordValue: A, instance: JsonNode, context: ValidationContext, isTop?: boolean) => Set<number> | false;
   collectExternalIds?: (visited: Set<string>, parentSchema: Browser<SchemaDocument>, schema: Browser<SchemaDocument>) => Promise<Set<string>>;
   annotation?: <B>(compiledKeywordValue: A, instance: JsonNode) => B | undefined;
 };
 
 export type ValidationContext = {
   ast: AST;
-  plugins: EvaluationPlugin<unknow>[];
-  dynamicAnchors: Anchors;
+  plugins: EvaluationPlugin<unknown>[];
 };
 
 export type EvaluationPlugin<Context> = {
-  beforeSchema(schemaContext: Context): void;
-  beforeKeyword(keywordContext: Context, schemaContext: Context): void;
-  afterKeyword(keywordNode: JsonNode, instanceNode: JsonNode, valid: boolean, keywordContext: Context, schemaContext: Context, keyword: Keyword): void;
-  afterSchema(schemaNode: JsonNode, instanceNode: JsonNode, valid: boolean, schemaContext: Context): void;
+  beforeSchema(url: string, instance: JsonNode, context: Context): void;
+  beforeKeyword(keywordNode: Node<unknown>, instance: JsonNode, context: Context, schemaContext: Context, keyword: Keyword): void;
+  afterKeyword(keywordNode: Node<unknown>, instance: JsonNode, context: Context, valid: boolean, schemaContext: Context, keyword: Keyword): void;
+  afterSchema(url: string, instance: JsonNode, context: Context, valid: boolean): void;
 };
 
 export const basicOutputPlugin: EvaluationPlugin<ErrorsContext>;