@hyperjump/json-schema 0.20.0 → 0.21.0

package/README.md

@@ -88,6 +88,43 @@ JsonSchema.setMetaOutputFormat(JsonSchema.FLAG);
 JsonSchema.setShouldMetaValidate(false);
 ```
 
+### Media Types
+JSV has a plugin system for adding support for different media types. By default
+it's configured to accept schemas that have the `application/schema+json`
+Content-Type (web) or a `.schema.json` file extension (filesystem). If for
+example, you want to fetch schemas that are written in YAML, you can add a
+MediaTypePlugin to support that.
+
+* **Core.addMediaTypePlugin**: (contentType: string, plugin: MediaTypePlugin) => void
+
+    Add a custom media type handler to support things like YAML or to change the
+    way JSON is supported.
+* **MediaTypePlugin**: object
+
+    * parse: (response: Response) => string -- Given a fetch Response object,
+      parse the body of the request
+    * matcher: (path) => boolean -- Given a filesystem path, return whether or
+      not the file should be considered a member of this media type
+
+```javascript
+const JsonSchema = require("@hyperjump/json-schema");
+
+
+// Add support for JSON Schemas written in YAML
+JsonSchema.addMediaTypePlugin("application/schema+yaml", {
+  parse: async (response) => YAML.parse(await response.text()),
+  matcher: (path) => path.endsWith(".schema.yaml")
+});
+
+// Example: Fetch schema with Content-Type: application/schema+yaml from the web
+const schema = await JsonSchema.get("http://example.com/schemas/string");
+
+// Example: Fetch from file with JSON Schema YAML file extension
+const schema = await JsonSchema.get("file:///path/to/my/schemas/string.schema.yaml");
+
+// Then validate against your schema like normal
+```
+
 ## TypeScript
 Although the package is written in JavaScript, type definitions are included for
 TypeScript support. The following example shows the types you might want to

package/dist/json-schema-amd.js

@@ -2090,6 +2090,88 @@ define(['exports'], (function (exports) { 'use strict';
 
 	var instance = { nil: nil$1, cons, uri: uri$1, value: value$1, has: has$1, typeOf: typeOf$1, step: step$1, entries: entries$3, keys: keys$1, map: map$4, filter: filter$1, reduce: reduce$3, every: every$1, some: some$1, length: length$1 };
 
+	var entries$2 = async (doc) => Object.entries(await doc);
+
+	const curry$7 = justCurryIt;
+
+
+	var map$3 = curry$7(async (fn, doc) => (await doc).map(fn));
+
+	const curry$6 = justCurryIt;
+
+
+	var reduce$2 = curry$6(async (fn, acc, doc) => {
+	  return (await doc).reduce(async (acc, item) => fn(await acc, item), acc);
+	});
+
+	const curry$5 = justCurryIt;
+	const reduce$1 = reduce$2;
+
+
+	var filter = curry$5(async (fn, doc, options = {}) => {
+	  return reduce$1(async (acc, item) => {
+	    return (await fn(item)) ? acc.concat([item]) : acc;
+	  }, [], doc, options);
+	});
+
+	const curry$4 = justCurryIt;
+	const map$2 = map$3;
+
+
+	var some = curry$4(async (fn, doc) => {
+	  const results = await map$2(fn, doc);
+	  return (await Promise.all(results))
+	    .some((a) => a);
+	});
+
+	const curry$3 = justCurryIt;
+	const map$1 = map$3;
+
+
+	var every = curry$3(async (fn, doc) => {
+	  const results = await map$1(fn, doc);
+	  return (await Promise.all(results))
+	    .every((a) => a);
+	});
+
+	const curry$2 = justCurryIt;
+
+
+	var pipeline$1 = curry$2((fns, doc) => {
+	  return fns.reduce(async (acc, fn) => fn(await acc), doc);
+	});
+
+	var all = (doc) => Promise.all(doc);
+
+	const pipeline = pipeline$1;
+	const entries$1 = entries$2;
+	const reduce = reduce$2;
+
+
+	var allValues = (doc) => {
+	  return pipeline([
+	    entries$1,
+	    reduce(async (acc, [propertyName, propertyValue]) => {
+	      acc[propertyName] = await propertyValue;
+	      return acc;
+	    }, {})
+	  ], doc);
+	};
+
+	var lib$2 = {
+	  entries: entries$2,
+	  map: map$3,
+	  filter: filter,
+	  reduce: reduce$2,
+	  some: some,
+	  every: every,
+	  pipeline: pipeline$1,
+	  all: all,
+	  allValues: allValues
+	};
+
+	var fetch_browser = fetch;
+
 	var contentType = {};
 
 	/*!
@@ -2144,7 +2226,7 @@ define(['exports'], (function (exports) { 'use strict';
 	 */
 
 	contentType.format = format$1;
-	contentType.parse = parse;
+	contentType.parse = parse$1;
 
 	/**
 	 * Format object to media type.
@@ -2195,7 +2277,7 @@ define(['exports'], (function (exports) { 'use strict';
 	 * @public
 	 */
 
-	function parse (string) {
+	function parse$1 (string) {
 	  if (!string) {
 	    throw new TypeError('argument string is required')
 	  }
@@ -2313,97 +2395,47 @@ define(['exports'], (function (exports) { 'use strict';
 	  this.type = type;
 	}
 
-	var entries$2 = async (doc) => Object.entries(await doc);
-
-	const curry$7 = justCurryIt;
-
-
-	var map$3 = curry$7(async (fn, doc) => (await doc).map(fn));
-
-	const curry$6 = justCurryIt;
-
-
-	var reduce$2 = curry$6(async (fn, acc, doc) => {
-	  return (await doc).reduce(async (acc, item) => fn(await acc, item), acc);
-	});
-
-	const curry$5 = justCurryIt;
-	const reduce$1 = reduce$2;
-
-
-	var filter = curry$5(async (fn, doc, options = {}) => {
-	  return reduce$1(async (acc, item) => {
-	    return (await fn(item)) ? acc.concat([item]) : acc;
-	  }, [], doc, options);
-	});
-
-	const curry$4 = justCurryIt;
-	const map$2 = map$3;
-
-
-	var some = curry$4(async (fn, doc) => {
-	  const results = await map$2(fn, doc);
-	  return (await Promise.all(results))
-	    .some((a) => a);
-	});
-
-	const curry$3 = justCurryIt;
-	const map$1 = map$3;
-
-
-	var every = curry$3(async (fn, doc) => {
-	  const results = await map$1(fn, doc);
-	  return (await Promise.all(results))
-	    .every((a) => a);
-	});
-
-	const curry$2 = justCurryIt;
-
-
-	var pipeline$1 = curry$2((fns, doc) => {
-	  return fns.reduce(async (acc, fn) => fn(await acc), doc);
-	});
+	const contentTypeParser = contentType;
 
-	var all = (doc) => Promise.all(doc);
 
-	const pipeline = pipeline$1;
-	const entries$1 = entries$2;
-	const reduce = reduce$2;
+	const mediaTypePlugins = {};
 
+	const addPlugin = (contentType, plugin) => {
+	  mediaTypePlugins[contentType] = plugin;
+	};
 
-	var allValues = (doc) => {
-	  return pipeline([
-	    entries$1,
-	    reduce(async (acc, [propertyName, propertyValue]) => {
-	      acc[propertyName] = await propertyValue;
-	      return acc;
-	    }, {})
-	  ], doc);
+	const parse = (response) => {
+	  const contentType = contentTypeParser.parse(response.headers.get("content-type")).type;
+	  if (!(contentType in mediaTypePlugins)) {
+	    throw Error(`${response.url} is not a schema. Found a document with media type: ${contentType}`);
+	  }
+	  return mediaTypePlugins[contentType].parse(response);
 	};
 
-	var lib$2 = {
-	  entries: entries$2,
-	  map: map$3,
-	  filter: filter,
-	  reduce: reduce$2,
-	  some: some,
-	  every: every,
-	  pipeline: pipeline$1,
-	  all: all,
-	  allValues: allValues
+	const getContentType = (path) => {
+	  for (const contentType in mediaTypePlugins) {
+	    if (mediaTypePlugins[contentType].matcher(path)) {
+	      return contentType;
+	    }
+	  }
+
+	  return "application/octet-stream";
 	};
 
-	var fetch_browser = fetch;
+	var mediaTypes = { addPlugin, parse, getContentType };
 
-	const contentTypeParser = contentType;
 	const curry$1 = justCurryIt;
 	const Pact$a = lib$2;
 	const JsonPointer = lib$3;
 	const { jsonTypeOf, resolveUrl: resolveUrl$1, urlFragment, pathRelative } = common$1;
 	const fetch$1 = fetch_browser;
 	const Reference$1 = reference;
+	const MediaTypes$1 = mediaTypes;
 
 
+	const core201909Id = "https://json-schema.org/draft/2019-09/vocab/core";
+	const core202012Id = "https://json-schema.org/draft/2020-12/vocab/core";
+
 	// Config
 	const config = {};
 	const dialectJsonSchemaVersion = {};
@@ -2416,10 +2448,8 @@ define(['exports'], (function (exports) { 'use strict';
 	};
 
 	const getConfig = (dialectId, key) => {
-	  const jsonSchemaVersion = dialectJsonSchemaVersion[dialectId] || dialectId;
-	  if (jsonSchemaVersion in config) {
-	    return config[jsonSchemaVersion][key];
-	  }
+	  const jsonSchemaVersion = dialectJsonSchemaVersion[dialectId];
+	  return config[jsonSchemaVersion]?.[key];
 	};
 
 	// Schema Management
@@ -2428,6 +2458,7 @@ define(['exports'], (function (exports) { 'use strict';
 
 	const add$1 = (schema, url = "", defaultSchemaVersion = "") => {
 	  schema = JSON.parse(JSON.stringify(schema));
+	  const externalId = resolveUrl$1(url, "");
 
 	  // Dialect / JSON Schema Version
 	  const dialectId = resolveUrl$1(schema["$schema"] || defaultSchemaVersion, "");
@@ -2436,35 +2467,43 @@ define(['exports'], (function (exports) { 'use strict';
 	  }
 	  delete schema["$schema"];
 
-	  let jsonSchemaVersion;
-	  if (schema.$vocabulary?.["https://json-schema.org/draft/2019-09/vocab/core"] === true) {
-	    jsonSchemaVersion = "https://json-schema.org/draft/2019-09/vocab/core";
-	  } else if (schema.$vocabulary?.["https://json-schema.org/draft/2020-12/vocab/core"] === true) {
-	    jsonSchemaVersion = "https://json-schema.org/draft/2020-12/vocab/core";
-	  } else {
-	    jsonSchemaVersion = dialectJsonSchemaVersion[dialectId] || dialectId;
+	  // JSON Schema version
+	  if (!(dialectId in dialectJsonSchemaVersion)) {
+	    if (schema?.$vocabulary?.[core201909Id] === true && dialectId === getSchemaIdentifier(schema, externalId, core201909Id)[0]) {
+	      dialectJsonSchemaVersion[dialectId] = core201909Id;
+	    } else if (schema?.$vocabulary?.[core202012Id] === true && dialectId === getSchemaIdentifier(schema, externalId, core202012Id)[0]) {
+	      dialectJsonSchemaVersion[dialectId] = core202012Id;
+	    } else if (dialectId === getSchemaIdentifier(schema, externalId, dialectId)[0]) {
+	      dialectJsonSchemaVersion[dialectId] = dialectId;
+	    } else if (!(dialectId in schemaStore)) {
+	      throw Error(`Couldn't determine JSON Schema version for dialect: '${dialectId}'`);
+	    } else {
+	      const metaSchema = schemaStore[dialectId];
+	      if (metaSchema.vocabulary[core201909Id] === true) {
+	        dialectJsonSchemaVersion[dialectId] = core201909Id;
+	      } else if (metaSchema.vocabulary[core202012Id] === true) {
+	        dialectJsonSchemaVersion[dialectId] = core202012Id;
+	      } else {
+	        dialectJsonSchemaVersion[dialectId] = dialectJsonSchemaVersion[metaSchema.dialectId];
+	      }
+	    }
 	  }
 
