A MODIFIED VERSION OF json-schema-ref-parser.

The modifications are to address the incompatability of this library with Angular versions > 6. See this issue over in the real repository.

Because I do not need to resolve URLs for my current usages, I'm just removing the HTTP(s) resolver. This "fix" works for me, but SHOULD NOT BE CONSIDERED A REAL FIX!

I'm publishing it locally using Verdaccio so as to not confuse anyone looking for the real version

USAGE

1. Publish this library locally

Clone this repository
Modify package.json to set the library name and version as desired.
Make sure Verdaccio is configured and running. (So you don't publish this to the real NPM.)

Publish this hacky package:

  cd json-schema-ref-parser
  npm publish

2. Configure your Angular app

Inside your angular app:

Install this package using whatever name you published it with.

*Modify index.html by adding the following to the <head> section:

  <script>
    var global = global || window;
  </script>

*Modify polyfills.ts by adding the following:

global.Buffer = global.Buffer || require('buffer').Buffer;

Import it using:

import $RefParser from "json-schema-ref-parser";

Parse your file using something else, such as js-yaml
Use $RefParser.dereference()

3. Example Usage

        const raw = {
            foo: 1,
            bar: 'test',
            deref: {
                $ref: '#/foo'
            }
        };

        const asString = JSON.stringify(raw);
        const parsed = yaml.safeLoad(asString);
        // DO NOT USE THE FOLLOWING:
        //  -- It would trigger the resolvers that were removed.
        // $RefParser.parse(asString, {resolve: {external: true}}, (err, schema) => {
        //     console.log(err, schema);
        //     done();
        // });

        $RefParser.dereference(parsed, (err, schema) => {
            console.log(err, schema);
        });

The above example outputs the following:

null, Object{foo: 1, bar: 'test', deref: 1}

Summary of Changes

All changes are hacky. This fork is designed to work for my purposes with minimal effor. Do not expect this to be a good solution! This is a bad solution.

Changes to make it work in the browser:

It seems like this library was designed to be run on the back-end, not in the browser. I'm not familiar enough with Node to know if these changes are OK or not.

Added process to the package dependencies.
Added const process = require('process') to the files that use it

Changes to make it work with newer versions of Angular:

Removed the imports of http and https from lib/resolvers/http.js
Commented out the code that performs an HTTP GET and replaced it with a hardcoded promise that immediately rejects with an error message indicating the feature was removed for Angular support.
Changed the syntax of the export in index.d.ts to avoid the need for import * as

JSON Schema $Ref Parser

Parse, Resolve, and Dereference JSON Schema $ref pointers

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
Tested in Node and all major web browsers on Windows, Mac, and Linux

Example

$RefParser.dereference(mySchema, (err, schema) => {
  if (err) {
    console.error(err);
  }
  else {
    // `schema` is just a normal JavaScript object that contains your entire JSON Schema,
    // including referenced files, combined into a single object
    console.log(schema.definitions.person.properties.firstName);
  }
}

Or use async/await syntax instead. The following example is the same as above:

try {
  let schema = await $RefParser.dereference(mySchema);
  console.log(schema.definitions.person.properties.firstName);
}
catch(err) {
  console.error(err);
}

For more detailed examples, please see the API Documentation

Installation

Install using npm:

npm install json-schema-ref-parser

Usage

When using Json-Schema-Ref-Parser in Node.js apps, you'll probably want to use CommonJS syntax:

const $RefParser = require("json-schema-ref-parser");

When using a transpiler such as Babel or TypeScript, or a bundler such as Webpack or Rollup, you can use ECMAScript modules syntax instead:

import $RefParser from "json-schema-ref-parser";

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.

API Documentation

Full API documentation is available right here

Contributing

I welcome any contributions, enhancements, and bug-fixes. File 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
npm install
Run the build script
npm run build
Run the tests
npm test

License

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

Big Thanks To

Thanks to these awesome companies for their support of Open Source developers ❤

Bakerburgh/json-schema-ref-parser