Allow no parser or resolver to be matched

P0lip · P0lip · commit c482edd307e5 · 2020-02-24T02:36:30.000+08:00
diff --git a/lib/index.d.ts b/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>;
+  errors: Array<$RefParser.GenericError | $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.
@@ -418,8 +418,10 @@ declare namespace $RefParser {
   }
 
   export class ParserError extends GenericError {}
+  export class UnmatchedParserError extends GenericError {}
   export class ResolverError extends GenericError {
     readonly code?: string;
   }
+  export class UnmatchedResolverError extends GenericError {}
   export class MissingPointerError extends GenericError {}
 }
diff --git a/lib/index.js b/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 { GenericError, MissingPointerError, ResolverError, ParserError, isHandledError } = require("./util/errors");
+const { GenericError, MissingPointerError, ResolverError, ParserError, UnmatchedParserError, UnmatchedResolverError, isHandledError } = require("./util/errors");
 const maybe = require("call-me-maybe");
 const { ono } = require("ono");
 
@@ -18,6 +18,8 @@ module.exports.GenericError = GenericError;
 module.exports.MissingPointerError = MissingPointerError;
 module.exports.ResolverError = ResolverError;
 module.exports.ParserError = ParserError;
+module.exports.UnmatchedParserError = UnmatchedParserError;
+module.exports.UnmatchedResolverError = UnmatchedResolverError;
 
 /**
  * This class parses a JSON schema, builds a map of its JSON references and their resolved values,
@@ -45,7 +47,7 @@ function $RefParser () {
 
 /**
  * List of all errors
- * @type {Array<GenericError | ResolverError | ParserError | MissingPointerError>}
+ * @type {Array<GenericError | ResolverError | ParserError | MissingPointerError | UnmatchedResolverError | UnmatchedResolverError>}
  */
 Object.defineProperty($RefParser.prototype, "errors", {
   get () {
diff --git a/lib/parse.js b/lib/parse.js
@@ -3,7 +3,7 @@
 const { ono } = require("ono");
 const url = require("./util/url");
 const plugins = require("./util/plugins");
-const { StoplightParserError, ResolverError, ParserError } = require("./util/errors");
+const { StoplightParserError, ResolverError, ParserError, UnmatchedParserError, UnmatchedResolverError, isHandledError } = require("./util/errors");
 
 module.exports = parse;
 
@@ -42,14 +42,12 @@ async function parse (path, $refs, options) {
 
     return parser.result;
   }
-  catch (ex) {
-    if (!("error" in ex)) {
-      throw ex;
-    }
-    else {
-      $ref.value = ex.error;
-      throw ex.error;
+  catch (err) {
+    if (isHandledError(err)) {
+      $ref.value = err;
     }
+
+    throw err;
   }
 }
 
@@ -78,17 +76,20 @@ function readFile (file, options, $refs) {
       .then(resolve, onError);
 
     function onError (err) {
-      // Throw the original error, if it's one of our own (user-friendly) errors.
-      // Otherwise, throw a generic, friendly error.
-      if (!err || !(err instanceof SyntaxError)) {
+      if (!err && !options.failFast) {
+        // No resolver could be matched
+        reject(new UnmatchedResolverError(file.url));
+      }
+      else if (!err || !("error" in err)) {
+        // Throw a generic, friendly error.
         reject(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 ResolverError) {
-        reject(err);
+        reject(err.error);
       }
       else {
-        err.error = new ResolverError(err, file.url);
-        reject(err);
+        reject(new ResolverError(err, file.url));
       }
     }
   }));
@@ -132,15 +133,18 @@ function parseFile (file, options, $refs) {
     }
 
     function onError (err) {
-      if (!err || !("error" in err)) {
+      if (!err && !options.failFast) {
+        // No resolver could be matched
+        reject(new UnmatchedParserError(file.url));
+      }
+      else if (!err || !("error" in err)) {
         reject(ono.syntax(`Unable to parse ${file.url}`));
       }
       else if (err.error instanceof ParserError || err.error instanceof StoplightParserError) {
-        reject(err);
+        reject(err.error);
       }
       else {
-        err.error = new ParserError(err.error.message, file.url);
-        reject(err);
+        reject(new ParserError(err.error.message, file.url));
       }
     }
   }));
diff --git a/lib/util/errors.js b/lib/util/errors.js
@@ -76,9 +76,17 @@ const ParserError = exports.ParserError = class ParserError extends GenericError
 
 setErrorName(ParserError);
 
+const UnmatchedParserError = exports.UnmatchedParserError = class UnmatchedParserError extends GenericError {
+  constructor (source) {
+    super(`Could not find parser for "${source}"`, source);
+  }
+};
+
+setErrorName(UnmatchedParserError);
+
 const ResolverError = exports.ResolverError = class ResolverError extends GenericError {
   constructor (ex, source) {
-    super(ex.message || `Error reading file ${source}`, source);
+    super(ex.message || `Error reading file "${source}"`, source);
     if ("code" in ex) {
       this.code = String(ex.code);
     }
@@ -87,6 +95,14 @@ const ResolverError = exports.ResolverError = class ResolverError extends Generi
 
 setErrorName(ResolverError);
 
+const UnmatchedResolverError = exports.UnmatchedResolverError = class UnmatchedResolverError extends GenericError {
+  constructor (source) {
+    super(`Could not find resolver for "${source}"`, source);
+  }
+};
+
+setErrorName(UnmatchedResolverError);
+
 const MissingPointerError = exports.MissingPointerError = class MissingPointerError extends GenericError {
   constructor (token, path) {
     super(`Token "${token}" does not exist.`, stripHash(path));
diff --git a/test/specs/parsers/parsers.spec.js b/test/specs/parsers/parsers.spec.js
@@ -6,7 +6,7 @@ const helper = require("../../utils/helper");
 const path = require("../../utils/path");
 const parsedSchema = require("./parsed");
 const dereferencedSchema = require("./dereferenced");
-const { StoplightParserError, ParserError } = require("../../../lib/util/errors");
+const { StoplightParserError, ParserError, UnmatchedParserError } = require("../../../lib/util/errors");
 
 describe("References to non-JSON files", () => {
   it("should parse successfully", async () => {
@@ -65,6 +65,24 @@ describe("References to non-JSON files", () => {
     expect(schema).to.deep.equal(dereferencedSchema.binaryParser);
   });
 
+  it("should throw an error if no no parser can be matched", async () => {
+    try {
+      await $RefParser.dereference(path.rel("specs/parsers/parsers.yaml"), {
+        parse: {
+          yaml: false,
+          json: false,
+          text: false,
+          binary: false,
+        },
+      });
+    }
+    catch (err) {
+      expect(err).to.be.an.instanceOf(SyntaxError);
+      expect(err.message).to.contain("Unable to parse ");
+      expect(err.message).to.contain("parsers/parsers.yaml");
+    }
+  });
+
   it('should throw an error if "parse.text" and "parse.binary" are disabled', async () => {
     try {
       await $RefParser.dereference(path.rel("specs/parsers/parsers.yaml"), { parse: { text: false, binary: false }});
@@ -184,4 +202,27 @@ describe("References to non-JSON files", () => {
       expect(err.message).to.contain("arsers/parsers.yaml: Woops");
     }
   });
+
+  it("should let no parser to be matched if fastFail is false", async () => {
+    const parser = new $RefParser();
+    await parser.dereference(path.rel("specs/parsers/parsers.yaml"), {
+      parse: {
+        yaml: false,
+        json: false,
+        text: false,
+        binary: false,
+      },
+      failFast: false,
+    });
+
+    expect(parser.errors.length).to.equal(1);
+    expect(parser.errors).to.containSubset([
+      {
+        name: UnmatchedParserError.name,
+        message: expectedValue => expectedValue.startsWith("Could not find parser for"),
+        path: [],
+        source: expectedValue => expectedValue.endsWith("specs/parsers/parsers.yaml"),
+      },
+    ]);
+  });
 });
diff --git a/test/specs/resolvers/resolvers.spec.js b/test/specs/resolvers/resolvers.spec.js
@@ -1,12 +1,15 @@
 "use strict";
 
-const { expect } = require("chai");
+const chai = require("chai");
+const chaiSubset = require("chai-subset");
+chai.use(chaiSubset);
+const { expect } = chai;
 const $RefParser = require("../../..");
 const helper = require("../../utils/helper");
 const path = require("../../utils/path");
 const parsedSchema = require("./parsed");
 const dereferencedSchema = require("./dereferenced");
-const { ResolverError } = require("../../../lib/util/errors");
+const { ResolverError, UnmatchedResolverError } = require("../../../lib/util/errors");
 
 describe("options.resolve", () => {
   it('should not resolve external links if "resolve.external" is disabled', async () => {
@@ -133,4 +136,25 @@ describe("options.resolve", () => {
       expect(err.message).to.contain("Error opening file");
     }
   });
+
+  it("should let no resolver to be matched if fastFail is false", async () => {
+    const parser = new $RefParser();
+    await parser.dereference(path.abs("specs/resolvers/resolvers.yaml"), {
+      resolve: {
+        file: false,
+        http: false,
+      },
+      failFast: false,
+    });
+
+    expect(parser.errors.length).to.equal(1);
+    expect(parser.errors).to.containSubset([
+      {
+        name: UnmatchedResolverError.name,
+        message: expectedValue => expectedValue.startsWith("Could not find resolver for"),
+        path: [],
+        source: expectedValue => expectedValue.endsWith("specs/resolvers/resolvers.yaml"),
+      },
+    ]);
+  });
 });

Original file line number	Diff line number	Diff line change
`@@ -30,7 +30,7 @@ declare class $RefParser {`
`30`	`30`	`*`
`31`	`31`	`* See https://github.com/APIDevTools/json-schema-ref-parser/blob/master/docs/ref-parser.md#errors`
`32`	`32`	`*/`
`33`		`- errors: Array<$RefParser.GenericError \| $RefParser.ResolverError \| $RefParser.ParserError \| $RefParser.MissingPointerError>;`
	`33`	`+ errors: Array<$RefParser.GenericError \| $RefParser.ResolverError \| $RefParser.ParserError \| $RefParser.MissingPointerError \| $RefParser.UnmatchedParserError \| $RefParser.UnmatchedResolverError>;`
`34`	`34`
`35`	`35`	`/**`
`36`	`36`	* 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.
`@@ -418,8 +418,10 @@ declare namespace $RefParser {`
`418`	`418`	`}`
`419`	`419`
`420`	`420`	`export class ParserError extends GenericError {}`
	`421`	`+ export class UnmatchedParserError extends GenericError {}`
`421`	`422`	`export class ResolverError extends GenericError {`
`422`	`423`	`readonly code?: string;`
`423`	`424`	`}`
	`425`	`+ export class UnmatchedResolverError extends GenericError {}`
`424`	`426`	`export class MissingPointerError extends GenericError {}`
`425`	`427`	`}`