@hyperjump/json-schema 1.1.2 → 1.2.1

package/README.md

@@ -11,6 +11,9 @@ A collection of modules for working with JSON Schemas.
   * Schemas can reference other schemas using a different dialect
   * Work directly with schemas on the filesystem or HTTP
 * Create custom keywords, vocabularies, and dialects
+* Bundle multiple schemas into one document
+  * Uses the process defined in the 2020-12 specification but works with any
+    dialect.
 * Provides utilities for building non-validation JSON Schema tooling
 
 ## Install
@@ -41,7 +44,12 @@ The API for this library is divided into two categories: Stable and
 Experimental. The Stable API strictly follows semantic versioning, but the
 Experimental API may have backward-incompatible changes between minor versions.
 
-## Usage
+All experimental features are segregated into exports that include the word
+"experimental" so you never accidentally depend on something that could change
+or be removed in future releases.
+
+## Validation
+### Usage
 This library supports many versions of JSON Schema. Use the pattern
 `@hyperjump/json-schema/*` to import the version you need.
 
@@ -130,7 +138,7 @@ const isString = await validate(`file://${__dirname}/string.schema.yaml`);
 const output = isString("foo");
 ```
 
-**Open API**
+**OpenAPI**
 
 The OpenAPI 3.0 and 3.1 meta-schemas are pre-loaded and the OpenAPI JSON Schema
 dialects for each of those versions is supported. A document with a Content-Type
@@ -155,7 +163,7 @@ const output = await validate("https://spec.openapis.org/oas/3.1/schema-base", o
 const output = await validate(`file://${__dirname}/example.openapi.json#/components/schemas/foo`, 42);
 ```
 
-## API
+### API
 These are available from any of the exports that refer to a version of JSON
 Schema, such as `@hyperjump/json-schema/draft-2020-12`.
 
@@ -178,12 +186,12 @@ Schema, such as `@hyperjump/json-schema/draft-2020-12`.
 
     This error is thrown if the schema being compiled is found to be invalid.
     The `output` field contains an `OutputUnit` with information about the
-    error. You can use the `setMetaOutputFormat` configuration to set the output
-    format that is returned in `output`.
-* **setMetaOutputFormat**: (outputFormat: OutputFormat) => void
+    error. You can use the `setMetaSchemaOutputFormat` configuration to set the
+    output format that is returned in `output`.
+* **setMetaSchemaOutputFormat**: (outputFormat: OutputFormat) => void
 
     Set the output format used for validating schemas.
-* **getMetaOutputFormat**: () => OutputFormat
+* **getMetaSchemaOutputFormat**: () => OutputFormat
 
     Get the output format used for validating schemas.
 * **setShouldMetaValidate**: (isEnabled: boolean) => void
@@ -221,28 +229,92 @@ The following types are used in the above definitions
       Given a filesystem path, return whether or not the file should be
       considered a member of this media type.
 
-## Experimental
-The JSON Schema specification includes several features that are experimental in
-nature including the Vocabulary System, Output Formats, and Annotations. This
-implementation aims to support only the latest version of experimental features
-as they evolve. There will not be a major version bump if there needs to be
-backward incompatible changes to the Experimental API.
-
+## Bundling
 ### Usage
-All experimental features are segregated into exports that include the word
-"experimental" so you never accidentally depend on something that could change
-or be removed in future releases.
+You can bundle schemas with external references into single deliverable using
+the official JSON Schema bundling process introduced in the 2020-12
+specification. Given a schema with external references, any external schemas
+will be embedded in the schema resulting in a Compound Schema Document with all
+the schemas necessary to evaluate the given schema in one document.
+
+The bundling process allows schemas to be embedded without needing to modify any
+references which means you get the same output details whether you validate the
+bundle or the original unbundled schemas.
 
 ```javascript
-import { BASIC } from "@hyperjump/json-schema/experimental";
+import { addSchema } from "@hyperjump/json-schema/draft-2020-12";
+import { bundle } from "@hyperjump/json-schema/bundle";
+
+addSchema({
+  "$id": "https://example.com/main"
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+
+  "type": "object",
+  "properties": {
+    "foo": { "$ref": "/string" }
+  }
+});
+
+addSchema({
+  "$id": "https://example.com/string",
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+
+  "type": "string"
+});
+
+const bundledSchema = await bundle("https://example.com/main"); // {
+//   "$id": "https://example.com/main",
+//   "$schema": "https://json-schema.org/draft/2020-12/schema",
+//
+//   "type": "object",
+//   "properties": {
+//     "foo": { "$ref": "/string" }
+//   },
+//
+//   "$defs": {
+//     "https://example.com/main": {
+//       "$id": "https://example.com/main",
+//       "type": "string"
+//     }
+//   }
+// }
 ```
 
+### API
+These are available from the `@hyperjump/json-schema/bundle` export.
+
+* **bundle**: (uri: string, options: Options) => Promise<SchemaObject>
+
+    Create a bundled schema starting with the given schema. External schemas
+    will be fetched from the filesystem, the network, or internally as needed.
+
+    Options:
+     * alwaysIncludeDialect: boolean (default: false) -- Include dialect even
+       when it isn't strictly needed
+     * bundleMode: "flat" | "full" (default: "flat") -- When bundling schemas
+       that already contain bundled schemas, "flat" mode with remove nested
+       embedded schemas and put them all in the top level `$defs`. When using
+       "full" mode, it will keep the already embedded schemas around, which will
+       result in some embedded schema duplication.
+     * definitionNamingStrategy: "uri" | "uuid" (default: "uri") -- By default
+       the name used in definitions for embedded schemas will match the
+       identifier of the embedded schema. This naming is unlikely to collide
+       with actual definitions, but if you want to be sure, you can use the
+       "uuid" strategy instead to be sure you get a unique name.
+     * externalSchemas: string[] (default: []) -- A list of schemas URIs that
+       are available externally and should not be included in the bundle.
+
+## Output Formats (Experimental)
+### Usage
+
 **Change the validation output format**
 
 The `FLAG` output format isn't very informative. You can change the output
-format used for validation to get more information.
+format used for validation to get more information about failures.
 
 ```javascript
