@hyperjump/json-schema 1.2.2 → 1.2.4

package/lib/core.js

@@ -1,6 +1,12 @@
 import curry from "just-curry-it";
-import * as PubSub from "./pubsub.js";
-import * as Configuration from "./configuration.js";
+import { subscribe, unsubscribe } from "./pubsub.js";
+import {
+  setMetaSchemaOutputFormat,
+  getShouldValidateSchema,
+  isExperimentalKeywordEnabled,
+  setExperimentalKeywordEnabled,
+  getMetaSchemaOutputFormat
+} from "./configuration.js";
 import * as Instance from "./instance.js";
 import { InvalidSchemaError } from "./invalid-schema-error.js";
 import * as Schema from "./schema.js";
@@ -8,7 +14,7 @@ import Validation from "./keywords/validation.js";
 
 
 export const FLAG = "FLAG", BASIC = "BASIC", DETAILED = "DETAILED", VERBOSE = "VERBOSE";
-Configuration.setMetaSchemaOutputFormat(FLAG);
+setMetaSchemaOutputFormat(FLAG);
 
 export const validate = async (url, value = undefined, outputFormat = undefined) => {
   const compiled = await compile(url);
@@ -30,9 +36,12 @@ export const interpret = curry(({ ast, schemaUri }, value, outputFormat = FLAG)
   }
 
   const output = [];
-  const subscriptionToken = PubSub.subscribe("result", outputHandler(outputFormat, output));
-  Validation.interpret(schemaUri, value, ast, {});
-  PubSub.unsubscribe("result", subscriptionToken);
+  const subscriptionToken = subscribe("result", outputHandler(outputFormat, output));
+  try {
+    Validation.interpret(schemaUri, value, ast, {});
+  } finally {
+    unsubscribe("result", subscriptionToken);
+  }
 
   return output[0];
 });
@@ -70,26 +79,26 @@ const outputHandler = (outputFormat, output) => {
 };
 
 const metaValidators = {};
