@apidevtools/json-schema-ref-parser

What is @apidevtools/json-schema-ref-parser?

The @apidevtools/json-schema-ref-parser package is a powerful tool for working with JSON Schemas. It allows users to parse JSON Schemas, resolve all $ref pointers to their corresponding values, and can bundle multiple files into a single schema. This package is particularly useful for developers working with complex JSON Schemas that include multiple references to other schemas or definitions.

What are @apidevtools/json-schema-ref-parser's main functionalities?

Dereferencing JSON Schemas

This feature allows you to take a JSON Schema that contains $ref pointers and resolve all references, resulting in a fully dereferenced schema. This is useful for understanding and validating the full structure of a schema without having to manually follow references.

{"const parser = require('@apidevtools/json-schema-ref-parser');\n\nlet schema = {\n  $ref: 'http://example.com/my-schema.json'\n};\n\nparser.dereference(schema).then(function(schema) {\n  console.log('Schema:', schema);\n}).catch(function(err) {\n  console.error(err);\n});"}

Bundling JSON Schemas

This feature bundles a JSON Schema and all its references into a single schema file. This is particularly useful for distribution or for loading a schema into tools that do not support $ref pointers.

{"const parser = require('@apidevtools/json-schema-ref-parser');\n\nlet schema = {\n  $ref: 'http://example.com/my-schema.json'\n};\n\nparser.bundle(schema).then(function(schema) {\n  console.log('Bundled schema:', schema);\n}).catch(function(err) {\n  console.error(err);\n});"}

Other packages similar to @apidevtools/json-schema-ref-parser

json-schema-resolver

Similar to @apidevtools/json-schema-ref-parser, this package focuses on resolving $ref pointers within JSON Schemas. However, it might not offer the same level of functionality for bundling schemas into a single file or the same breadth of dereferencing options.

jsonref

jsonref is another package that offers functionality to resolve $ref pointers in JSON objects, including JSON Schemas. It provides a simpler interface but may not have as comprehensive support for complex schemas or the ability to bundle schemas as @apidevtools/json-schema-ref-parser does.

README

JSON Schema $Ref Parser

Parse, Resolve, and Dereference JSON Schema $ref pointers

Installation

Install using npm:

npm install @apidevtools/json-schema-ref-parser
yarn add @apidevtools/json-schema-ref-parser
bun add @apidevtools/json-schema-ref-parser

The Problem:

You've got a JSON Schema with $ref pointers to other files and/or URLs. Maybe you know all the referenced files ahead of time. Maybe you don't. Maybe some are local files, and others are remote URLs. Maybe they are a mix of JSON and YAML format. Maybe some of the files contain cross-references to each other.

{
  "definitions": {
    "person": {
      // references an external file
      "$ref": "schemas/people/Bruce-Wayne.json"
    },
    "place": {
      // references a sub-schema in an external file
      "$ref": "schemas/places.yaml#/definitions/Gotham-City"
    },
    "thing": {
      // references a URL
      "$ref": "http://wayne-enterprises.com/things/batmobile"
    },
    "color": {
      // references a value in an external file via an internal reference
      "$ref": "#/definitions/thing/properties/colors/black-as-the-night"
    }
  }
}

The Solution:

JSON Schema $Ref Parser is a full JSON Reference and JSON Pointer implementation that crawls even the most complex JSON Schemas and gives you simple, straightforward JavaScript objects.

• Use JSON or YAML schemas — or even a mix of both!
• Supports $ref pointers to external files and URLs, as well as custom sources such as databases
• Can bundle multiple files into a single schema that only has internal $ref pointers
• Can dereference your schema, producing a plain-old JavaScript object that's easy to work with
• Supports circular references, nested references, back-references, and cross-references between files
• Maintains object reference equality — $ref pointers to the same value always resolve to the same object instance
• Compatible with Node LTS and beyond, and all major web browsers on Windows, Mac, and Linux

Example

import $RefParser from "@apidevtools/json-schema-ref-parser";

try {
  await $RefParser.dereference(mySchema);
  // note - by default, mySchema is modified in place, and the returned value is a reference to the same object
  console.log(mySchema.definitions.person.properties.firstName);

  // if you want to avoid modifying the original schema, you can disable the `mutateInputSchema` option
  let clonedSchema = await $RefParser.dereference(mySchema, { mutateInputSchema: false });
  console.log(clonedSchema.definitions.person.properties.firstName);
} catch (err) {
  console.error(err);
}

For more detailed examples, please see the API Documentation

Polyfills

If you are using Node.js < 18, you'll need a polyfill for fetch, like node-fetch:

import fetch from "node-fetch";

globalThis.fetch = fetch;

Browser support

JSON Schema $Ref Parser supports recent versions of every major web browser. Older browsers may require Babel and/or polyfills.

To use JSON Schema $Ref Parser in a browser, you'll need to use a bundling tool such as Webpack, Rollup, Parcel, or Browserify. Some bundlers may require a bit of configuration, such as setting browser: true in rollup-plugin-resolve.

Webpack 5

Webpack 5 has dropped the default export of node core modules in favour of polyfills, you'll need to set them up yourself ( after npm-installing them ) Edit your webpack.config.js :

config.resolve.fallback = {
  path: require.resolve("path-browserify"),
  fs: require.resolve("browserify-fs"),
};

config.plugins.push(
  new webpack.ProvidePlugin({
    Buffer: ["buffer", "Buffer"],
  }),
);

API Documentation

Full API documentation is available right here

Contributing

I welcome any contributions, enhancements, and bug-fixes. Open an issue on GitHub and submit a pull request.

Building/Testing

To build/test the project locally on your computer:

• Clone this repo
  git clone https://github.com/APIDevTools/json-schema-ref-parser.git

• Install dependencies
  yarn install

• Run the tests
  yarn test

License

JSON Schema $Ref Parser is 100% free and open-source, under the MIT license. Use it however you want.

Thanks

Thanks to these awesome contributors for their major support of this open-source project.

• JonLuca De Caro
• Phil Sturgeon
• Stoplight