@apidevtools/json-schema-ref-parser 10.1.0 → 11.1.0

package/README.md

@@ -124,6 +124,28 @@ JSON Schema $Ref Parser supports recent versions of every major web browser.  Ol
 To use JSON Schema $Ref Parser in a browser, you'll need to use a bundling tool such as [Webpack](https://webpack.js.org/), [Rollup](https://rollupjs.org/), [Parcel](https://parceljs.org/), or [Browserify](http://browserify.org/). Some bundlers may require a bit of configuration, such as setting `browser: true` in [rollup-plugin-resolve](https://github.com/rollup/rollup-plugin-node-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` :
+```js
+  config.resolve.fallback = {
+    "path": require.resolve("path-browserify"),
+    'util': require.resolve('util/'),
+    'fs': require.resolve('browserify-fs'),
+    "buffer": require.resolve("buffer/"),
+    "http": require.resolve("stream-http"),
+    "https": require.resolve("https-browserify"),
+    "url": require.resolve("url"),
+  }
+
+  config.plugins.push(
+    new webpack.ProvidePlugin({
+      Buffer: [ 'buffer', 'Buffer']
+    })
+  )
+
+```
+
 
 API Documentation
 --------------------------

package/dist/lib/bundle.js

@@ -106,6 +106,7 @@ function crawl(parent, key, path, pathFromRoot, indirections, inventory, $refs,
  * @param $refParent - The object that contains a JSON Reference as one of its keys
  * @param $refKey - The key in `$refParent` that is a JSON Reference
  * @param path - The full path of the JSON Reference at `$refKey`, possibly with a JSON Pointer in the hash
+ * @param indirections - unknown
  * @param pathFromRoot - The path of the JSON Reference at `$refKey`, from the schema root
  * @param inventory - An array of already-inventoried $ref pointers
  * @param $refs

package/dist/lib/dereference.js

@@ -130,7 +130,9 @@ function crawl(obj, path, pathFromRoot, parents, processedObjects, dereferencedC
  */
 function dereference$Ref($ref, path, pathFromRoot, parents, processedObjects, dereferencedCache, $refs, options) {
     // console.log('Dereferencing $ref pointer "%s" at %s', $ref.$ref, path);
-    const $refPath = url.resolve(path, $ref.$ref);
+    const isExternalRef = ref_js_1.default.isExternal$Ref($ref);
+    const shouldResolveOnCwd = isExternalRef && options?.dereference.externalReferenceResolution === "root";
+    const $refPath = url.resolve(shouldResolveOnCwd ? url.cwd() : path, $ref.$ref);
     const cache = dereferencedCache.get($refPath);
     if (cache) {
         const refKeys = Object.keys($ref);

package/dist/lib/index.js

@@ -22,15 +22,6 @@ var __importStar = (this && this.__importStar) || function (mod) {
     __setModuleDefault(result, mod);
     return result;
 };
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -76,66 +67,71 @@ class $RefParser {
          */
         this.$refs = new refs_js_1.default();
     }
-    parse() {
-        return __awaiter(this, arguments, void 0, function* () {
-            const args = (0, normalize_args_js_1.default)(arguments);
-            let promise;
-            if (!args.path && !args.schema) {
-                const err = (0, ono_1.ono)(`Expected a file path, URL, or object. Got ${args.path || args.schema}`);
-                return (0, maybe_js_1.default)(args.callback, Promise.reject(err));
-            }
-            // Reset everything
-            this.schema = null;
-            this.$refs = new refs_js_1.default();
-            // If the path is a filesystem path, then convert it to a URL.
-            // NOTE: According to the JSON Reference spec, these should already be URLs,
-            // but, in practice, many people use local filesystem paths instead.
-            // So we're being generous here and doing the conversion automatically.
-            // This is not intended to be a 100% bulletproof solution.
-            // If it doesn't work for your use-case, then use a URL instead.
-            let pathType = "http";
-            if (url.isFileSystemPath(args.path)) {
-                args.path = url.fromFileSystemPath(args.path);
-                pathType = "file";
+    async parse() {
+        const args = (0, normalize_args_js_1.default)(arguments);
+        let promise;
+        if (!args.path && !args.schema) {
+            const err = (0, ono_1.ono)(`Expected a file path, URL, or object. Got ${args.path || args.schema}`);
+            return (0, maybe_js_1.default)(args.callback, Promise.reject(err));
+        }
+        // Reset everything
+        this.schema = null;
+        this.$refs = new refs_js_1.default();
+        // If the path is a filesystem path, then convert it to a URL.
+        // NOTE: According to the JSON Reference spec, these should already be URLs,
+        // but, in practice, many people use local filesystem paths instead.
+        // So we're being generous here and doing the conversion automatically.
+        // This is not intended to be a 100% bulletproof solution.
+        // If it doesn't work for your use-case, then use a URL instead.
+        let pathType = "http";
+        if (url.isFileSystemPath(args.path)) {
+            args.path = url.fromFileSystemPath(args.path);
+            pathType = "file";
+        }
+        else if (!args.path && args.schema && args.schema.$id) {
+            // when schema id has defined an URL should use that hostname to request the references,
+            // instead of using the current page URL
+            const params = url.parse(args.schema.$id);
+            const port = params.protocol === "https:" ? 443 : 80;
+            args.path = `${params.protocol}//${params.hostname}:${port}`;
+        }
+        // Resolve the absolute path of the schema
+        args.path = url.resolve(url.cwd(), args.path);
+        if (args.schema && typeof args.schema === "object") {
+            // A schema object was passed-in.
+            // So immediately add a new $Ref with the schema object as its value
+            const $ref = this.$refs._add(args.path);
+            $ref.value = args.schema;
+            $ref.pathType = pathType;
+            promise = Promise.resolve(args.schema);
+        }
+        else {
+            // Parse the schema file/url
+            promise = (0, parse_js_1.default)(args.path, this.$refs, args.options);
+        }
+        try {
+            const result = await promise;
+            if (result !== null && typeof result === "object" && !Buffer.isBuffer(result)) {
+                this.schema = result;
+                return (0, maybe_js_1.default)(args.callback, Promise.resolve(this.schema));
             }
-            // Resolve the absolute path of the schema
-            args.path = url.resolve(url.cwd(), args.path);
-            if (args.schema && typeof args.schema === "object") {
-                // A schema object was passed-in.
-                // So immediately add a new $Ref with the schema object as its value
-                const $ref = this.$refs._add(args.path);
-                $ref.value = args.schema;
-                $ref.pathType = pathType;
-                promise = Promise.resolve(args.schema);
+            else if (args.options.continueOnError) {
+                this.schema = null; // it's already set to null at line 79, but let's set it again for the sake of readability
+                return (0, maybe_js_1.default)(args.callback, Promise.resolve(this.schema));
             }
             else {
-                // Parse the schema file/url
-                promise = (0, parse_js_1.default)(args.path, this.$refs, args.options);
+                throw ono_1.ono.syntax(`"${this.$refs._root$Ref.path || result}" is not a valid JSON Schema`);
             }
-            try {
-                const result = yield promise;
-                if (result !== null && typeof result === "object" && !Buffer.isBuffer(result)) {
-                    this.schema = result;
-                    return (0, maybe_js_1.default)(args.callback, Promise.resolve(this.schema));
-                }
-                else if (args.options.continueOnError) {
-                    this.schema = null; // it's already set to null at line 79, but let's set it again for the sake of readability
-                    return (0, maybe_js_1.default)(args.callback, Promise.resolve(this.schema));
-                }
-                else {
-                    throw ono_1.ono.syntax(`"${this.$refs._root$Ref.path || result}" is not a valid JSON Schema`);
-                }
+        }
+        catch (err) {
+            if (!args.options.continueOnError || !(0, errors_js_1.isHandledError)(err)) {
+                return (0, maybe_js_1.default)(args.callback, Promise.reject(err));
             }
-            catch (err) {
-                if (!args.options.continueOnError || !(0, errors_js_1.isHandledError)(err)) {
-                    return (0, maybe_js_1.default)(args.callback, Promise.reject(err));
-                }
-                if (this.$refs._$refs[url.stripHash(args.path)]) {
-                    this.$refs._$refs[url.stripHash(args.path)].addError(err);
-                }
-                return (0, maybe_js_1.default)(args.callback, Promise.resolve(null));
+            if (this.$refs._$refs[url.stripHash(args.path)]) {
+                this.$refs._$refs[url.stripHash(args.path)].addError(err);
             }
-        });
+            return (0, maybe_js_1.default)(args.callback, Promise.resolve(null));
+        }
     }
     static parse() {
         const parser = new $RefParser();
@@ -154,19 +150,17 @@ class $RefParser {
      * @returns
      * The returned promise resolves with a {@link $Refs} object containing the resolved JSON references
      */
-    resolve() {
-        return __awaiter(this, arguments, void 0, function* () {
-            const args = (0, normalize_args_js_1.default)(arguments);
-            try {
-                yield this.parse(args.path, args.schema, args.options);
-                yield (0, resolve_external_js_1.default)(this, args.options);
-                finalize(this);
-                return (0, maybe_js_1.default)(args.callback, Promise.resolve(this.$refs));
-            }
-            catch (err) {
-                return (0, maybe_js_1.default)(args.callback, Promise.reject(err));
-            }
-        });
+    async resolve() {
+        const args = (0, normalize_args_js_1.default)(arguments);
+        try {
+            await this.parse(args.path, args.schema, args.options);
+            await (0, resolve_external_js_1.default)(this, args.options);
+            finalize(this);
+            return (0, maybe_js_1.default)(args.callback, Promise.resolve(this.$refs));
+        }
+        catch (err) {
+            return (0, maybe_js_1.default)(args.callback, Promise.reject(err));
+        }
     }
     static resolve() {
         const instance = new $RefParser();
@@ -176,37 +170,33 @@ class $RefParser {
         const instance = new $RefParser();
         return instance.bundle.apply(instance, arguments);
     }
-    bundle() {
-        return __awaiter(this, arguments, void 0, function* () {
-            const args = (0, normalize_args_js_1.default)(arguments);
-            try {
-                yield this.resolve(args.path, args.schema, args.options);
-                (0, bundle_js_1.default)(this, args.options);
-                finalize(this);
-                return (0, maybe_js_1.default)(args.callback, Promise.resolve(this.schema));
-            }
-            catch (err) {
-                return (0, maybe_js_1.default)(args.callback, Promise.reject(err));
-            }
-        });
+    async bundle() {
+        const args = (0, normalize_args_js_1.default)(arguments);
+        try {
+            await this.resolve(args.path, args.schema, args.options);
+            (0, bundle_js_1.default)(this, args.options);
+            finalize(this);
+            return (0, maybe_js_1.default)(args.callback, Promise.resolve(this.schema));
+        }
+        catch (err) {
+            return (0, maybe_js_1.default)(args.callback, Promise.reject(err));
+        }
     }
     static dereference() {
         const instance = new $RefParser();
         return instance.dereference.apply(instance, arguments);
     }
-    dereference() {
-        return __awaiter(this, arguments, void 0, function* () {
-            const args = (0, normalize_args_js_1.default)(arguments);
-            try {
-                yield this.resolve(args.path, args.schema, args.options);
-                (0, dereference_js_1.default)(this, args.options);
-                finalize(this);
-                return (0, maybe_js_1.default)(args.callback, Promise.resolve(this.schema));
-            }
-            catch (err) {
-                return (0, maybe_js_1.default)(args.callback, Promise.reject(err));
-            }
-        });
+    async dereference() {
+        const args = (0, normalize_args_js_1.default)(arguments);
+        try {
+            await this.resolve(args.path, args.schema, args.options);
+            (0, dereference_js_1.default)(this, args.options);
+            finalize(this);
+            return (0, maybe_js_1.default)(args.callback, Promise.resolve(this.schema));
+        }
+        catch (err) {
+            return (0, maybe_js_1.default)(args.callback, Promise.reject(err));
+        }
     }
 }
 exports.$RefParser = $RefParser;

package/dist/lib/options.d.ts

@@ -69,6 +69,12 @@ interface $RefParserOptions {
          * @argument {JSONSchemaObject} object The JSON-Schema that the `$ref` resolved to.
          */
         onDereference?(path: string, value: JSONSchemaObject): void;
+        /**
+         * Whether a reference should resolve relative to its directory/path, or from the cwd
+         *
+         * Default: `relative`
+         */
+        externalReferenceResolution?: "relative" | "root";
     };
 }
 export declare const getNewOptions: (options: DeepPartial<$RefParserOptions>) => $RefParserOptions;

package/dist/lib/options.js

@@ -69,6 +69,7 @@ const getDefaults = () => {
              * @type {function}
              */
             excludedPathMatcher: () => false,
+            referenceResolution: "relative",
         },
     };
     return (0, lodash_clonedeep_1.default)(defaults);

package/dist/lib/parse.js

@@ -22,15 +22,6 @@ var __importStar = (this && this.__importStar) || function (mod) {
     __setModuleDefault(result, mod);
     return result;
 };
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 const ono_1 = require("@jsdevtools/ono");
 const url = __importStar(require("./util/url.js"));
@@ -40,34 +31,32 @@ exports.default = parse;
 /**
  * Reads and parses the specified file path or URL.
  */
-function parse(path, $refs, options) {
-    return __awaiter(this, void 0, void 0, function* () {
-        // Remove the URL fragment, if any
-        path = url.stripHash(path);
-        // Add a new $Ref for this file, even though we don't have the value yet.
-        // This ensures that we don't simultaneously read & parse the same file multiple times
-        const $ref = $refs._add(path);
-        // This "file object" will be passed to all resolvers and parsers.
-        const file = {
-            url: path,
-            extension: url.getExtension(path),
-        };
-        // Read the file and then parse the data
-        try {
-            const resolver = yield readFile(file, options, $refs);
-            $ref.pathType = resolver.plugin.name;
-            file.data = resolver.result;
-            const parser = yield parseFile(file, options, $refs);
-            $ref.value = parser.result;
-            return parser.result;
-        }
-        catch (err) {
-            if ((0, errors_js_1.isHandledError)(err)) {
-                $ref.value = err;
-            }
-            throw err;
+async function parse(path, $refs, options) {
+    // Remove the URL fragment, if any
+    path = url.stripHash(path);
+    // Add a new $Ref for this file, even though we don't have the value yet.
+    // This ensures that we don't simultaneously read & parse the same file multiple times
+    const $ref = $refs._add(path);
+    // This "file object" will be passed to all resolvers and parsers.
+    const file = {
+        url: path,
+        extension: url.getExtension(path),
+    };
+    // Read the file and then parse the data
+    try {
+        const resolver = await readFile(file, options, $refs);
+        $ref.pathType = resolver.plugin.name;
+        file.data = resolver.result;
+        const parser = await parseFile(file, options, $refs);
+        $ref.value = parser.result;
+        return parser.result;
+    }
+    catch (err) {
+        if ((0, errors_js_1.isHandledError)(err)) {
+            $ref.value = err;
         }
-    });
+        throw err;
+    }
 }
 /**
  * Reads the given file, using the configured resolver plugins
@@ -80,36 +69,34 @@ function parse(path, $refs, options) {
  * @returns
  * The promise resolves with the raw file contents and the resolver that was used.
  */
-function readFile(file, options, $refs) {
-    return __awaiter(this, void 0, void 0, function* () {
-        // console.log('Reading %s', file.url);
-        // Find the resolvers that can read this file
-        let resolvers = plugins.all(options.resolve);
-        resolvers = plugins.filter(resolvers, "canRead", file);
-        // Run the resolvers, in order, until one of them succeeds
-        plugins.sort(resolvers);
-        try {
-            const data = yield plugins.run(resolvers, "read", file, $refs);
-            return data;
+async function readFile(file, options, $refs) {
+    // console.log('Reading %s', file.url);
+    // Find the resolvers that can read this file
+    let resolvers = plugins.all(options.resolve);
+    resolvers = plugins.filter(resolvers, "canRead", file);
+    // Run the resolvers, in order, until one of them succeeds
+    plugins.sort(resolvers);
+    try {
+        const data = await plugins.run(resolvers, "read", file, $refs);
+        return data;
+    }
+    catch (err) {
+        if (!err && options.continueOnError) {
+            // No resolver could be matched
+            throw new errors_js_1.UnmatchedResolverError(file.url);
+        }
+        else if (!err || !("error" in err)) {
+            // Throw a generic, friendly error.
+            throw ono_1.ono.syntax(`Unable to resolve $ref pointer "${file.url}"`);
         }
-        catch (err) {
-            if (!err && options.continueOnError) {
-                // No resolver could be matched
-                throw new errors_js_1.UnmatchedResolverError(file.url);
-            }
-            else if (!err || !("error" in err)) {
-                // Throw a generic, friendly error.
-                throw ono_1.ono.syntax(`Unable to resolve $ref pointer "${file.url}"`);
-            }
-            // Throw the original error, if it's one of our own (user-friendly) errors.
-            else if (err.error instanceof errors_js_1.ResolverError) {
-                throw err.error;
-            }
-            else {
-                throw new errors_js_1.ResolverError(err, file.url);
-            }
+        // Throw the original error, if it's one of our own (user-friendly) errors.
+        else if (err.error instanceof errors_js_1.ResolverError) {
+            throw err.error;
         }
-    });
+        else {
+            throw new errors_js_1.ResolverError(err, file.url);
+        }
+    }
 }
 /**
  * Parses the given file's contents, using the configured parser plugins.
@@ -123,45 +110,43 @@ function readFile(file, options, $refs) {
  * @returns
  * The promise resolves with the parsed file contents and the parser that was used.
  */
-function parseFile(file, options, $refs) {
-    return __awaiter(this, void 0, void 0, function* () {
-        // console.log('Parsing %s', file.url);
-        // Find the parsers that can read this file type.
-        // If none of the parsers are an exact match for this file, then we'll try ALL of them.
-        // This handles situations where the file IS a supported type, just with an unknown extension.
-        const allParsers = plugins.all(options.parse);
-        const filteredParsers = plugins.filter(allParsers, "canParse", file);
-        const parsers = filteredParsers.length > 0 ? filteredParsers : allParsers;
-        // Run the parsers, in order, until one of them succeeds
-        plugins.sort(parsers);
-        try {
-            const parser = yield plugins.run(parsers, "parse", file, $refs);
-            if (!parser.plugin.allowEmpty && isEmpty(parser.result)) {
-                throw ono_1.ono.syntax(`Error parsing "${file.url}" as ${parser.plugin.name}. \nParsed value is empty`);
-            }
-            else {
-                return parser;
-            }
+async function parseFile(file, options, $refs) {
+    // console.log('Parsing %s', file.url);
+    // Find the parsers that can read this file type.
+    // If none of the parsers are an exact match for this file, then we'll try ALL of them.
+    // This handles situations where the file IS a supported type, just with an unknown extension.
+    const allParsers = plugins.all(options.parse);
+    const filteredParsers = plugins.filter(allParsers, "canParse", file);
+    const parsers = filteredParsers.length > 0 ? filteredParsers : allParsers;
+    // Run the parsers, in order, until one of them succeeds
+    plugins.sort(parsers);
+    try {
+        const parser = await plugins.run(parsers, "parse", file, $refs);
+        if (!parser.plugin.allowEmpty && isEmpty(parser.result)) {
+            throw ono_1.ono.syntax(`Error parsing "${file.url}" as ${parser.plugin.name}. \nParsed value is empty`);
         }
-        catch (err) {
-            if (!err && options.continueOnError) {
-                // No resolver could be matched
-                throw new errors_js_1.UnmatchedParserError(file.url);
-            }
-            else if (err && err.message && err.message.startsWith("Error parsing")) {
-                throw err;
-            }
-            else if (!err || !("error" in err)) {
-                throw ono_1.ono.syntax(`Unable to parse ${file.url}`);
-            }
-            else if (err.error instanceof errors_js_1.ParserError) {
-                throw err.error;
-            }
-            else {
-                throw new errors_js_1.ParserError(err.error.message, file.url);
-            }
+        else {
+            return parser;
         }
-    });
+    }
+    catch (err) {
+        if (!err && options.continueOnError) {
+            // No resolver could be matched
+            throw new errors_js_1.UnmatchedParserError(file.url);
+        }
+        else if (err && err.message && err.message.startsWith("Error parsing")) {
+            throw err;
+        }
+        else if (!err || !("error" in err)) {
+            throw ono_1.ono.syntax(`Unable to parse ${file.url}`);
+        }
+        else if (err.error instanceof errors_js_1.ParserError) {
+            throw err.error;
+        }
+        else {
+            throw new errors_js_1.ParserError(err.error.message, file.url);
+        }
+    }
 }
 /**
  * Determines whether the parsed value is "empty".

package/dist/lib/parsers/json.js

@@ -1,13 +1,4 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 const errors_js_1 = require("../util/errors.js");
 exports.default = {
@@ -29,29 +20,27 @@ exports.default = {
     /**
      * Parses the given file as JSON
      */
-    parse(file) {
-        return __awaiter(this, void 0, void 0, function* () {
-            let data = file.data;
-            if (Buffer.isBuffer(data)) {
-                data = data.toString();
+    async parse(file) {
+        let data = file.data;
+        if (Buffer.isBuffer(data)) {
+            data = data.toString();
+        }
+        if (typeof data === "string") {
+            if (data.trim().length === 0) {
+                return; // This mirrors the YAML behavior
             }
-            if (typeof data === "string") {
-                if (data.trim().length === 0) {
-                    return; // This mirrors the YAML behavior
+            else {
+                try {
+                    return JSON.parse(data);
                 }
-                else {
-                    try {
-                        return JSON.parse(data);
-                    }
-                    catch (e) {
-                        throw new errors_js_1.ParserError(e.message, file.url);
-                    }
+                catch (e) {
+                    throw new errors_js_1.ParserError(e.message, file.url);
                 }
             }
-            else {
-                // data is already a JavaScript value (object, array, number, null, NaN, etc.)
-                return data;
-            }
-        });
+        }
+        else {
+            // data is already a JavaScript value (object, array, number, null, NaN, etc.)
+            return data;
+        }
     },
 };