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
- Clone this repository
- Modify
package.jsonto 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
Inside your angular app:
- Install this package using whatever name you published it with.
- *Modify
index.htmlby adding the following to the<head>section:<script> var global = global || window; </script>
- *Modify
polyfills.tsby 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()
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}
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.
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
processto the package dependencies. - Added
const process = require('process')to the files that use it
- Removed the imports of
httpandhttpsfromlib/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.tsto avoid the need forimport * as
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"
}
}
}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
$refpointers 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
$refpointers - 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 —
$refpointers to the same value always resolve to the same object instance - Tested in Node and all major web browsers on Windows, Mac, and Linux
$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
Install using npm:
npm install json-schema-ref-parserWhen 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";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.
Full API documentation is available right here
I welcome any contributions, enhancements, and bug-fixes. File an issue on GitHub and submit a pull request.
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
JSON Schema $Ref Parser is 100% free and open-source, under the MIT license. Use it however you want.
Thanks to these awesome companies for their support of Open Source developers ❤