-PubSub.subscribe("validate.metaValidate", async (message, schema) => {
-  if (Configuration.getShouldValidateSchema() && !schema.validated) {
+subscribe("validate.metaValidate", async (message, schema) => {
+  if (getShouldValidateSchema() && !schema.validated) {
     Schema.markValidated(schema.id);
 
     // Compile
     if (!(schema.dialectId in metaValidators)) {
       // Dynamic references are experimental, but are necessary for meta-validation
       const dyanmicRefKeywordId = "https://json-schema.org/keyword/dynamicRef";
-      const isDynamicRefEnabled = Configuration.isExperimentalKeywordEnabled(dyanmicRefKeywordId);
-      Configuration.setExperimentalKeywordEnabled(dyanmicRefKeywordId, true);
+      const isDynamicRefEnabled = isExperimentalKeywordEnabled(dyanmicRefKeywordId);
+      setExperimentalKeywordEnabled(dyanmicRefKeywordId, true);
 
       const compiledSchema = await compile(schema.dialectId);
       metaValidators[schema.dialectId] = interpret(compiledSchema);
 
-      Configuration.setExperimentalKeywordEnabled(dyanmicRefKeywordId, isDynamicRefEnabled);
+      setExperimentalKeywordEnabled(dyanmicRefKeywordId, isDynamicRefEnabled);
     }
 
     // Interpret
     const schemaInstance = Instance.cons(schema.schema, schema.id);
-    const metaResults = metaValidators[schema.dialectId](schemaInstance, Configuration.getMetaSchemaOutputFormat());
+    const metaResults = metaValidators[schema.dialectId](schemaInstance, getMetaSchemaOutputFormat());
     if (!metaResults.valid) {
       throw new InvalidSchemaError(metaResults);
     }

package/lib/fetch.js

@@ -1,5 +1,5 @@
 import fs from "fs/promises";
-import fetch, { Response } from "node-fetch";
+import { fetch, Response } from "undici";
 import Url from "url";
 import * as MediaTypes from "./media-types.js";
 

package/lib/index.js

@@ -57,6 +57,7 @@ import type from "./keywords/type.js";
 import unevaluatedItems from "./keywords/unevaluatedItems.js";
 import unevaluatedProperties from "./keywords/unevaluatedProperties.js";
 import uniqueItems from "./keywords/uniqueItems.js";
+import unknown from "./keywords/unknown.js";
 import vocabulary from "./keywords/vocabulary.js";
 import writeOnly from "./keywords/writeOnly.js";
 
@@ -125,6 +126,7 @@ addKeyword(type);
 addKeyword(unevaluatedItems);
 addKeyword(unevaluatedProperties);
 addKeyword(uniqueItems);
+addKeyword(unknown);
 addKeyword(vocabulary);
 addKeyword(writeOnly);
 

package/lib/keywords/meta-data.js

@@ -1,4 +1,7 @@
-const compile = (schema) => schema.value;
+import { value } from "../schema.js";
+
+
+const compile = value;
 const interpret = () => true;
 
 export default { compile, interpret };

package/lib/keywords/unknown.js

@@ -0,0 +1,4 @@
+import metaData from "./meta-data.js";
+
+
+export default { id: "https://json-schema.org/keyword/unknown", ...metaData };

package/lib/keywords/validation.js

@@ -27,7 +27,7 @@ const compile = async (schema, ast) => {
 
     const schemaValue = Schema.value(schema);
     if (!["object", "boolean"].includes(typeof schemaValue)) {
-      throw Error(`No schema found at '${Schema.uri(schema)}'`);
+      throw Error(`No schema found at '${url}'`);
     }
 
     ast[url] = [
@@ -38,12 +38,15 @@ const compile = async (schema, ast) => {
         Pact.map(async ([keyword, keywordSchema]) => {
           const keywordId = getKeywordId(schema.dialectId, keyword);
           if (!keywordId) {
-            throw Error(`Encountered unknown keyword '${keyword}' at ${Schema.uri(schema)}`);
+            throw Error(`Encountered unknown keyword '${keyword}' at ${url}`);
           }
 
           const keywordHandler = getKeyword(keywordId);
+          if (!keywordHandler) {
+            throw Error(`Encountered unsupported keyword ${keyword} at '${url}'. You can provide an implementation for the '${keywordId}' keyword using the 'addKeyword' function.`);
+          }
           if (keywordHandler.experimental && !isExperimentalKeywordEnabled(keywordId)) {
-            throw Error(`Encountered experimental keyword ${keyword} at '${Schema.uri(schema)}'. You can enable this keyword with: setExperimentalKeywordEnabled('${keywordId}', true)`);
+            throw Error(`Encountered experimental keyword ${keyword} at '${url}'. You can enable this keyword with: setExperimentalKeywordEnabled('${keywordId}', true)`);
           }
 
           const keywordAst = await keywordHandler.compile(keywordSchema, ast, schema);
@@ -89,6 +92,7 @@ const interpret = (url, instance, ast, dynamicAnchors) => {
   return isValid;
 };
 
+const emptyPropertyNames = [];
 const collectEvaluatedProperties = (url, instance, ast, dynamicAnchors, isTop = false) => {
   const nodes = ast[url][2];
 
@@ -96,14 +100,28 @@ const collectEvaluatedProperties = (url, instance, ast, dynamicAnchors, isTop =
     return nodes ? [] : false;
   }
 
-  return nodes
-    .filter(([keywordId]) => !isTop || keywordId !== "https://json-schema.org/keyword/unevaluatedProperties")
-    .reduce((acc, [keywordId, , keywordValue]) => {
-      const propertyNames = acc && getKeyword(keywordId).collectEvaluatedProperties(keywordValue, instance, ast, dynamicAnchors);
-      return propertyNames !== false && [...acc, ...propertyNames];
-    }, []);
+  const accumulatedPropertyNames = [];
+  for (const [keywordId, , keywordValue] of nodes) {
+    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, isTop) && emptyPropertyNames;
+
+    if (propertyNames === false) {
+      return false;
+    }
+
+    Array.prototype.push.apply(accumulatedPropertyNames, propertyNames);
+  }
+
+  return accumulatedPropertyNames;
 };
 
+const emptyItemIndexes = new Set();
 const collectEvaluatedItems = (url, instance, ast, dynamicAnchors, isTop = false) => {
   const nodes = ast[url][2];
 
@@ -111,12 +129,25 @@ const collectEvaluatedItems = (url, instance, ast, dynamicAnchors, isTop = false
     return nodes ? new Set() : false;
   }
 
-  return nodes
-    .filter(([keywordId]) => !isTop || keywordId !== "https://json-schema.org/keyword/unevaluatedItems")
-    .reduce((acc, [keywordId, , keywordValue]) => {
-      const itemIndexes = acc !== false && getKeyword(keywordId).collectEvaluatedItems(keywordValue, instance, ast, dynamicAnchors);
-      return itemIndexes !== false && new Set([...acc, ...itemIndexes]);
-    }, new Set());
+  const accumulatedItemIndexes = new Set();
+  for (const [keywordId, , keywordValue] of nodes) {
+    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, isTop) && emptyItemIndexes;
+
+    if (itemIndexes === false) {
+      return false;
+    }
+
+    itemIndexes.forEach(Set.prototype.add.bind(accumulatedItemIndexes));
+  }
+
+  return accumulatedItemIndexes;
 };
 
 export default { id, compile, interpret, collectEvaluatedProperties, collectEvaluatedItems };

package/lib/keywords.js

@@ -1,19 +1,8 @@
-import metaData from "./keywords/meta-data.js";
-
-
 const _keywords = {};
-export const getKeyword = (id) => _keywords[id] || id.startsWith("https://json-schema.org/keyword/unknown#") && { id, ...metaData };
+export const getKeyword = (id) => _keywords[id];
 
 export const addKeyword = (keywordHandler) => {
-  _keywords[keywordHandler.id] = {
-    collectEvaluatedItems: (keywordValue, instance, ast, dynamicAnchors, isTop) => {
-      return keywordHandler.interpret(keywordValue, instance, ast, dynamicAnchors, isTop) && new Set();
-    },
-    collectEvaluatedProperties: (keywordValue, instance, ast, dynamicAnchors, isTop) => {
-      return keywordHandler.interpret(keywordValue, instance, ast, dynamicAnchors, isTop) && [];
-    },
-    ...keywordHandler
-  };
+  _keywords[keywordHandler.id] = keywordHandler;
 };
 
 const _vocabularies = {};
@@ -24,7 +13,7 @@ export const defineVocabulary = (id, keywords) => {
 const _dialects = {};
 const _allowUnknownKeywords = {};
 export const getKeywordId = (dialectId, keyword) => _dialects[dialectId]?.[keyword]
-  || _allowUnknownKeywords[dialectId] && `https://json-schema.org/keyword/unknown#${keyword}`;
+  || _allowUnknownKeywords[dialectId] && "https://json-schema.org/keyword/unknown";
 export const getKeywordName = (dialectId, keywordId) => {
   for (const keyword in _dialects[dialectId]) {
     if (_dialects[dialectId][keyword] === keywordId) {
@@ -44,14 +33,9 @@ export const loadDialect = (dialectId, dialect, allowUnknownKeywords = false) =>
       if (vocabularyId in _vocabularies) {
         Object.entries(_vocabularies[vocabularyId])
           .forEach(([keyword, keywordId]) => {
-            if (!(keywordId in _keywords)) {
-              if (isRequired) {
-                delete _dialects[dialectId];
-                throw Error(`The '${keywordId}' keyword is not supported. This keyword was included in the '${vocabularyId}' vocabulary which is required by the '${dialectId}' dialect.`);
-              } else {
-                // Allow keyword to be ignored
-                keywordId = `https://json-schema.org/keyword/unknown#${keyword}`;
-              }
+            if (!(keywordId in _keywords) && !isRequired) {
+              // Allow keyword to be ignored
+              keywordId = "https://json-schema.org/keyword/unknown";
             }
             _dialects[dialectId][keyword] = keywordId;
           });

package/lib/media-types.d.ts

@@ -1,4 +1,5 @@
 import type { SchemaObject } from "./schema.js";
+import type { Response } from "undici";
 
 
 export const addMediaTypePlugin: (contentType: string, plugin: MediaTypePlugin) => void;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hyperjump/json-schema",
-  "version": "1.2.2",
+  "version": "1.2.4",
   "description": "A JSON Schema validator with support for custom keywords, vocabularies, and dialects",
   "type": "module",
   "main": "./stable/index.js",
@@ -56,7 +56,6 @@
     "eslint-plugin-import": "*",
     "json-schema-test-suite": "github:json-schema-org/JSON-Schema-Test-Suite",
     "mocha": "*",
-    "nock": "*",
     "ts-node": "*",
     "typescript": "*",
     "yaml": "*"
@@ -67,10 +66,10 @@
     "@hyperjump/uri": "^1.0.0",
     "content-type": "^1.0.4",
     "fastest-stable-stringify": "^2.0.2",
-    "node-fetch": "^3.3.0",
+    "undici": "^5.19.1",
     "uuid": "^9.0.0"
   },
   "engines": {
-    "node": "^18.0.0"
+    "node": ">=18.0.0"
   }
 }