+import { BASIC } from "@hyperjump/json-schema/experimental";
+
 const output = await validate("https://example.com/schema1", 42, BASIC);
 ```
 
@@ -251,7 +323,10 @@ const output = await validate("https://example.com/schema1", 42, BASIC);
 The output format used for validating schemas can be changed as well.
 
 ```javascript
-setMetaOutputFormat(BASIC);
+import { validate, setMetaSchemaOutputFormat } from "@hyperjump/json-schema/draft-2020-12";
+import { BASIC } from "@hyperjump/json-schema/experimental";
+
+setMetaSchemaOutputFormat(BASIC);
 try {
   const output = await validate("https://example.com/invalid-schema");
 } catch (error) {
@@ -259,8 +334,20 @@ try {
 }
 ```
 
-**Keywords, Vocabularies, and Dialects**
+### API
+**Type Definitions**
+
+* **OutputFormat**: **FLAG** | **BASIC** | **DETAILED** | **VERBOSE**
+
+    In addition to the `FLAG` output format in the Stable API, the Experimental
+    API includes support for the `BASIC`, `DETAILED`, and `VERBOSE` formats as
+    specified in the 2019-09 specification (with some minor customizations).
+    This implementation doesn't include annotations or human readable error
+    messages. The output can be processed to create human readable error
+    messages as needed.
 
+## Meta-Schemas, Keywords, Vocabularies, and Dialects (Experimental)
+### Usage
 In order to create and use a custom keyword, you need to define your keyword's
 behavior, create a vocabulary that includes that keyword, and then create a
 dialect that includes your vocabulary.
@@ -384,14 +471,6 @@ const output = await validate("https://example.com/schema1", 42); // Expect Inva
 ### API
 These are available from the `@hyperjump/json-schema/experimental` export.
 
-* **compile**: (schema: SchemaDocument) => Promise<CompiledSchema>
-
-    Return a compiled schema. This is useful if you're creating tooling for
-    something other than validation.
-* **interpret**: (schema: CompiledSchema, instance: Instance, outputFormat: OutputFormat = BASIC) => OutputUnit
-
-    A curried function for validating an instance against a compiled schema.
-    This can be useful for creating custom output formats.
 * **addKeyword**: (keywordHandler: Keyword) => void
 
     Define a keyword for use in a vocabulary.
@@ -419,18 +498,6 @@ These are available from the `@hyperjump/json-schema/experimental` export.
     A Keyword object that represents a "validate" operation. You would use this
     for compiling and evaluating sub-schemas when defining a custom keyword.
 
-**Type Definitions**
-
-The following types are used in the above definitions
-
-* **OutputFormat**: **FLAG** | **BASIC** | **DETAILED** | **VERBOSE**
-
-    In addition to the `FLAG` output format in the Stable API, the Experimental
-    API includes support for the `BASIC`, `DETAILED`, and `VERBOSE` formats as
-    specified in the 2019-09 specification (with some minor customizations).
-    This implementation doesn't include annotations or human readable error
-    messages. The output can be processed to create human readable error
-    messages as needed.
 * **Keyword**: object
     * id: string
 
@@ -459,7 +526,7 @@ The following types are used in the above definitions
         If the keyword is an applicator, it will need to implements this
         function for `unevaluatedItems` to work as expected.
 
-### Schema
+### Schema API
 These functions are available from the
 `@hyperjump/json-schema/schema/experimental` export.
 
@@ -518,7 +585,7 @@ The following types are used in the above definitions
     * includeEmbedded: boolean (default: true) -- If false, embedded schemas
       will be unbundled from the schema.
 
-### Instance
+### Instance API
 These functions are available from the
 `@hyperjump/json-schema/instance/experimental` export.
 
@@ -569,6 +636,19 @@ set of functions for working with InstanceDocuments.
 
     Similar to `Array.prototype.length`.
 
+## Low-level Utilities (Experimental)
+### API
+These are available from the `@hyperjump/json-schema/experimental` export.
+
+* **compile**: (schema: SchemaDocument) => Promise<CompiledSchema>
+
+    Return a compiled schema. This is useful if you're creating tooling for
+    something other than validation.
+* **interpret**: (schema: CompiledSchema, instance: Instance, outputFormat: OutputFormat = BASIC) => OutputUnit
+
+    A curried function for validating an instance against a compiled schema.
+    This can be useful for creating custom output formats.
+
 ## Contributing
 
 ### Tests

package/bundle/index.d.ts

@@ -0,0 +1,18 @@
+import type { SchemaObject } from "../lib/schema.js";
+
+
+export const bundle: <A = SchemaObject>(uri: string, options?: BundleOptions) => Promise<A>;
+export const FULL: "full";
+export const FLAT: "flat";
+export const URI: "uri";
+export const UUID: "uuid";
+
+export type BundleOptions = {
+  alwaysIncludeDialect?: boolean;
+  bundleMode?: BundleMode;
+  definitionNamingStrategy?: DefinitionNamingStrategy;
+  externalSchemas?: string[];
+};
+
+export type BundleMode = "full" | "flat";
+export type DefinitionNamingStrategy = "uri" | "uuid";

package/bundle/index.js

@@ -0,0 +1,269 @@
+import { v4 as uuid } from "uuid";
+import * as JsonPointer from "@hyperjump/json-pointer";
+import { toAbsoluteUri } from "../lib/common.js";
+import { compile } from "../lib/core.js";
+import { getKeywordName, getKeyword } from "../lib/keywords.js";
+import Validation from "../lib/keywords/validation.js";
+import * as Schema from "../lib/schema.js";
+
+
+export const FULL = "full", FLAT = "flat";
+export const URI = "uri", UUID = "uuid";
+
+const defaultOptions = {
+  alwaysIncludeDialect: false,
+  bundleMode: FLAT,
+  definitionNamingStrategy: URI,
+  externalSchemas: []
+};
+
+export const bundle = async (url, options = {}) => {
+  loadKeywordSupport();
+  const fullOptions = { ...defaultOptions, ...options };
+
+  const schemaDoc = await Schema.get(url);
+  const externalIds = await collectExternalIds(url, fullOptions);
+
+  const bundled = Schema.toSchema(schemaDoc, {
+    includeEmbedded: fullOptions.bundleMode === FULL
+  });
+
+  const bundlingLocation = "/" + getKeywordName(schemaDoc.dialectId, "https://json-schema.org/keyword/definitions");
+  if (JsonPointer.get(bundlingLocation, bundled) === undefined && externalIds.size > 0) {
+    JsonPointer.assign(bundlingLocation, bundled, {});
+  }
+
+  for (const uri of externalIds.values()) {
+    const externalSchema = await Schema.get(uri);
+    const embeddedSchema = Schema.toSchema(externalSchema, {
+      parentId: schemaDoc.id,
+      parentDialect: fullOptions.alwaysIncludeDialect ? "" : schemaDoc.dialectId,
+      includeEmbedded: fullOptions.bundleMode === FULL
+    });
+    let id;
+    if (fullOptions.definitionNamingStrategy === URI) {
+      const idToken = getKeywordName(externalSchema.dialectId, "https://json-schema.org/keyword/id")
+        || getKeywordName(externalSchema.dialectId, "https://json-schema.org/keyword/draft-04/id");
+      id = embeddedSchema[idToken];
+    } else if (fullOptions.definitionNamingStrategy === UUID) {
+      id = uuid();
+    } else {
+      throw Error(`Unknown definition naming stragety: ${fullOptions.definitionNamingStrategy}`);
+    }
+    const pointer = JsonPointer.append(id, bundlingLocation);
+    JsonPointer.assign(pointer, bundled, embeddedSchema);
+  }
+
+  return bundled;
+};
+
+const collectExternalIds = async (uri, options) => {
+  const { ast, schemaUri } = await compile(uri);
+  const subSchemaUris = new Set();
+  Validation.collectExternalIds(schemaUri, subSchemaUris, ast, {});
+  const externalIds = new Set([...subSchemaUris]
+    .map(toAbsoluteUri)
+    .filter((uri) => !options.externalSchemas.includes(uri)));
+  externalIds.delete(toAbsoluteUri(schemaUri));
+
+  return externalIds;
+};
+
+Validation.collectExternalIds = (schemaUri, externalIds, ast, dynamicAnchors) => {
+  const nodes = ast[schemaUri][2];
+  if (externalIds.has(schemaUri) || typeof nodes === "boolean") {
+    return;
+  }
+  externalIds.add(schemaUri);
+
+  const id = toAbsoluteUri(schemaUri);
+  for (const [keywordId, , keywordValue] of nodes) {
+    const keyword = getKeyword(keywordId);
+
+    if (keyword.collectExternalIds) {
+      keyword.collectExternalIds(keywordValue, externalIds, ast, {
+        ...ast.metaData[id].dynamicAnchors, ...dynamicAnchors
+      });
+    }
+  }
+};
+
+const loadKeywordSupport = () => {
+  // Stable
+
+  const additionalProperties = getKeyword("https://json-schema.org/keyword/additionalProperties");
+  if (additionalProperties) {
+    additionalProperties.collectExternalIds = ([, , additionalProperties], externalIds, ast, dynamicAnchors) => {
+      if (typeof additionalProperties === "string") {
+        Validation.collectExternalIds(additionalProperties, externalIds, ast, dynamicAnchors);
+      }
+    };
+  }
+
+  const allOf = getKeyword("https://json-schema.org/keyword/allOf");
+  if (allOf) {
+    allOf.collectExternalIds = (allOf, externalIds, ast, dynamicAnchors) => {
+      allOf.forEach((schemaUri) => Validation.collectExternalIds(schemaUri, externalIds, ast, dynamicAnchors));
+    };
+  }
+
+  const anyOf = getKeyword("https://json-schema.org/keyword/anyOf");
+  if (anyOf) {
+    anyOf.collectExternalIds = (anyOf, externalIds, ast, dynamicAnchors) => {
+      anyOf.forEach((schemaUri) => Validation.collectExternalIds(schemaUri, externalIds, ast, dynamicAnchors));
+    };
+  }
+
+  const contains = getKeyword("https://json-schema.org/keyword/contains");
+  if (contains) {
+    contains.collectExternalIds = ({ contains }, externalIds, ast, dynamicAnchors) => {
+      Validation.collectExternalIds(contains, externalIds, ast, dynamicAnchors);
+    };
+  }
+
+  const dependentSchemas = getKeyword("https://json-schema.org/keyword/dependentSchemas");
+  if (dependentSchemas) {
+    dependentSchemas.collectExternalIds = (dependentSchemas, externalIds, ast, dynamicAnchors) => {
+      Object.values(dependentSchemas).forEach(([, schemaUri]) => Validation.collectExternalIds(schemaUri, externalIds, ast, dynamicAnchors));
+    };
+  }
+
+  const if_ = getKeyword("https://json-schema.org/keyword/if");
+  if (if_) {
+    if_.collectExternalIds = Validation.collectExternalIds;
+  }
+
+  const then = getKeyword("https://json-schema.org/keyword/then");
+  if (then) {
+    then.collectExternalIds = ([, then], externalIds, ast, dynamicAnchors) => {
+      Validation.collectExternalIds(then, externalIds, ast, dynamicAnchors);
+    };
+  }
+
+  const else_ = getKeyword("https://json-schema.org/keyword/else");
+  if (else_) {
+    else_.collectExternalIds = ([, elseSchema], externalIds, ast, dynamicAnchors) => {
+      Validation.collectExternalIds(elseSchema, externalIds, ast, dynamicAnchors);
+    };
+  }
+
+  const items = getKeyword("https://json-schema.org/keyword/items");
+  if (items) {
+    items.collectExternalIds = ([, items], externalIds, ast, dynamicAnchors) => {
+      Validation.collectExternalIds(items, externalIds, ast, dynamicAnchors);
+    };
+  }
+
+  const not = getKeyword("https://json-schema.org/keyword/not");
+  if (not) {
+    not.collectExternalIds = Validation.collectExternalIds;
+  }
+
+  const oneOf = getKeyword("https://json-schema.org/keyword/oneOf");
+  if (oneOf) {
+    oneOf.collectExternalIds = (oneOf, externalIds, ast, dynamicAnchors) => {
+      oneOf.forEach((schemaUri) => Validation.collectExternalIds(schemaUri, externalIds, ast, dynamicAnchors));
+    };
+  }
+
+  const patternProperties = getKeyword("https://json-schema.org/keyword/patternProperties");
+  if (patternProperties) {
+    patternProperties.collectExternalIds = (patternProperties, externalIds, ast, dynamicAnchors) => {
+      patternProperties.forEach(([, schemaUri]) => Validation.collectExternalIds(schemaUri, externalIds, ast, dynamicAnchors));
+    };
+  }
+
+  const prefixItems = getKeyword("https://json-schema.org/keyword/prefixItems");
+  if (prefixItems) {
+    prefixItems.collectExternalIds = (tupleItems, externalIds, ast, dynamicAnchors) => {
+      tupleItems.forEach((schemaUri) => Validation.collectExternalIds(schemaUri, externalIds, ast, dynamicAnchors));
+    };
+  }
+
+  const properties = getKeyword("https://json-schema.org/keyword/properties");
+  if (properties) {
+    properties.collectExternalIds = (properties, externalIds, ast, dynamicAnchors) => {
+      Object.values(properties).forEach((schemaUri) => Validation.collectExternalIds(schemaUri, externalIds, ast, dynamicAnchors));
+    };
+  }
+
+  const propertyNames = getKeyword("https://json-schema.org/keyword/propertyNames");
+  if (propertyNames) {
+    propertyNames.collectExternalIds = Validation.collectExternalIds;
+  }
+
+  const ref = getKeyword("https://json-schema.org/keyword/ref");
+  if (ref) {
+    ref.collectExternalIds = Validation.collectExternalIds;
+  }
+
+  const unevaluatedItems = getKeyword("https://json-schema.org/keyword/unevaluatedItems");
+  if (unevaluatedItems) {
+    unevaluatedItems.collectExternalIds = ([, unevaluatedItems], externalIds, ast, dynamicAnchors) => {
+      Validation.collectExternalIds(unevaluatedItems, externalIds, ast, dynamicAnchors);
+    };
+  }
+
+  const unevaluatedProperties = getKeyword("https://json-schema.org/keyword/unevaluatedProperties");
+  if (unevaluatedProperties) {
+    unevaluatedProperties.collectExternalIds = ([, unevaluatedProperties], externalIds, ast, dynamicAnchors) => {
+      Validation.collectExternalIds(unevaluatedProperties, externalIds, ast, dynamicAnchors);
+    };
+  }
+
+  // Draft-04
+
+  const additionalItems4 = getKeyword("https://json-schema.org/keyword/draft-04/additionalItems");
+  if (additionalItems4) {
+    additionalItems4.collectExternalIds = ([, additionalItems], externalIds, ast, dynamicAnchors) => {
+      if (typeof additionalItems === "string") {
+        Validation.collectExternalIds(additionalItems, externalIds, ast, dynamicAnchors);
+      }
+    };
+  }
+
+  const dependencies = getKeyword("https://json-schema.org/keyword/draft-04/dependencies");
+  if (dependencies) {
+    dependencies.collectExternalIds = (dependentSchemas, externalIds, ast, dynamicAnchors) => {
+      Object.values(dependentSchemas).forEach(([, dependency]) => {
+        if (typeof dependency === "string") {
+          Validation.collectExternalIds(dependency, externalIds, ast, dynamicAnchors);
+        }
+      });
+    };
+  }
+
+  const items4 = getKeyword("https://json-schema.org/keyword/draft-04/items");
+  if (items4) {
+    items4.collectExternalIds = (items, externalIds, ast, dynamicAnchors) => {
+      if (typeof items === "string") {
+        Validation.collectExternalIds(items, externalIds, ast, dynamicAnchors);
+      } else {
+        items.forEach((schemaUri) => Validation.collectExternalIds(schemaUri, externalIds, ast, dynamicAnchors));
+      }
+    };
+  }
+
+  const ref4 = getKeyword("https://json-schema.org/keyword/draft-04/ref");
+  if (ref4) {
+    ref4.collectExternalIds = Validation.collectExternalIds;
+  }
+
+  // Draft-06
+
+  const contains6 = getKeyword("https://json-schema.org/keyword/draft-06/contains");
+  if (contains6) {
+    contains6.collectExternalIds = (contains, externalIds, ast, dynamicAnchors) => {
+      Validation.collectExternalIds(contains, externalIds, ast, dynamicAnchors);
+    };
+  }
+
+  // Draft-2019-09
+
+  const contains19 = getKeyword("https://json-schema.org/keyword/draft-2019-09/contains");
+  if (contains19) {
+    contains19.collectExternalIds = ({ contains }, externalIds, ast, dynamicAnchors) => {
+      Validation.collectExternalIds(contains, externalIds, ast, dynamicAnchors);
+    };
+  }
+};

package/lib/common.d.ts

@@ -1,5 +1,7 @@
 export type JsonType = "object" | "array" | "string" | "number" | "boolean" | "null";
 export type JsonSchemaType = JsonType | "integer";
 
-type PathRelative = (from: string, to: string) => string;
-export const pathRelative: PathRelative;
+export const pathRelative: (from: string, to: string) => string;
+
+export type Replacer = (key: string, value: unknown) => unknown;
+export const jsonStringify: (value: unknown, replacer?: Replacer, space?: string) => string;

package/lib/common.js

@@ -1,4 +1,5 @@
 import { resolveIri, toAbsoluteIri, parseIriReference } from "@hyperjump/uri";
+import * as JsonPointer from "@hyperjump/json-pointer";
 
 
 const isObject = (value) => typeof value === "object" && !Array.isArray(value) && value !== null;
@@ -86,3 +87,65 @@ export const pathRelative = (from, to) => {
 
   return to.slice(toStart, to.length);
 };
+
+const defaultReplacer = (key, value) => value;
+export const jsonStringify = (value, replacer = defaultReplacer, space = "") => {
+  return stringifyValue(value, replacer, space, "", JsonPointer.nil, 1);
+};
+
+const stringifyValue = (value, replacer, space, key, pointer, depth) => {
+  value = replacer(key, value, pointer);
+  let result;
+  if (Array.isArray(value)) {
+    result = stringifyArray(value, replacer, space, pointer, depth);
+  } else if (typeof value === "object" && value !== null) {
+    result = stringifyObject(value, replacer, space, pointer, depth);
+  } else {
+    result = JSON.stringify(value);
+  }
+
+  return result;
+};
+
+const stringifyArray = (value, replacer, space, pointer, depth) => {
+  if (value.length === 0) {
+    return "[]";
+  }
+
+  const padding = space ? `\n${space.repeat(depth - 1)}` : "";
+
+  let result = "[" + padding + space;
+  for (let index = 0; index < value.length; index++) {
+    const indexPointer = JsonPointer.append(index, pointer);
+    const stringifiedValue = stringifyValue(value[index], replacer, space, String(index), indexPointer, depth + 1);
+    result += stringifiedValue === undefined ? "null" : stringifiedValue;
+    if (index + 1 < value.length) {
+      result += `,${padding}${space}`;
+    }
+  }
+  return result + padding + "]";
+};
+
+const stringifyObject = (value, replacer, space, pointer, depth) => {
+  const entries = Object.entries(value);
+  if (entries.length === 0) {
+    return "{}";
+  }
+
+  const padding = space ? `\n${space.repeat(depth - 1)}` : "";
+  const colonSpacing = space ? " " : "";
+
+  let result = "{" + padding + space;
+  for (let index = 0; index < entries.length; index++) {
+    const [key, value] = entries[index];
+    const keyPointer = JsonPointer.append(key, pointer);
+    const stringifiedValue = stringifyValue(value, replacer, space, key, keyPointer, depth + 1);
+    if (stringifiedValue !== undefined) {
+      result += JSON.stringify(key) + ":" + colonSpacing + stringifiedValue;
+      if (entries[index + 1]) {
+        result += `,${padding}${space}`;
+      }
+    }
+  }
+  return result + padding + "}";
+};

package/lib/instance.js

@@ -1,4 +1,4 @@
-import * as JsonPointer from "@hyperjump/json-pointer";
+import { append as pointerAppend } from "@hyperjump/json-pointer";
 import curry from "just-curry-it";
 import { toAbsoluteUri, jsonTypeOf } from "./common.js";
 import * as Reference from "./reference.js";
@@ -27,7 +27,7 @@ export const typeOf = curry((doc, type) => jsonTypeOf(value(doc), type));
 
 export const step = (key, doc) => ({
   ...doc,
-  pointer: JsonPointer.append(key, doc.pointer),
+  pointer: pointerAppend(key, doc.pointer),
   value: value(doc)[key]
 });
 

package/lib/media-types.js

@@ -7,7 +7,7 @@ export const addMediaTypePlugin = (contentType, plugin) => {
   mediaTypePlugins[contentType] = plugin;
 };
 
-export const parse = (response) => {
+export const parseResponse = (response) => {
   const contentType = contentTypeParser.parse(response.headers.get("content-type"));
   if (!(contentType.type in mediaTypePlugins)) {
     throw Error(`${response.url} is not a schema. Found a document with media type: ${contentType.type}`);

package/lib/schema.js

@@ -1,11 +1,10 @@
 import curry from "just-curry-it";
 import * as Pact from "@hyperjump/pact";
-import * as Json from "@hyperjump/json";
-import * as JsonPointer from "@hyperjump/json-pointer";
-import { jsonTypeOf, resolveUri, toAbsoluteUri, uriFragment, pathRelative } from "./common.js";
+import { nil as nilPointer, append as pointerAppend, get as pointerGet } from "@hyperjump/json-pointer";
+import { jsonTypeOf, resolveUri, toAbsoluteUri, uriFragment, pathRelative, jsonStringify } from "./common.js";
 import fetch from "./fetch.js";
-import * as Keywords from "./keywords.js";
-import * as MediaTypes from "./media-types.js";
+import { hasDialect, loadDialect, getKeywordName } from "./keywords.js";
+import { parseResponse } from "./media-types.js";
 import * as Reference from "./reference.js";
 
 
@@ -22,13 +21,13 @@ export const add = (schema, retrievalUri = undefined, contextDialectId = undefin
   const dialectId = toAbsoluteUri(schema.$schema || contextDialectId || defaultDialectId);
   delete schema.$schema;
 
-  if (!Keywords.hasDialect(dialectId)) {
+  if (!hasDialect(dialectId)) {
     throw Error(`Encountered unknown dialect '${dialectId}'`);
   }
 
   // Identifiers
-  const idToken = Keywords.getKeywordName(dialectId, "https://json-schema.org/keyword/id")
-    || Keywords.getKeywordName(dialectId, "https://json-schema.org/keyword/draft-04/id");
+  const idToken = getKeywordName(dialectId, "https://json-schema.org/keyword/id")
+    || getKeywordName(dialectId, "https://json-schema.org/keyword/draft-04/id");
   if (retrievalUri === undefined && !(idToken in schema)) {
     throw Error(`Unable to determine an identifier for the schema. Use the '${idToken}' keyword or pass a retrievalUri when loading the schema.`);
   }
@@ -41,19 +40,19 @@ export const add = (schema, retrievalUri = undefined, contextDialectId = undefin
   }
 
   // Vocabulary
-  const vocabularyToken = Keywords.getKeywordName(dialectId, "https://json-schema.org/keyword/vocabulary");
+  const vocabularyToken = getKeywordName(dialectId, "https://json-schema.org/keyword/vocabulary");
   if (jsonTypeOf(schema[vocabularyToken], "object")) {
     const allowUnknownKeywords = schema[vocabularyToken]["https://json-schema.org/draft/2019-09/vocab/core"]
       || schema[vocabularyToken]["https://json-schema.org/draft/2020-12/vocab/core"];
 
-    Keywords.loadDialect(id, schema[vocabularyToken], allowUnknownKeywords);
+    loadDialect(id, schema[vocabularyToken], allowUnknownKeywords);
     delete schema[vocabularyToken];
   }
 
   const dynamicAnchors = {};
 
   // Recursive anchor
-  const recursiveAnchorToken = Keywords.getKeywordName(dialectId, "https://json-schema.org/keyword/draft-2019-09/recursiveAnchor");
+  const recursiveAnchorToken = getKeywordName(dialectId, "https://json-schema.org/keyword/draft-2019-09/recursiveAnchor");
   if (schema[recursiveAnchorToken] === true) {
     dynamicAnchors[""] = `${id}#`;
   }
