@hyperjump/json-schema 1.2.3 → 1.2.5

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";
 
@@ -9,10 +9,11 @@ export default async (url, options) => {
     const filePath = Url.fileURLToPath(url);
     const fd = await fs.open(filePath);
     const stream = fd.createReadStream();
-    return new Response(stream, {
-      url: url,
+    const response = new Response(stream, {
       headers: { "Content-Type": MediaTypes.getContentType(filePath) }
     });
+    Object.defineProperty(response, "url", { value: url });
+    return response;
   } else {
     return fetch(url, options);
   }

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);

package/lib/keywords.js

@@ -1,8 +1,5 @@
-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] = keywordHandler;
@@ -16,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) {
@@ -36,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/lib/openapi.js

@@ -11,7 +11,9 @@ addMediaTypePlugin("application/openapi+json", {
     let defaultDialect;
     const version = doc.openapi || contentTypeParameters.version;
 
-    if (is30(version)) {
+    if (!version) {
+      throw Error("Invalid OpenAPI document. Add the 'openapi' field and try again.");
+    } else if (is30(version)) {
       defaultDialect = "https://spec.openapis.org/oas/3.0/schema";
     } else if (is31(version)) {
       if (!("jsonSchemaDialect" in doc) || doc.jsonSchemaDialect === "https://spec.openapis.org/oas/3.1/dialect/base") {
@@ -20,7 +22,7 @@ addMediaTypePlugin("application/openapi+json", {
         defaultDialect = `https://spec.openapis.org/oas/3.1/schema-${encodeURIComponent(doc.jsonSchemaDialect)}`;
       }
     } else {
-      throw Error("Invalid OpenAPI document. Add the 'openapi' field and try again.");
+      throw Error(`Encountered unsupported OpenAPI version '${version}' in ${response.url}`);
     }
 
     return [doc, defaultDialect];

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

@@ -33,28 +33,28 @@ export type OasSchema30 = {
   anyOf?: OasSchema30[];
   oneOf?: OasSchema30[];
   not?: OasSchema30;
-  example: Json;
-  discriminator: Discriminator;
-  externalDocs: ExternalDocs;
-  xml: Xml;
+  example?: Json;
+  discriminator?: Discriminator;
+  externalDocs?: ExternalDocs;
+  xml?: Xml;
 };
 
 type Discriminator = {
   propertyName: string;
-  mappings: Record<string, string>;
+  mappings?: Record<string, string>;
 };
 
 type ExternalDocs = {
   url: string;
-  description: string;
+  description?: string;
 };
 
 type Xml = {
-  name: string;
-  namespace: string;
-  prefix: string;
-  attribute: boolean;
-  wrapped: boolean;
+  name?: string;
+  namespace?: string;
+  prefix?: string;
+  attribute?: boolean;
+  wrapped?: boolean;
 };
 
 export * from "../lib/index.js";

package/openapi-3-0/schema/2021-09-28.js

@@ -193,16 +193,7 @@ export default {
         "schemas": {
           "type": "object",
           "patternProperties": {
-            "^[a-zA-Z0-9\\.\\-_]+$": {
-              "oneOf": [
-                {
-                  "$ref": "#/definitions/Schema"
-                },
-                {
-                  "$ref": "#/definitions/Reference"
-                }
-              ]
-            }
+            "^[a-zA-Z0-9\\.\\-_]+$": { "$ref": "#/definitions/Schema" }
           }
         },
         "responses": {
@@ -384,16 +375,7 @@ export default {
     "MediaType": {
       "type": "object",
       "properties": {
-        "schema": {
-          "oneOf": [
-            {
-              "$ref": "#/definitions/Schema"
-            },
-            {
-              "$ref": "#/definitions/Reference"
-            }
-          ]
-        },
+        "schema": { "$ref": "#/definitions/Schema" },
         "example": {
         },
         "examples": {
@@ -481,16 +463,7 @@ export default {
           "type": "boolean",
           "default": false
         },
-        "schema": {
-          "oneOf": [
-            {
-              "$ref": "#/definitions/Schema"
-            },
-            {
-              "$ref": "#/definitions/Reference"
-            }
-          ]
-        },
+        "schema": { "$ref": "#/definitions/Schema" },
         "content": {
           "type": "object",
           "additionalProperties": {
@@ -853,16 +826,7 @@ export default {
           "type": "boolean",
           "default": false
         },
-        "schema": {
-          "oneOf": [
-            {
-              "$ref": "#/definitions/Schema"
-            },
-            {
-              "$ref": "#/definitions/Reference"
-            }
-          ]
-        },
+        "schema": { "$ref": "#/definitions/Schema" },
         "content": {
           "type": "object",
           "additionalProperties": {

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

@@ -61,28 +61,28 @@ export type OasSchema31 = boolean | {
   contentMediaType?: string;
   contentEncoding?: string;
   contentSchema?: OasSchema31;
-  example: Json;
-  discriminator: Discriminator;
-  externalDocs: ExternalDocs;
-  xml: Xml;
+  example?: Json;
+  discriminator?: Discriminator;
+  externalDocs?: ExternalDocs;
+  xml?: Xml;
 };
 
 type Discriminator = {
   propertyName: string;
-  mappings: Record<string, string>;
+  mappings?: Record<string, string>;
 };
 
 type ExternalDocs = {
   url: string;
-  description: string;
+  description?: string;
 };
 
 type Xml = {
-  name: string;
-  namespace: string;
-  prefix: string;
-  attribute: boolean;
-  wrapped: boolean;
+  name?: string;
+  namespace?: string;
+  prefix?: string;
+  attribute?: boolean;
+  wrapped?: boolean;
 };
 
 export * from "../lib/index.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hyperjump/json-schema",
-  "version": "1.2.3",
+  "version": "1.2.5",
   "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,7 +66,7 @@
     "@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": {