Dedicated error for invalid pointers

Author: P0lip

lib/index.d.ts

@@ -30,7 +30,7 @@ declare class $RefParser {
    *
    * See https://github.com/APIDevTools/json-schema-ref-parser/blob/master/docs/ref-parser.md#errors
    */
-  errors: Array<$RefParser.GenericError | $RefParser.ResolverError | $RefParser.ParserError | $RefParser.MissingPointerError | $RefParser.UnmatchedParserError | $RefParser.UnmatchedResolverError>;
+  errors: Array<$RefParser.GenericError | $RefParser.InvalidPointerError | $RefParser.ResolverError | $RefParser.ParserError | $RefParser.MissingPointerError | $RefParser.UnmatchedParserError | $RefParser.UnmatchedResolverError>;
 
   /**
    * Dereferences all `$ref` pointers in the JSON Schema, replacing each reference with its resolved value. This results in a schema object that does not contain any `$ref` pointers. Instead, it's a normal JavaScript object tree that can easily be crawled and used just like any other JavaScript object. This is great for programmatic usage, especially when using tools that don't understand JSON references.
@@ -424,4 +424,5 @@ declare namespace $RefParser {
   }
   export class UnmatchedResolverError extends GenericError {}
   export class MissingPointerError extends GenericError {}
+  export class InvalidPointerError extends GenericError {}
 }

lib/index.js

@@ -8,13 +8,14 @@ const resolveExternal = require("./resolve-external");
 const bundle = require("./bundle");
 const dereference = require("./dereference");
 const url = require("./util/url");
-const { GenericError, MissingPointerError, ResolverError, ParserError, UnmatchedParserError, UnmatchedResolverError, isHandledError } = require("./util/errors");
+const { GenericError, InvalidPointerError, MissingPointerError, ResolverError, ParserError, UnmatchedParserError, UnmatchedResolverError, isHandledError } = require("./util/errors");
 const maybe = require("call-me-maybe");
 const { ono } = require("ono");
 
 module.exports = $RefParser;
 module.exports.YAML = require("./util/yaml");
 module.exports.GenericError = GenericError;
+module.exports.InvalidPointerError = InvalidPointerError;
 module.exports.MissingPointerError = MissingPointerError;
 module.exports.ResolverError = ResolverError;
 module.exports.ParserError = ParserError;

lib/pointer.js

@@ -4,7 +4,7 @@ module.exports = Pointer;
 
 const $Ref = require("./ref");
 const url = require("./util/url");
-const { GenericError, MissingPointerError, isHandledError } = require("./util/errors");
+const { GenericError, InvalidPointerError, MissingPointerError, isHandledError } = require("./util/errors");
 const slashes = /\//g;
 const tildes = /~/g;
 const escapedSlash = /~1/g;
@@ -72,7 +72,7 @@ function Pointer ($ref, path, friendlyPath) {
  * of the resolved value.
  */
 Pointer.prototype.resolve = function (obj, options) {
-  let tokens = Pointer.parse(this.path);
+  let tokens = Pointer.parse(this.path, this.originalPath);
 
   // Crawl the object, one token at a time
   this.value = unwrapOrThrow(obj);
@@ -153,9 +153,10 @@ Pointer.prototype.set = function (obj, value, options) {
  * {@link https://tools.ietf.org/html/rfc6901#section-3}
  *
  * @param {string} path
+ * @param {string} [originalPath]
  * @returns {string[]}
  */
-Pointer.parse = function (path) {
+Pointer.parse = function (path, originalPath) {
   // Get the JSON pointer from the path's hash
   let pointer = url.getHash(path).substr(1);
 
@@ -174,7 +175,7 @@ Pointer.parse = function (path) {
   }
 
   if (pointer[0] !== "") {
-    throw new GenericError(`Invalid $ref pointer "${pointer}". Pointers must begin with "#/"`);
+    throw new InvalidPointerError(pointer, originalPath === undefined ? path : originalPath);
   }
 
   return pointer.slice(1);

lib/util/errors.js

@@ -111,6 +111,14 @@ const MissingPointerError = exports.MissingPointerError = class MissingPointerEr
 
 setErrorName(MissingPointerError);
 
+const InvalidPointerError = exports.InvalidPointerError = class InvalidPointerError extends GenericError {
+  constructor (pointer, path) {
+    super(`Invalid $ref pointer "${pointer}". Pointers must begin with "#/"`, stripHash(path));
+  }
+};
+
+setErrorName(InvalidPointerError);
+
 function setErrorName (err) {
   Object.defineProperty(err.prototype, "name", {
     value: err.name,

test/specs/invalid-pointers/invalid-pointers.js

@@ -0,0 +1,37 @@
+"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 path = require("../../utils/path");
+const { InvalidPointerError } = require("../../../lib/util/errors");
+
+describe("Schema with invalid pointers", () => {
+  it("should throw an error for invalid pointer", async () => {
+    try {
+      await $RefParser.dereference(path.rel("specs/invalid-pointers/invalid.json"));
+      helper.shouldNotGetCalled();
+    }
+    catch (err) {
+      expect(err).to.be.an.instanceOf(InvalidPointerError);
+      expect(err.message).to.contain("Invalid $ref pointer \"f\". Pointers must begin with \"#/\"");
+    }
+  });
+
+  it("should not throw an error for invalid pointer if failFast is false", async () => {
+    const parser = new $RefParser();
+    const result = await parser.dereference(path.rel("specs/invalid-pointers/invalid.json"), { failFast: false });
+    expect(result).to.deep.equal({ foo: null });
+    expect(parser.errors).to.containSubset([
+      {
+        name: InvalidPointerError.name,
+        message: "Invalid $ref pointer \"f\". Pointers must begin with \"#/\"",
+        path: ["foo"],
+        source: path.abs("specs/invalid-pointers/invalid.json"),
+      }
+    ]);
+  });
+});

test/specs/invalid-pointers/invalid.json

@@ -0,0 +1,5 @@
+{
+  "foo": {
+    "$ref": "./invalid.json#f"
+  }
+}