Resolved might be null

Author: P0lip

Diff for: lib/pointer.js

@@ -227,6 +227,10 @@ function resolveIf$Ref (pointer, options) {
     }
     else {
       let resolved = pointer.$ref.$refs._resolve($refPath, url.getHash(pointer.path), options);
+      if (resolved === null) {
+        return false;
+      }
+
       pointer.indirections += resolved.indirections + 1;
 
       if ($Ref.isExtended$Ref(pointer.value)) {

Diff for: lib/ref.js

@@ -53,25 +53,30 @@ function $Ref () {
 /**
  * Pushes an error to errors array.
  *
- * @param {Array<JSONParserError | JSONParserErrorGroup>} error - The error to be pushed
+ * @param {Array<JSONParserError | JSONParserErrorGroup>} err - The error to be pushed
  * @returns {void}
  */
 $Ref.prototype.addError = function (err) {
   if (this.errors === undefined) {
     this.errors = [];
   }
 
+  const existingErrors = this.errors.map(({ footprint }) => footprint);
+
   // the path has been almost certainly set at this point,
-  // but just in case something went wrong, let's inject path if necessary
+  // but just in case something went wrong, normalizeError injects path if necessary
+  // moreover, certain errors might point at the same spot, so filter them out to reduce noise
   if (Array.isArray(err.errors)) {
-    this.errors.push(...err.errors.map(normalizeError));
+    this.errors.push(...err.errors
+      .map(normalizeError)
+      .filter(({ footprint }) => !existingErrors.includes(footprint)),
+    );
   }
-  else {
+  else if (!existingErrors.includes(err.footprint)) {
     this.errors.push(normalizeError(err));
   }
 };
 
-
 /**
  * Determines whether the given JSON reference exists within this {@link $Ref#value}.
  *
@@ -107,7 +112,7 @@ $Ref.prototype.get = function (path, options) {
  * @param {$RefParserOptions} options
  * @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}
+ * @returns {Pointer | null}
  */
 $Ref.prototype.resolve = function (path, options, friendlyPath, pathFromRoot) {
   let pointer = new Pointer(this, path, friendlyPath);

Diff for: lib/util/errors.js

@@ -15,6 +15,10 @@ const JSONParserError = exports.JSONParserError = class JSONParserError extends
 
     Ono.extend(this);
   }
+
+  get footprint () {
+    return `${this.path}+${this.source}+${this.code}+${this.message}`;
+  }
 };
 
 setErrorName(JSONParserError);

Diff for: test/specs/missing-pointers/external-from-internal.yaml

@@ -0,0 +1,5 @@
+internal1:
+  $ref: '#/internal2'
+internal2:
+  $ref: '#/external'
+

Diff for: test/specs/missing-pointers/missing-pointers.spec.js

@@ -21,25 +21,65 @@ describe("Schema with missing pointers", () => {
     }
   });
 
-  it("should throw a grouped error for missing pointer if continueOnError is true", async () => {
-    const parser = new $RefParser();
+  it("should throw an error for missing pointer in external file", async () => {
     try {
-      await parser.dereference({ foo: { $ref: "#/baz" }}, { continueOnError: true });
+      await $RefParser.dereference({ foo: { $ref: path.abs("specs/missing-pointers/external-from-internal.yaml") }});
       helper.shouldNotGetCalled();
     }
     catch (err) {
-      expect(err).to.be.instanceof(JSONParserErrorGroup);
-      expect(err.files).to.equal(parser);
-      expect(err.files.$refs._root$Ref.value).to.deep.equal({ foo: null });
-      expect(err.message).to.have.string("1 error occurred while reading '");
-      expect(err.errors).to.containSubset([
-        {
-          name: MissingPointerError.name,
-          message: "Token \"baz\" does not exist.",
-          path: ["foo"],
-          source: message => message.endsWith("/test/") || message.startsWith("http://localhost"),
-        }
-      ]);
+      expect(err).to.be.an.instanceOf(MissingPointerError);
+      expect(err.message).to.contain("Token \"external\" does not exist.");
     }
   });
+
+  context("when continueOnError is true", () => {
+    it("should throw a grouped error for missing pointer", async () => {
+      const parser = new $RefParser();
+      try {
+        await parser.dereference({ foo: { $ref: "#/baz" }}, { continueOnError: true });
+        helper.shouldNotGetCalled();
+      }
+      catch (err) {
+        expect(err).to.be.instanceof(JSONParserErrorGroup);
+        expect(err.files).to.equal(parser);
+        expect(err.files.$refs._root$Ref.value).to.deep.equal({ foo: null });
+        expect(err.message).to.have.string("1 error occurred while reading '");
+        expect(err.errors).to.containSubset([
+          {
+            name: MissingPointerError.name,
+            message: "Token \"baz\" does not exist.",
+            path: ["foo"],
+            source: message => message.endsWith("/test/") || message.startsWith("http://localhost"),
+          }
+        ]);
+      }
+    });
+
+    it("should throw an error for missing pointer in external file", async () => {
+      const parser = new $RefParser();
+      try {
+        await parser.dereference({ foo: { $ref: path.abs("specs/missing-pointers/external-from-internal.yaml") }}, { continueOnError: true });
+        helper.shouldNotGetCalled();
+      }
+      catch (err) {
+        expect(err).to.be.instanceof(JSONParserErrorGroup);
+        expect(err.files).to.equal(parser);
+        expect(err.files.$refs._root$Ref.value).to.deep.equal({
+          foo: {
+            internal1: null,
+            internal2: null,
+          }
+        });
+        expect(err.message).to.have.string("1 error occurred while reading '");
+        expect(err.errors).to.containSubset([
+          {
+            name: MissingPointerError.name,
+            message: "Token \"external\" does not exist.",
+            path: ["internal2"],
+            source: message => message.endsWith("missing-pointers/external-from-internal.yaml") || message.startsWith("http://localhost"),
+          }
+        ]);
+      }
+    });
+  });
 });