Always fail

Author: P0lip

docs/ref-parser.md

@@ -6,7 +6,6 @@ This is the default export of JSON Schema $Ref Parser.  You can creates instance
 ##### Properties
 - [`schema`](#schema)
 - [`$refs`](#refs)
-- [`errors`](#errors)
 
 ##### Methods
 - [`dereference()`](#dereferenceschema-options-callback)
@@ -43,13 +42,6 @@ await parser.dereference("my-schema.json");
 parser.$refs.paths();       // => ["my-schema.json"]
 ```
 
-### `errors`
-The `errors` property contains all list of errors that occurred during the bundling/resolving/dereferencing process.
-All errors share error properties:
-- path - json path to the document property
-- message
-- source - the uri of document where the faulty document was referenced
-
 
 ### `dereference(schema, [options], [callback])`
 

lib/index.d.ts

@@ -25,13 +25,6 @@ declare class $RefParser {
    */
   $refs: $RefParser.$Refs
 
-  /**
-   * List of all errors
-   *
-   * See https://github.com/APIDevTools/json-schema-ref-parser/blob/master/docs/ref-parser.md#errors
-   */
-  errors: Array<$RefParser.JSONParserError | $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.
    *
@@ -417,10 +410,31 @@ declare namespace $RefParser {
     readonly name: string;
     readonly message: string;
     readonly path: Array<string | number>;
-    readonly source: string;
+    readonly errors: string;
     readonly code: JSONParserErrorType;
   }
 
+  export class JSONParserErrorGroup extends Error {
+    /**
+     * List of all errors
+     *
+     * See https://github.com/APIDevTools/json-schema-ref-parser/blob/master/docs/ref-parser.md#errors
+     */
+    readonly errors: Array<$RefParser.JSONParserError | $RefParser.InvalidPointerError | $RefParser.ResolverError | $RefParser.ParserError | $RefParser.MissingPointerError | $RefParser.UnmatchedParserError | $RefParser.UnmatchedResolverError>;
+
+    /**
+     * The fields property is a `$RefParser` instance
+     *
+     * See https://apitools.dev/json-schema-ref-parser/docs/ref-parser.html
+     */
+    readonly files: $RefParser;
+
+    /**
+     * User friendly message containing the total amount of errors, as well as the absolute path to the source document
+     */
+    readonly message: string;
+  }
+
   export class ParserError extends JSONParserError {
     readonly name = "ParserError";
     readonly code = "EPARSER";

lib/index.js

@@ -8,7 +8,7 @@ const resolveExternal = require("./resolve-external");
 const bundle = require("./bundle");
 const dereference = require("./dereference");
 const url = require("./util/url");
-const { JSONParserError, InvalidPointerError, MissingPointerError, ResolverError, ParserError, UnmatchedParserError, UnmatchedResolverError, isHandledError } = require("./util/errors");
+const { JSONParserError, InvalidPointerError, MissingPointerError, ResolverError, ParserError, UnmatchedParserError, UnmatchedResolverError, isHandledError, JSONParserErrorGroup } = require("./util/errors");
 const maybe = require("call-me-maybe");
 const { ono } = require("@jsdevtools/ono");
 
@@ -46,25 +46,6 @@ function $RefParser () {
   this.$refs = new $Refs();
 }
 
-/**
- * List of all errors
- * @type {Array<JSONParserError | ResolverError | ParserError | MissingPointerError | UnmatchedResolverError | UnmatchedResolverError>}
- */
-Object.defineProperty($RefParser.prototype, "errors", {
-  get () {
-    const errors = [];
-
-    for (const $ref of Object.values(this.$refs._$refs)) {
-      if ($ref.errors) {
-        errors.push(...$ref.errors);
-      }
-    }
-
-    return errors;
-  },
-  enumerable: true,
-});
-
 /**
  * Parses the given JSON schema.
  * This method does not resolve any JSON references.
@@ -202,6 +183,7 @@ $RefParser.prototype.resolve = async function (path, schema, options, callback)
   try {
     await this.parse(args.path, args.schema, args.options);
     await resolveExternal(me, args.options);
+    finalize(me);
     return maybe(args.callback, Promise.resolve(me.$refs));
   }
   catch (err) {
@@ -244,6 +226,7 @@ $RefParser.prototype.bundle = async function (path, schema, options, callback) {
   try {
     await this.resolve(args.path, args.schema, args.options);
     bundle(me, args.options);
+    finalize(me);
     return maybe(args.callback, Promise.resolve(me.schema));
   }
   catch (err) {
@@ -284,9 +267,17 @@ $RefParser.prototype.dereference = async function (path, schema, options, callba
   try {
     await this.resolve(args.path, args.schema, args.options);
     dereference(me, args.options);
+    finalize(me);
     return maybe(args.callback, Promise.resolve(me.schema));
   }
   catch (err) {
     return maybe(args.callback, Promise.reject(err));
   }
 };
+
+function finalize (parser) {
+  const errors = JSONParserErrorGroup.getParserErrors(parser);
+  if (errors.length > 0) {
+    throw new JSONParserErrorGroup(parser);
+  }
+}

lib/util/errors.js

@@ -2,7 +2,7 @@
 
 const { Ono } = require("@jsdevtools/ono");
 
-const { stripHash } = require("./url");
+const { stripHash, toFileSystemPath } = require("./url");
 
 const JSONParserError = exports.JSONParserError = class JSONParserError extends Error {
   constructor (message, source) {
@@ -20,52 +20,47 @@ const JSONParserError = exports.JSONParserError = class JSONParserError extends
 setErrorName(JSONParserError);
 
 const JSONParserErrorGroup = exports.JSONParserErrorGroup = class JSONParserErrorGroup extends Error {
-  constructor (errors, source) {
+  constructor (parser) {
     super();
 
-    this.code = "EUNKNOWN";
-    this._path = undefined;
-    this._source = source;
-    this.errors = errors;
+    this.files = parser;
+    this.message = `${this.errors.length} error${this.errors.length > 1 ? "s" : ""} occurred while reading '${toFileSystemPath(parser.$refs._root$Ref.path)}'`;
 
     Ono.extend(this);
   }
 
-  get source () {
-    return this._source;
-  }
-
-  set source (source) {
-    this._source = source;
+  static getParserErrors (parser) {
+    const errors = [];
 
-    for (let error of this.errors) {
-      error.source = source;
+    for (const $ref of Object.values(parser.$refs._$refs)) {
+      if ($ref.errors) {
+        errors.push(...$ref.errors);
+      }
     }
-  }
 
-  get path () {
-    return this.path;
+    return errors;
   }
 
-  set path (path) {
-    this._path = path;
-
-    for (let error of this.errors) {
-      error.path = path;
-    }
+  get errors () {
+    return JSONParserErrorGroup.getParserErrors(this.files);
   }
 };
 
-exports.StoplightParserError = class StoplightParserError extends JSONParserErrorGroup {
+setErrorName(JSONParserErrorGroup);
+
+exports.StoplightParserError = class StoplightParserError extends JSONParserError {
   constructor (diagnostics, source) {
-    super(diagnostics.filter(StoplightParserError.pickError).map(error => {
+    super(`Error parsing ${source}`, source);
+
+    this.code = "ESTOPLIGHTPARSER";
+
+    this._source = source;
+    this._path = [];
+    this.errors = diagnostics.filter(StoplightParserError.pickError).map(error => {
       let parserError = new ParserError(error.message, source);
       parserError.message = error.message;
       return parserError;
-    }));
-
-    this.code = "ESTOPLIGHTPARSER";
-    this.message = `Error parsing ${source}`;
+    });
   }
 
   static pickError (diagnostic) {
@@ -75,6 +70,34 @@ exports.StoplightParserError = class StoplightParserError extends JSONParserErro
   static hasErrors (diagnostics) {
     return diagnostics.some(StoplightParserError.pickError);
   }
+
+  get source () {
+    return this._source;
+  }
+
+  set source (source) {
+    this._source = source;
+
+    if (this.errors) {
+      for (let error of this.errors) {
+        error.source = source;
+      }
+    }
+  }
+
+  get path () {
+    return this._path;
+  }
+
+  set path (path) {
+    this._path = path;
+
+    if (this.errors) {
+      for (let error of this.errors) {
+        error.path = path;
+      }
+    }
+  }
 };
 
 const ParserError = exports.ParserError = class ParserError extends JSONParserError {

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

@@ -7,10 +7,10 @@ const { expect } = chai;
 const $RefParser = require("../../../lib");
 const helper = require("../../utils/helper");
 const path = require("../../utils/path");
-const { InvalidPointerError } = require("../../../lib/util/errors");
+const { JSONParserErrorGroup, InvalidPointerError } = require("../../../lib/util/errors");
 
 describe("Schema with invalid pointers", () => {
-  it("should throw an error for invalid pointer", async () => {
+  it("should throw an error for an invalid pointer", async () => {
     try {
       await $RefParser.dereference(path.rel("specs/invalid-pointers/invalid.json"));
       helper.shouldNotGetCalled();
@@ -21,17 +21,24 @@ describe("Schema with invalid pointers", () => {
     }
   });
 
-  it("should not throw an error for invalid pointer if failFast is false", async () => {
+  it("should throw a grouped error for an 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"),
-      }
-    ]);
+    try {
+      await parser.dereference(path.rel("specs/invalid-pointers/invalid.json"), { failFast: false });
+      helper.shouldNotGetCalled();
+    }
+    catch (err) {
+      expect(err).to.be.instanceof(JSONParserErrorGroup);
+      expect(err.files).to.equal(parser);
+      expect(err.message).to.equal(`1 error occurred while reading '${path.abs("specs/invalid-pointers/invalid.json")}'`);
+      expect(err.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"),
+        }
+      ]);
+    }
   });
 });