@@ -64,7 +63,7 @@ export const add = (schema, retrievalUri = undefined, contextDialectId = undefin
   schemaStore[id] = {
     id: id,
     dialectId: dialectId,
-    schema: processSchema(schema, id, dialectId, JsonPointer.nil, anchors, dynamicAnchors),
+    schema: processSchema(schema, id, dialectId, nilPointer, anchors, dynamicAnchors),
     anchors: anchors,
     dynamicAnchors: dynamicAnchors,
     validated: false
@@ -76,7 +75,7 @@ export const add = (schema, retrievalUri = undefined, contextDialectId = undefin
 const processSchema = (subject, id, dialectId, pointer, anchors, dynamicAnchors) => {
   if (jsonTypeOf(subject, "object")) {
     // Legacy id
-    const legacyIdToken = Keywords.getKeywordName(dialectId, "https://json-schema.org/keyword/draft-04/id");
+    const legacyIdToken = getKeywordName(dialectId, "https://json-schema.org/keyword/draft-04/id");
     if (typeof subject[legacyIdToken] === "string") {
       if (subject[legacyIdToken][0] === "#") {
         const anchor = decodeURIComponent(subject[legacyIdToken].slice(1));
@@ -92,7 +91,7 @@ const processSchema = (subject, id, dialectId, pointer, anchors, dynamicAnchors)
 
     // Embedded Schema
     const embeddedDialectId = typeof subject.$schema === "string" ? toAbsoluteUri(subject.$schema) : dialectId;
-    const idToken = Keywords.getKeywordName(embeddedDialectId, "https://json-schema.org/keyword/id");
+    const idToken = getKeywordName(embeddedDialectId, "https://json-schema.org/keyword/id");
     if (typeof subject[idToken] === "string") {
       subject[idToken] = resolveUri(subject[idToken], id);
       add(subject, undefined, dialectId);
@@ -100,37 +99,37 @@ const processSchema = (subject, id, dialectId, pointer, anchors, dynamicAnchors)
     }
 
     // Legacy dynamic anchor
-    const legacyDynamicAnchorToken = Keywords.getKeywordName(dialectId, "https://json-schema.org/keyword/draft-2020-12/dynamicAnchor");
+    const legacyDynamicAnchorToken = getKeywordName(dialectId, "https://json-schema.org/keyword/draft-2020-12/dynamicAnchor");
     if (typeof subject[legacyDynamicAnchorToken] === "string") {
       dynamicAnchors[subject[legacyDynamicAnchorToken]] = `${id}#${encodeURI(pointer)}`;
       anchors[subject[legacyDynamicAnchorToken]] = pointer;
       delete subject[legacyDynamicAnchorToken];
     }
 
-    const dynamicAnchorToken = Keywords.getKeywordName(dialectId, "https://json-schema.org/keyword/dynamicAnchor");
+    const dynamicAnchorToken = getKeywordName(dialectId, "https://json-schema.org/keyword/dynamicAnchor");
     if (typeof subject[dynamicAnchorToken] === "string") {
       dynamicAnchors[subject[dynamicAnchorToken]] = `${id}#${encodeURI(pointer)}`;
       delete subject[dynamicAnchorToken];
     }
 
-    const anchorToken = Keywords.getKeywordName(dialectId, "https://json-schema.org/keyword/anchor");
+    const anchorToken = getKeywordName(dialectId, "https://json-schema.org/keyword/anchor");
     if (typeof subject[anchorToken] === "string") {
       anchors[subject[anchorToken]] = pointer;
       delete subject[anchorToken];
     }
 
     // Legacy $ref
-    const jrefToken = Keywords.getKeywordName(dialectId, "https://json-schema.org/keyword/draft-04/ref");
+    const jrefToken = getKeywordName(dialectId, "https://json-schema.org/keyword/draft-04/ref");
     if (typeof subject[jrefToken] === "string") {
       return Reference.cons(subject[jrefToken], subject);
     }
 
     for (const key in subject) {
-      subject[key] = processSchema(subject[key], id, dialectId, JsonPointer.append(key, pointer), anchors, dynamicAnchors);
+      subject[key] = processSchema(subject[key], id, dialectId, pointerAppend(key, pointer), anchors, dynamicAnchors);
     }
   } else if (Array.isArray(subject)) {
     for (let index = 0; index < subject.length; index++) {
-      subject[index] = processSchema(subject[index], id, dialectId, JsonPointer.append(index, pointer), anchors, dynamicAnchors);
+      subject[index] = processSchema(subject[index], id, dialectId, pointerAppend(index, pointer), anchors, dynamicAnchors);
     }
   }
 
@@ -148,7 +147,7 @@ export const markValidated = (id) => {
 const nil = {
   id: undefined,
   dialectId: undefined,
-  pointer: JsonPointer.nil,
+  pointer: nilPointer,
   schema: undefined,
   value: undefined,
   anchors: {},
@@ -168,11 +167,11 @@ export const get = async (url, contextDoc = nil) => {
       throw Error(`Failed to retrieve schema with id: ${id}`);
     }
 
-    const [schema, contextDialectId] = await MediaTypes.parse(response);
+    const [schema, contextDialectId] = await parseResponse(response);
 
     // Try to determine the dialect from the meta-schema if it isn't already known
     const dialectId = toAbsoluteUri(schema.$schema || contextDialectId || defaultDialectId);
-    if (!Keywords.hasDialect(dialectId) && !hasStoredSchema(dialectId)) {
+    if (!hasDialect(dialectId) && !hasStoredSchema(dialectId)) {
       await get(dialectId);
     }
 
@@ -184,7 +183,7 @@ export const get = async (url, contextDoc = nil) => {
   const doc = {
     ...storedSchema,
     pointer: pointer,
-    value: JsonPointer.get(pointer, storedSchema.schema)
+    value: pointerGet(pointer, storedSchema.schema)
   };
 
   return followReferences(doc);
@@ -210,7 +209,7 @@ export const step = (key, doc) => {
   const storedSchema = getStoredSchema(doc.id);
   return followReferences({
     ...doc,
-    pointer: JsonPointer.append(`${key}`, doc.pointer),
+    pointer: pointerAppend(`${key}`, doc.pointer),
     value: value(doc)[key],
     validated: storedSchema.validated
   });
@@ -241,11 +240,12 @@ const toSchemaDefaultOptions = {
 export const toSchema = (schemaDoc, options = {}) => {
   const fullOptions = { ...toSchemaDefaultOptions, ...options };
 
-  const idToken = Keywords.getKeywordName(schemaDoc.dialectId, "https://json-schema.org/keyword/id");
-  const anchorToken = Keywords.getKeywordName(schemaDoc.dialectId, "https://json-schema.org/keyword/anchor");
-  const dynamicAnchorToken = Keywords.getKeywordName(schemaDoc.dialectId, "https://json-schema.org/keyword/dynamicAnchor");
-  const legacyDynamicAnchorToken = Keywords.getKeywordName(schemaDoc.dialectId, "https://json-schema.org/keyword/draft-2020-12/dynamicAnchor");
-  const recursiveAnchorToken = Keywords.getKeywordName(schemaDoc.dialectId, "https://json-schema.org/keyword/recursiveAnchor");
+  const idToken = getKeywordName(schemaDoc.dialectId, "https://json-schema.org/keyword/id")
+    || getKeywordName(schemaDoc.dialectId, "https://json-schema.org/keyword/draft-04/id");
+  const anchorToken = getKeywordName(schemaDoc.dialectId, "https://json-schema.org/keyword/anchor");
+  const dynamicAnchorToken = getKeywordName(schemaDoc.dialectId, "https://json-schema.org/keyword/dynamicAnchor");
+  const legacyDynamicAnchorToken = getKeywordName(schemaDoc.dialectId, "https://json-schema.org/keyword/draft-2020-12/dynamicAnchor");
+  const recursiveAnchorToken = getKeywordName(schemaDoc.dialectId, "https://json-schema.org/keyword/recursiveAnchor");
 
   const anchors = {};
   for (const anchor in schemaDoc.anchors) {
@@ -260,7 +260,7 @@ export const toSchema = (schemaDoc, options = {}) => {
     dynamicAnchors[pointer] = anchor;
   }
 
-  const schema = JSON.parse(Json.stringify(schemaDoc.schema, (key, value, pointer) => {
+  const schema = JSON.parse(jsonStringify(schemaDoc.schema, (key, value, pointer) => {
     if (Reference.isReference(value)) {
       const refValue = Reference.value(value);
       if (fullOptions.includeEmbedded || !(idToken in refValue)) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hyperjump/json-schema",
-  "version": "1.1.2",
+  "version": "1.2.1",
   "description": "A JSON Schema validator with support for custom keywords, vocabularies, and dialects",
   "type": "module",
   "main": "./stable/index.js",
@@ -15,7 +15,8 @@
     "./openapi-3-1": "./openapi-3-1/index.js",
     "./experimental": "./lib/experimental.js",
     "./schema/experimental": "./lib/schema.js",
-    "./instance/experimental": "./lib/instance.js"
+    "./instance/experimental": "./lib/instance.js",
+    "./bundle": "./bundle/index.js"
   },
   "browser": {
     "./lib/fetch.js": "./lib/fetch.browser.js"
@@ -23,7 +24,7 @@
   "scripts": {
     "clean": "xargs -a .gitignore rm -rf",
     "lint": "eslint lib stable draft-* openapi-*",
-    "test": "mocha 'lib/**/*.spec.ts' 'stable/**/*.spec.ts' 'draft-*/**/*.spec.ts' 'openapi-*/**/*.spec.ts'"
+    "test": "mocha 'lib/**/*.spec.ts' 'stable/**/*.spec.ts' 'draft-*/**/*.spec.ts' 'openapi-*/**/*.spec.ts' 'bundle/**/*.spec.ts'"
   },
   "repository": "github:hyperjump-io/json-schema",
   "keywords": [
@@ -61,12 +62,12 @@
     "yaml": "*"
   },
   "dependencies": {
-    "@hyperjump/json": "^0.1.0",
-    "@hyperjump/json-pointer": "^0.9.5",
+    "@hyperjump/json-pointer": "^1.0.0",
     "@hyperjump/pact": "^0.2.4",
     "@hyperjump/uri": "^1.0.0",
     "content-type": "^1.0.4",
     "fastest-stable-stringify": "^2.0.2",
-    "node-fetch": "^3.3.0"
+    "node-fetch": "^3.3.0",
+    "uuid": "^9.0.0"
   }
 }