@hyperjump/json-schema 1.5.1 → 1.5.2

package/README.md

@@ -18,7 +18,9 @@ A collection of modules for working with JSON Schemas.
 * Provides utilities for working with annotations
 
 ## Install
-Includes support for node.js (ES Modules, TypeScript) and browsers.
+Includes support for node.js (ES Modules, TypeScript) and browsers (works with
+CSP
+[`unsafe-eval`](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Content-Security-Policy/script-src#unsafe_eval_expressions)).
 
 ### Node.js
 ```bash

package/lib/core.js

@@ -90,9 +90,15 @@ subscribe("validate.metaValidate", async (message, schema) => {
       const isDynamicRefEnabled = isExperimentalKeywordEnabled(dyanmicRefKeywordId);
       setExperimentalKeywordEnabled(dyanmicRefKeywordId, true);
 
+      // itemPattern is experimental, but is necessary for meta-validation
+      const itemPatternKeywordId = "https://json-schema.org/keyword/itemPattern";
+      const isItemPatternEnabled = isExperimentalKeywordEnabled(itemPatternKeywordId);
+      setExperimentalKeywordEnabled(itemPatternKeywordId, true);
+
       const compiledSchema = await compile(schema.dialectId);
       metaValidators[schema.dialectId] = interpret(compiledSchema);
 
+      setExperimentalKeywordEnabled(itemPatternKeywordId, isItemPatternEnabled);
       setExperimentalKeywordEnabled(dyanmicRefKeywordId, isDynamicRefEnabled);
     }
 

package/lib/index.js

@@ -5,6 +5,7 @@ import additionalProperties from "./keywords/additionalProperties.js";
 import allOf from "./keywords/allOf.js";
 import anchor from "./keywords/anchor.js";
 import anyOf from "./keywords/anyOf.js";
+import conditional from "./keywords/conditional.js";
 import const_ from "./keywords/const.js";
 import contains from "./keywords/contains.js";
 import comment from "./keywords/comment.js";
@@ -27,6 +28,7 @@ import exclusiveMinimum from "./keywords/exclusiveMinimum.js";
 import format from "./keywords/format.js";
 import id from "./keywords/id.js";
 import if_ from "./keywords/if.js";
+import itemPattern from "./keywords/itemPattern.js";
 import items from "./keywords/items.js";
 import maxContains from "./keywords/maxContains.js";
 import maxItems from "./keywords/maxItems.js";
@@ -74,6 +76,7 @@ addKeyword(additionalProperties);
 addKeyword(allOf);
 addKeyword(anchor);
 addKeyword(anyOf);
+addKeyword(conditional);
 addKeyword(const_);
 addKeyword(contains);
 addKeyword(comment);
@@ -120,6 +123,7 @@ addKeyword(readOnly);
 addKeyword(ref);
 addKeyword(requireAllExcept);
 addKeyword(required);
+addKeyword(itemPattern);
 addKeyword(title);
 addKeyword(then);
 addKeyword(type);

package/lib/keywords/additionalProperties.js

@@ -1,4 +1,4 @@
-import { filter, every, pipe } from "@hyperjump/pact";
+import { concat, join, empty, map, filter, every, pipe, tap } from "@hyperjump/pact";
 import * as Schema from "../schema.js";
 import * as Instance from "../instance.js";
 import { getKeywordName } from "../keywords.js";
@@ -8,26 +8,24 @@ import Validation from "./validation.js";
 const id = "https://json-schema.org/keyword/additionalProperties";
 
 const compile = async (schema, ast, parentSchema) => {
-  const patterns = [];
-
   const propertiesKeyword = getKeywordName(schema.dialectId, "https://json-schema.org/keyword/properties");
   const propertiesSchema = await Schema.step(propertiesKeyword, parentSchema);
-  if (Schema.typeOf(propertiesSchema, "object")) {
-    for (const name of Schema.keys(propertiesSchema)) {
-      patterns.push(regexEscape(name));
-    }
-  }
+  const propertyPatterns = Schema.typeOf(propertiesSchema, "object")
+    ? map((propertyName) => "^" + regexEscape(propertyName) + "$", Schema.keys(propertiesSchema))
+    : empty();
 
   const patternPropertiesKeyword = getKeywordName(schema.dialectId, "https://json-schema.org/keyword/patternProperties");
   const patternProperties = await Schema.step(patternPropertiesKeyword, parentSchema);
-  if (Schema.typeOf(patternProperties, "object")) {
-    patterns.push(...Schema.keys(patternProperties));
-  }
+  const patternPropertyPatterns = Schema.typeOf(patternProperties, "object")
+    ? Schema.keys(patternProperties)
+    : empty();
+
+  const pattern = pipe(
+    concat(propertyPatterns, patternPropertyPatterns),
+    join("|")
+  ) || "(?!)";
 
-  return [
-    new RegExp(patterns.length > 0 ? patterns.join("|") : "(?!)", "u"),
-    await Validation.compile(schema, ast)
-  ];
+  return [new RegExp(pattern, "u"), await Validation.compile(schema, ast)];
 };
 
 const regexEscape = (string) => string

package/lib/keywords/conditional.js

@@ -0,0 +1,65 @@
+import { pipe, asyncMap, asyncCollectArray } from "@hyperjump/pact";
+import * as Schema from "../schema.js";
+import Validation from "./validation.js";
+
+
+const id = "https://json-schema.org/keyword/conditional";
+const experimental = true;
+
+const compile = (schema, ast) => pipe(
+  Schema.iter(schema),
+  schemaFlatten,
+  asyncMap((subSchema) => Validation.compile(subSchema, ast)),
+  asyncCollectArray
+);
+
+const interpret = (conditional, instance, ast, dynamicAnchors, quiet) => {
+  for (let index = 0; index < conditional.length; index += 2) {
+    const isValid = Validation.interpret(conditional[index], instance, ast, dynamicAnchors, quiet);
+    if (index + 1 === conditional.length) {
+      return isValid;
+    } else if (isValid) {
+      return Validation.interpret(conditional[index + 1], instance, ast, dynamicAnchors, quiet);
+    }
+  }
+
+  return true;
+};
+
+const collectEvaluatedProperties = (conditional, instance, ast, dynamicAnchors) => {
+  for (let index = 0; index < conditional.length; index += 2) {
+    const unevaluatedProperties = Validation.collectEvaluatedProperties(conditional[index], instance, ast, dynamicAnchors);
+    if (index + 1 === conditional.length) {
+      return unevaluatedProperties;
+    } else if (unevaluatedProperties !== false) {
+      return Validation.collectEvaluatedProperties(conditional[index + 1], instance, ast, dynamicAnchors);
+    }
+  }
+
+  return new Set();
+};
+
+const collectEvaluatedItems = (conditional, instance, ast, dynamicAnchors) => {
+  for (let index = 0; index < conditional.length; index += 2) {
+    const unevaluatedItems = Validation.collectEvaluatedItems(conditional[index], instance, ast, dynamicAnchors);
+    if (index + 1 === conditional.length) {
+      return unevaluatedItems;
+    } else if (unevaluatedItems !== false) {
+      return Validation.collectEvaluatedItems(conditional[index + 1], instance, ast, dynamicAnchors);
+    }
+  }
+
+  return new Set();
+};
+
+const schemaFlatten = async function* (iter, depth = 1) {
+  for await (const n of iter) {
+    if (depth > 0 && Schema.typeOf(n, "array")) {
+      yield* schemaFlatten(Schema.iter(n), depth - 1);
+    } else {
+      yield n;
+    }
+  }
+};
+
+export default { id, experimental, compile, interpret, collectEvaluatedProperties, collectEvaluatedItems };

package/lib/keywords/contains.js

@@ -1,4 +1,4 @@
-import { pipe, map, filter, reduce, collectSet, zip, range } from "@hyperjump/pact";
+import { pipe, map, filter, count, collectSet, zip, range } from "@hyperjump/pact";
 import * as Schema from "../schema.js";
 import * as Instance from "../instance.js";
 import { getKeywordName } from "../keywords.js";
@@ -34,7 +34,7 @@ const interpret = ({ contains, minContains, maxContains }, instance, ast, dynami
   const matches = pipe(
     iterator,
     filter((item) => Validation.interpret(contains, item, ast, dynamicAnchors, quiet)),
-    reduce((matches) => matches + 1, 0)
+    count
   );
   return matches >= minContains && matches <= maxContains;
 };

package/lib/keywords/dependentRequired.js

@@ -12,10 +12,8 @@ const compile = (schema) => pipe(
 );
 
 const interpret = (dependentRequired, instance) => {
-  const value = Instance.value(instance);
-
   return !Instance.typeOf(instance, "object") || dependentRequired.every(([propertyName, required]) => {
-    return !(propertyName in value) || required.every((key) => key in value);
+    return !Instance.has(propertyName, instance) || required.every((key) => Instance.has(key, instance));
   });
 };
 

package/lib/keywords/dependentSchemas.js

@@ -13,22 +13,19 @@ const compile = (schema, ast) => pipe(
 );
 
 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, quiet);
+    return !Instance.has(propertyName, instance) || Validation.interpret(dependentSchema, instance, ast, dynamicAnchors, quiet);
   });
 };
 
 const collectEvaluatedProperties = (dependentSchemas, instance, ast, dynamicAnchors) => {
-  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) {
+    if (Instance.has(propertyName, instance)) {
       const propertyNames = Validation.collectEvaluatedProperties(dependentSchema, instance, ast, dynamicAnchors);
       if (propertyNames === false) {
         return false;

package/lib/keywords/itemPattern.js

@@ -0,0 +1,88 @@
+import * as Schema from "../schema.js";
+import * as Instance from "../instance.js";
+import Validation from "./validation.js";
+import { fromEpsilon, fromSchema, closure, zeroOrOne, oneOrMore, concat, union } from "../nfa.js";
+
+
+const id = "https://json-schema.org/keyword/itemPattern";
+const experimental = true;
+
+const compile = async (schema, ast) => {
+  const groups = [[]];
+  let group = groups[0];
+
+  for await (const rule of Schema.iter(schema)) {
+    if (Schema.typeOf(rule, "string")) {
+      const operator = Schema.value(rule);
+
+      if (operator === "*") {
+        group.push(closure(group.pop()));
+      } else if (operator === "?") {
+        group.push(zeroOrOne(group.pop()));
+      } else if (operator === "+") {
+        group.push(oneOrMore(group.pop()));
+      } else if (operator === "|") {
+        group = [];
+        groups.push(group);
+      } else {
+        throw Error(`Unsupported pattern syntax: ${operator}`);
+      }
+    } else {
+      const node = Schema.typeOf(rule, "array")
+        ? compile(rule, ast)
+        : fromSchema(await Validation.compile(rule, ast));
+      group.push(await node);
+    }
+  }
+
+  return Schema.length(schema) === 0 ? fromEpsilon() : groups
+    .map((group) => group.reduce(concat))
+    .reduce(union);
+};
+
+const interpret = (nfa, instance, ast, dynamicAnchors, quiet) => {
+  if (!Instance.typeOf(instance, "array")) {
+    return true;
+  }
+
+  let currentStates = [];
+  addNextState(nfa.start, currentStates, []);
+
+  for (const item of Instance.iter(instance)) {
+    const nextStates = [];
+
+    for (const state of currentStates) {
+      const nextState = transition(state.transition, item, ast, dynamicAnchors, quiet);
+      if (nextState) {
+        addNextState(nextState, nextStates, []);
+      }
+    }
+
+    currentStates = nextStates;
+  }
+
+  return Boolean(currentStates.find((s) => s.isEnd));
+};
+
+const addNextState = (state, nextStates, visited) => {
+  if (state.epsilonTransitions.length) {
+    for (const epsilonState of state.epsilonTransitions) {
+      if (!visited.find((visited) => visited === epsilonState)) {
+        visited.push(epsilonState);
+        addNextState(epsilonState, nextStates, visited);
+      }
+    }
+  } else {
+    nextStates.push(state);
+  }
+};
+
+const transition = (transitions, instance, ast, dynamicAnchors, quiet) => {
+  for (const schema in transitions) {
+    if (Validation.interpret(schema, instance, ast, dynamicAnchors, quiet)) {
+      return transitions[schema];
+    }
+  }
+};
+
+export default { id, experimental, compile, interpret };

package/lib/keywords/prefixItems.js

@@ -13,11 +13,7 @@ const compile = (schema, ast) => pipe(
 );
 
 const interpret = (prefixItems, instance, ast, dynamicAnchors, quiet) => {
-  if (!Instance.typeOf(instance, "array")) {
-    return true;
-  }
-
-  return pipe(
+  return !Instance.typeOf(instance, "array") || pipe(
     zip(prefixItems, Instance.iter(instance)),
     take(Instance.length(instance)),
     every(([prefixItem, item]) => Validation.interpret(prefixItem, item, ast, dynamicAnchors, quiet))

package/lib/nfa.js

@@ -0,0 +1,95 @@
+export const fromEpsilon = () => {
+  const start = createState(false);
+  const end = createState(true);
+  addEpsilonTransition(start, end);
+
+  return { start, end };
+};
+
+export const fromSchema = (schema) => {
+  const start = createState(false);
+  const end = createState(true);
+  addTransition(start, end, schema);
+
+  return { start, end };
+};
+
+export const concat = (first, second) => {
+  if (first === undefined) {
+    return second;
+  }
+  addEpsilonTransition(first.end, second.start);
+  first.end.isEnd = false;
+
+  return { start: first.start, end: second.end };
+};
+
+export const union = (first, second) => {
+  const start = createState(false);
+  addEpsilonTransition(start, first.start);
+  addEpsilonTransition(start, second.start);
+
+  const end = createState(true);
+
+  addEpsilonTransition(first.end, end);
+  first.end.isEnd = false;
+  addEpsilonTransition(second.end, end);
+  second.end.isEnd = false;
+
+  return { start, end };
+};
+
+export const closure = (nfa) => {
+  const start = createState(false);
+  const end = createState(true);
+
+  addEpsilonTransition(start, end);
+  addEpsilonTransition(start, nfa.start);
+
+  addEpsilonTransition(nfa.end, end);
+  addEpsilonTransition(nfa.end, nfa.start);
+  nfa.end.isEnd = false;
+
+  return { start, end };
+};
+
+export const zeroOrOne = (nfa) => {
+  const start = createState(false);
+  const end = createState(true);
+
+  addEpsilonTransition(start, end);
+  addEpsilonTransition(start, nfa.start);
+
+  addEpsilonTransition(nfa.end, end);
+  nfa.end.isEnd = false;
+
+  return { start, end };
+};
+
+export const oneOrMore = (nfa) => {
+  const start = createState(false);
+  const end = createState(true);
+
+  addEpsilonTransition(start, nfa.start);
+  addEpsilonTransition(nfa.end, end);
+  addEpsilonTransition(nfa.end, nfa.start);
+  nfa.end.isEnd = false;
+
+  return { start, end };
+};
+
+const addEpsilonTransition = (from, to) => {
+  from.epsilonTransitions.push(to);
+};
+
+const addTransition = (from, to, symbol) => {
+  from.transition[symbol] = to;
+};
+
+const createState = (isEnd) => {
+  return {
+    isEnd,
+    transition: {},
+    epsilonTransitions: []
+  };
+};

package/lib/schema.js

@@ -204,7 +204,7 @@ const getAnchorPointer = (schema, fragment) => {
 
 // Utility Functions
 export const uri = (doc) => doc.id ? `${doc.id}#${encodeURI(doc.pointer)}` : undefined;
-export const value = (doc) => Reference.isReference(doc.value) ? Reference.value(doc.value) : doc.value;
+export const value = (doc) => doc.value;
 export const has = (key, doc) => key in value(doc);
 export const typeOf = (doc, type) => jsonTypeOf(value(doc), type);
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hyperjump/json-schema",
-  "version": "1.5.1",
+  "version": "1.5.2",
   "description": "A JSON Schema validator with support for custom keywords, vocabularies, and dialects",
   "type": "module",
   "main": "./stable/index.js",
@@ -64,7 +64,7 @@
   },
   "dependencies": {
     "@hyperjump/json-pointer": "^1.0.0",
-    "@hyperjump/pact": "^1.0.0",
+    "@hyperjump/pact": "^1.2.0",
     "@hyperjump/uri": "^1.2.0",
     "content-type": "^1.0.4",
     "fastest-stable-stringify": "^2.0.2",

package/stable/index.js

@@ -34,7 +34,9 @@ defineVocabulary("https://json-schema.org/vocab/applicator", {
   "if": "https://json-schema.org/keyword/if",
   "then": "https://json-schema.org/keyword/then",
   "else": "https://json-schema.org/keyword/else",
+  "conditional": "https://json-schema.org/keyword/conditional",
   "items": "https://json-schema.org/keyword/items",
+  "itemPattern": "https://json-schema.org/keyword/itemPattern",
   "not": "https://json-schema.org/keyword/not",
   "oneOf": "https://json-schema.org/keyword/oneOf",
   "patternProperties": "https://json-schema.org/keyword/patternProperties",

package/stable/meta/applicator.js

@@ -8,6 +8,7 @@ export default {
     "prefixItems": { "$ref": "#/$defs/schemaArray" },
     "items": { "$dynamicRef": "meta" },
     "contains": { "$dynamicRef": "meta" },
+    "itemPattern": { "$ref": "#/$defs/itemPattern" },
     "additionalProperties": { "$dynamicRef": "meta" },
     "properties": {
       "type": "object",
@@ -33,6 +34,16 @@ export default {
     "if": { "$dynamicRef": "meta" },
     "then": { "$dynamicRef": "meta" },
     "else": { "$dynamicRef": "meta" },
+    "conditional": {
+      "type": "array",
+      "items": {
+        "if": { "type": "array" },
+        "then": {
+          "items": { "$dynamicRef": "meta" }
+        },
+        "else": { "$dynamicRef": "meta" }
+      }
+    },
     "allOf": { "$ref": "#/$defs/schemaArray" },
     "anyOf": { "$ref": "#/$defs/schemaArray" },
     "oneOf": { "$ref": "#/$defs/schemaArray" },
@@ -44,6 +55,21 @@ export default {
       "type": "array",
       "minItems": 1,
       "items": { "$dynamicRef": "meta" }
+    },
+    "itemPattern": {
+      "type": "array",
+      "itemPattern": [
+        [
+          {
+            "if": { "type": "array" },
+            "then": { "$ref": "#/$defs/itemPattern" },
+            "else": { "$dynamicRef": "meta" }
+          },
+          { "enum": ["?", "*", "+"] }, "?",
+          "|",
+          { "const": "|" }
+        ], "*"
+      ]
     }
   }
 };