Allow pointer errors

Author: P0lip

lib/bundle.js

@@ -96,7 +96,11 @@ function crawl (parent, key, path, pathFromRoot, indirections, inventory, $refs,
 function inventory$Ref ($refParent, $refKey, path, pathFromRoot, indirections, inventory, $refs, options) {
   let $ref = $refKey === null ? $refParent : $refParent[$refKey];
   let $refPath = url.resolve(path, $ref.$ref);
-  let pointer = $refs._resolve($refPath, options);
+  let pointer = $refs._resolve($refPath, pathFromRoot, options);
+  if (pointer === null) {
+    return;
+  }
+
   let depth = Pointer.parse(pathFromRoot).length;
   let file = url.stripHash(pointer.path);
   let hash = url.getHash(pointer.path);

lib/dereference.js

@@ -96,7 +96,14 @@ function dereference$Ref ($ref, path, pathFromRoot, parents, $refs, options) {
   // console.log('Dereferencing $ref pointer "%s" at %s', $ref.$ref, path);
 
   let $refPath = url.resolve(path, $ref.$ref);
-  let pointer = $refs._resolve($refPath, options);
+  let pointer = $refs._resolve($refPath, pathFromRoot, options);
+
+  if (pointer === null) {
+    return {
+      circular: false,
+      value: null,
+    };
+  }
 
   // Check for circular references
   let directCircular = pointer.circular;

lib/pointer.js

@@ -4,7 +4,7 @@ module.exports = Pointer;
 
 const $Ref = require("./ref");
 const url = require("./util/url");
-const { ono } = require("ono");
+const { GenericError, MissingPointerError, isHandledError } = require("./util/errors");
 const slashes = /\//g;
 const tildes = /~/g;
 const escapedSlash = /~1/g;
@@ -75,16 +75,18 @@ Pointer.prototype.resolve = function (obj, options) {
   let tokens = Pointer.parse(this.path);
 
   // Crawl the object, one token at a time
-  this.value = obj;
+  this.value = unwrapOrThrow(obj);
+
   for (let i = 0; i < tokens.length; i++) {
     if (resolveIf$Ref(this, options)) {
       // The $ref path has changed, so append the remaining tokens to the path
       this.path = Pointer.join(this.path, tokens.slice(i));
     }
 
     let token = tokens[i];
-    if (this.value[token] === undefined) {
-      throw ono.syntax(`Error resolving $ref pointer "${this.originalPath}". \nToken "${token}" does not exist.`);
+    if (this.value[token] === undefined || this.value[token] === null) {
+      this.value = null;
+      throw new MissingPointerError(token, this.originalPath);
     }
     else {
       this.value = this.value[token];
@@ -117,7 +119,8 @@ Pointer.prototype.set = function (obj, value, options) {
   }
 
   // Crawl the object, one token at a time
-  this.value = obj;
+  this.value = unwrapOrThrow(obj);
+
   for (let i = 0; i < tokens.length - 1; i++) {
     resolveIf$Ref(this, options);
 
@@ -171,7 +174,7 @@ Pointer.parse = function (path) {
   }
 
   if (pointer[0] !== "") {
-    throw ono.syntax(`Invalid $ref pointer "${pointer}". Pointers must begin with "#/"`);
+    throw new GenericError(`Invalid $ref pointer "${pointer}". Pointers must begin with "#/"`);
   }
 
   return pointer.slice(1);
@@ -222,7 +225,7 @@ function resolveIf$Ref (pointer, options) {
       pointer.circular = true;
     }
     else {
-      let resolved = pointer.$ref.$refs._resolve($refPath, options);
+      let resolved = pointer.$ref.$refs._resolve($refPath, url.getHash(pointer.path), options);
       pointer.indirections += resolved.indirections + 1;
 
       if ($Ref.isExtended$Ref(pointer.value)) {
@@ -264,7 +267,16 @@ function setValue (pointer, token, value) {
     }
   }
   else {
-    throw ono.syntax(`Error assigning $ref pointer "${pointer.path}". \nCannot set "${token}" of a non-object.`);
+    throw new GenericError(`Error assigning $ref pointer "${pointer.path}". \nCannot set "${token}" of a non-object.`);
+  }
+  return value;
+}
+
+
+function unwrapOrThrow (value) {
+  if (isHandledError(value)) {
+    throw value;
   }
+
   return value;
 }

lib/ref.js

@@ -3,7 +3,8 @@
 module.exports = $Ref;
 
 const Pointer = require("./pointer");
-const { GenericError, GenericErrorGroup, ParserError, MissingPointerError, ResolverError } = require("./util/errors");
+const { GenericError, GenericErrorGroup, ParserError, MissingPointerError, ResolverError, isHandledError } = require("./util/errors");
+const { safePointerToPath } = require("./util/url");
 
 /**
  * This class represents a single JSON reference and its resolved value.
@@ -102,12 +103,24 @@ $Ref.prototype.get = function (path, options) {
  *
  * @param {string} path - The full path being resolved, optionally with a JSON pointer in the hash
  * @param {$RefParserOptions} options
- * @param {string} [friendlyPath] - The original user-specified path (used for error messages)
+ * @param {string} friendlyPath - The original user-specified path (used for error messages)
+*  @param {string} pathFromRoot - The path of `obj` from the schema root
  * @returns {Pointer}
  */
-$Ref.prototype.resolve = function (path, options, friendlyPath) {
+$Ref.prototype.resolve = function (path, options, friendlyPath, pathFromRoot) {
   let pointer = new Pointer(this, path, friendlyPath);
-  return pointer.resolve(this.value, options);
+  try {
+    return pointer.resolve(this.value, options);
+  }
+  catch (err) {
+    if (!options || options.failFast || !isHandledError(err)) {
+      throw err;
+    }
+
+    err.path = safePointerToPath(pathFromRoot);
+    this.addError(err);
+    return null;
+  }
 };
 
 /**

lib/refs.js

@@ -79,7 +79,7 @@ $Refs.prototype.toJSON = $Refs.prototype.values;
  */
 $Refs.prototype.exists = function (path, options) {
   try {
-    this._resolve(path, options);
+    this._resolve(path, "", options);
     return true;
   }
   catch (e) {
@@ -95,7 +95,7 @@ $Refs.prototype.exists = function (path, options) {
  * @returns {*} - Returns the resolved value
  */
 $Refs.prototype.get = function (path, options) {
-  return this._resolve(path, options).value;
+  return this._resolve(path, "", options).value;
 };
 
 /**
@@ -139,11 +139,12 @@ $Refs.prototype._add = function (path) {
  * Resolves the given JSON reference.
  *
  * @param {string} path - The path being resolved, optionally with a JSON pointer in the hash
+ * @param {string} pathFromRoot - The path of `obj` from the schema root
  * @param {$RefParserOptions} [options]
  * @returns {Pointer}
  * @protected
  */
-$Refs.prototype._resolve = function (path, options) {
+$Refs.prototype._resolve = function (path, pathFromRoot, options) {
   let absPath = url.resolve(this._root$Ref.path, path);
   let withoutHash = url.stripHash(absPath);
   let $ref = this._$refs[withoutHash];
@@ -152,7 +153,7 @@ $Refs.prototype._resolve = function (path, options) {
     throw ono(`Error resolving $ref pointer "${path}". \n"${withoutHash}" not found.`);
   }
 
-  return $ref.resolve(absPath, options, path);
+  return $ref.resolve(absPath, options, path, pathFromRoot);
 };
 
 /**

lib/resolve-external.js

@@ -118,6 +118,7 @@ async function resolve$Ref ($ref, path, $refs, options) {
 
     if ($refs._$refs[withoutHash]) {
       err.source = url.stripHash(path);
+      err.path = url.safePointerToPath(url.getHash(path));
     }
 
     return [];

lib/util/url.js

@@ -1,5 +1,7 @@
 "use strict";
 
+const { pointerToPath } = require("@stoplight/json");
+
 let isWindows = /^win/.test(process.platform),
     forwardSlashPattern = /\//g,
     protocolPattern = /^(\w{2,}):\/\//i,
@@ -220,3 +222,19 @@ exports.toFileSystemPath = function toFileSystemPath (path, keepFileProtocol) {
 
   return path;
 };
+
+/**
+ * Converts a $ref pointer to a valid JSON Path.
+ * It _does not_ throw.
+ *
+ * @param {string}  pointer
+ * @returns {Array<number | string>}
+ */
+exports.safePointerToPath = function safePointerToPath (pointer) {
+  try {
+    return pointerToPath(pointer);
+  }
+  catch (ex) {
+    return [];
+  }
+};

test/specs/invalid/invalid.spec.js

@@ -193,5 +193,73 @@ describe("Invalid syntax", () => {
         foo: ":\n"
       });
     });
+
+    describe("when failFast is false", () => {
+      it("should not throw an error for an invalid file path", async () => {
+        const parser = new $RefParser();
+        const result = await parser.dereference({ foo: { $ref: "this file does not exist" }}, { failFast: false });
+        expect(parser.errors.length).to.equal(1);
+        expect(parser.errors).to.containSubset([
+          {
+            name: ResolverError.name,
+            message: expectedValue => expectedValue.startsWith("Error opening file"),
+            path: ["foo"],
+            source: expectedValue => expectedValue.endsWith("/test/"),
+          }
+        ]);
+      });
+
+      it("should not throw an error for an invalid YAML file", async () => {
+        const parser = new $RefParser();
+        const result = await parser.dereference({ foo: { $ref: path.rel("specs/invalid/invalid.yaml") }}, { failFast: false });
+        expect(result).to.deep.equal({ foo: null });
+        expect(parser.errors.length).to.equal(1);
+        expect(parser.errors).to.containSubset([
+          {
+            name: ParserError.name,
+            message: "incomplete explicit mapping pair; a key node is missed",
+            path: ["foo"],
+            source: expectedValue => expectedValue.endsWith("/test/"),
+          },
+        ]);
+      });
+
+      it("should not throw an error for an invalid JSON file", async () => {
+        const parser = new $RefParser();
+        const result = await parser.dereference({ foo: { $ref: path.rel("specs/invalid/invalid.json") }}, { failFast: false });
+        expect(result).to.deep.equal({ foo: null });
+        expect(parser.errors.length).to.equal(1);
+        expect(parser.errors).to.containSubset([
+          {
+            name: ParserError.name,
+            message: "unexpected end of the stream within a flow collection",
+            path: ["foo"],
+            source: expectedValue => expectedValue.endsWith("/test/"),
+          }
+        ]);
+      });
+
+      it("should not throw an error for an invalid JSON file with YAML disabled", async () => {
+        const parser = new $RefParser();
+        const result = await parser.dereference({ foo: { $ref: path.rel("specs/invalid/invalid.json") }}, { failFast: false, parse: { yaml: false }});
+        expect(result).to.deep.equal({ foo: null });
+        expect(parser.errors.length).to.equal(1);
+        expect(parser.errors).to.containSubset([
+          {
+            name: ParserError.name,
+            message: "CloseBraceExpected",
+            path: ["foo"],
+            source: expectedValue => expectedValue.endsWith("/test/"),
+          }
+        ]);
+      });
+
+      it("should not throw an error for an invalid YAML file with JSON and YAML disabled", async () => {
+        const parser = new $RefParser();
+        const result = await parser.dereference({ foo: { $ref: path.rel("specs/invalid/invalid.yaml") }}, { failFast: false, parse: { yaml: false, json: false }});
+        expect(result).to.deep.equal({ foo: ":\n" });
+        expect(parser.errors).to.deep.equal([]);
+      });
+    });
   });
 });

test/specs/missing-pointers/missing-pointers.spec.js

@@ -0,0 +1,36 @@
+"use strict";
+
+const chai = require("chai");
+const chaiSubset = require("chai-subset");
+chai.use(chaiSubset);
+const { expect } = chai;
+const $RefParser = require("../../../lib");
+const helper = require("../../utils/helper");
+const { MissingPointerError } = require("../../../lib/util/errors");
+
+describe("Schema with missing pointers", () => {
+  it("should throw an error for missing pointer", async () => {
+    try {
+      await $RefParser.dereference({ foo: { $ref: "#/baz" }});
+      helper.shouldNotGetCalled();
+    }
+    catch (err) {
+      expect(err).to.be.an.instanceOf(MissingPointerError);
+      expect(err.message).to.contain("Token \"baz\" does not exist.");
+    }
+  });
+
+  it("should not throw an error for missing pointer if failFast is false", async () => {
+    const parser = new $RefParser();
+    const result = await parser.dereference({ foo: { $ref: "#/baz" }}, { failFast: false });
+    expect(result).to.deep.equal({ foo: null });
+    expect(parser.errors).to.containSubset([
+      {
+        name: MissingPointerError.name,
+        message: "Token \"baz\" does not exist.",
+        path: ["foo"],
+        source: expectedValue => expectedValue.endsWith("/test/"),
+      }
+    ]);
+  });
+});

test/specs/refs.spec.js

@@ -216,10 +216,7 @@ describe("$Refs object", () => {
       }
       catch (err) {
         expect(err).to.be.an.instanceOf(Error);
-        expect(err.message).to.equal(
-          'Error resolving $ref pointer "definitions/name.yaml#/". ' +
-          '\nToken "" does not exist.'
-        );
+        expect(err.message).to.equal('Token "" does not exist.');
       }
     });
 
@@ -257,10 +254,7 @@ describe("$Refs object", () => {
       }
       catch (err) {
         expect(err).to.be.an.instanceOf(Error);
-        expect(err.message).to.equal(
-          'Error resolving $ref pointer "external.yaml#/foo/bar". ' +
-          '\nToken "foo" does not exist.'
-        );
+        expect(err.message).to.equal('Token "foo" does not exist.');
       }
     });
   });