-	  // Identifier
-	  const baseToken = getConfig(jsonSchemaVersion, "baseToken");
-	  const anchorToken = getConfig(jsonSchemaVersion, "anchorToken");
-	  const externalId = resolveUrl$1(url, "");
-	  if (!externalId && !resolveUrl$1(schema[baseToken] || "", "")) {
+	  // Internal Identifier
+	  const [id, fragment] = getSchemaIdentifier(schema, externalId, dialectJsonSchemaVersion[dialectId]);
+	  if (!id) {
 	    throw Error("Couldn't determine an identifier for the schema");
 	  }
-	  const internalUrl = resolveUrl$1(externalId, schema[baseToken] || "");
-	  const id = resolveUrl$1(internalUrl, "");
-	  const fragment = urlFragment(internalUrl);
+	  const baseToken = getConfig(dialectId, "baseToken");
 	  delete schema[baseToken];
-	  if (fragment && baseToken === anchorToken) {
-	    schema[anchorToken] = anchorToken !== baseToken ? encodeURI(fragment) : `#${encodeURI(fragment)}`;
-	  }
 	  if (externalId) {
 	    schemaStoreAlias[externalId] = id;
 	  }
 
-	  // JSON Schema version
-	  dialectJsonSchemaVersion[id] = jsonSchemaVersion;
+	  const anchorToken = getConfig(dialectId, "anchorToken");
+	  if (fragment && baseToken === anchorToken) {
+	    schema[anchorToken] = anchorToken !== baseToken ? encodeURI(fragment) : `#${encodeURI(fragment)}`;
+	  }
 
 	  // recursiveAnchor
 	  const dynamicAnchors = {};
@@ -2500,6 +2539,12 @@ define(['exports'], (function (exports) { 'use strict';
 	  return id;
 	};
 
+	const getSchemaIdentifier = (schema, externalId, jsonSchemaVersion) => {
+	  const baseToken = config[jsonSchemaVersion]?.["baseToken"];
+	  const internalUrl = resolveUrl$1(externalId, schema[baseToken] || "");
+	  return [resolveUrl$1(internalUrl, ""), urlFragment(internalUrl)];
+	};
+
 	const processSchema = (subject, id, dialectId, pointer, anchors, dynamicAnchors) => {
 	  if (jsonTypeOf(subject, "object")) {
 	    const embeddedSchemaDialectId = typeof subject.$schema === "string" ? resolveUrl$1(subject.$schema, "") : dialectId;
@@ -2577,14 +2622,7 @@ define(['exports'], (function (exports) { 'use strict';
 	      throw Error(`Failed to retrieve schema with id: ${id}`);
 	    }
 
-	    if (response.headers.has("content-type")) {
-	      const contentType = contentTypeParser.parse(response.headers.get("content-type")).type;
-	      if (contentType !== "application/schema+json") {
-	        throw Error(`${id} is not a schema. Found a document with media type: ${contentType}`);
-	      }
-	    }
-
-	    add$1(await response.json(), id);
+	    add$1(await MediaTypes$1.parse(response), id);
 	  }
 
 	  const storedSchema = getStoredSchema(id);
@@ -2727,6 +2765,7 @@ define(['exports'], (function (exports) { 'use strict';
 	const Instance$E = instance;
 	const Schema$R = schema$5;
 	const InvalidSchemaError$2 = invalidSchemaError;
+	const MediaTypes = mediaTypes;
 
 
 	const FLAG = "FLAG", BASIC = "BASIC", DETAILED = "DETAILED", VERBOSE = "VERBOSE";
@@ -2734,6 +2773,11 @@ define(['exports'], (function (exports) { 'use strict';
 	let metaOutputFormat = DETAILED;
 	let shouldMetaValidate = true;
 
+	MediaTypes.addPlugin("application/schema+json", {
+	  parse: async (response) => await response.json(),
+	  matcher: (path) => path.endsWith(".schema.json")
+	});
+
 	const validate$2 = async (schema, value = undefined, outputFormat = undefined) => {
 	  const compiled = await compile$O(schema);
 	  const interpretAst = (value, outputFormat) => interpret$O(compiled, Instance$E.cons(value), outputFormat);
@@ -2913,7 +2957,8 @@ define(['exports'], (function (exports) { 'use strict';
 	  validate: validate$2, compile: compile$O, interpret: interpret$O,
 	  setMetaOutputFormat, setShouldMetaValidate, FLAG, BASIC, DETAILED, VERBOSE,
 	  add, getKeyword, hasKeyword, defineVocabulary,
-	  compileSchema, interpretSchema, collectEvaluatedProperties: collectEvaluatedProperties$e, collectEvaluatedItems: collectEvaluatedItems$f
+	  compileSchema, interpretSchema, collectEvaluatedProperties: collectEvaluatedProperties$e, collectEvaluatedItems: collectEvaluatedItems$f,
+	  addMediaTypePlugin: MediaTypes.addPlugin
 	};
 
 	const Schema$Q = schema$5;
@@ -5627,6 +5672,7 @@ define(['exports'], (function (exports) { 'use strict';
 	  interpret: Core.interpret,
 	  setMetaOutputFormat: Core.setMetaOutputFormat,
 	  setShouldMetaValidate: Core.setShouldMetaValidate,
+	  addMediaTypePlugin: Core.addMediaTypePlugin,
 	  FLAG: Core.FLAG,
 	  BASIC: Core.BASIC,
 	  DETAILED: Core.DETAILED,