feat: expose an option to support custom resolver resolution.

This feature exposes two separate entry points for creating a resolver,
one using the makeCustomResolver() option and another for advanced
users that want more or need more control over the resolution process,
which allows users to extend the resolver class if needed.

fixes #587

Author: zcstarr

src/parse-open-rpc-document.test.ts

@@ -4,12 +4,13 @@ jest.mock("fs-extra", () => ({
 }));
 
 import * as _fs from "fs-extra";
-import makeParseOpenRPCDocument from "./parse-open-rpc-document";
+import makeParseOpenRPCDocument, { makeCustomResolver } from "./parse-open-rpc-document";
 import { OpenrpcDocument as OpenRPC, OpenrpcDocument } from "@open-rpc/meta-schema";
 import { OpenRPCDocumentValidationError } from "./validate-open-rpc-document";
 import fetchUrlSchema from "./get-open-rpc-document-from-url";
 import readSchemaFromFile from "./get-open-rpc-document-from-file";
 import { OpenRPCDocumentDereferencingError } from "./dereference-document";
+import { JSONSchema } from "@json-schema-tools/meta-schema";
 
 const parseOpenRPCDocument = makeParseOpenRPCDocument(fetchUrlSchema, readSchemaFromFile);
 const fs: any = _fs;
@@ -248,6 +249,35 @@ describe("parseOpenRPCDocument", () => {
       }
     });
 
+    it("should make a reference resolver", ()=> {
+      const resolver = makeCustomResolver({"file": 
+        async (): Promise<JSONSchema> => {  
+          return {}
+        }
+      });
+      expect(resolver).toBeDefined()
+    });
+
+    it("should handle dereference option true", async ()=> {
+      const document = await parseOpenRPCDocument(workingDocument,{
+        dereference: true,
+      });
+      expect(document.methods).toBeDefined();
+    });
+
+    it("should handle custom resolver option", async ()=> {
+      const resolver = makeCustomResolver({"handler": 
+        async (uri: string): Promise<JSONSchema> => {  
+          return {}
+        }
+      });
+      const document = await parseOpenRPCDocument(workingDocument,{
+        resolver
+      });
+      expect(document.methods).toBeDefined();
+
+    });
+
     it("rejects when the json provided is invalid from file", async () => {
       expect.assertions(1);
       fs.readJson.mockClear();

src/parse-open-rpc-document.ts

@@ -4,6 +4,8 @@ import defaultResolver from "@json-schema-tools/reference-resolver"
 import isUrl = require("is-url");
 import { OpenrpcDocument } from "@open-rpc/meta-schema";
 import { TGetOpenRPCDocument } from "./get-open-rpc-document";
+import ReferenceResolver, { ProtocolHandlerMap } from "@json-schema-tools/reference-resolver/build/reference-resolver";
+export { JSONSchema } from "@json-schema-tools/meta-schema";
 
 /**
  * @ignore
@@ -34,6 +36,13 @@ export interface ParseOpenRPCDocumentOptions {
    *
    */
   dereference?: boolean;
+  /*
+   * Enable custom reference resolver. This will allow people to resolve 3rd party custom reference values like for ipfs.
+   *
+   * @default defaultReferenceResolver  
+   *
+   */
+  resolver?: ReferenceResolver;
 }
 
 const defaultParseOpenRPCDocumentOptions = {
@@ -105,7 +114,11 @@ const makeParseOpenRPCDocument = (fetchUrlSchema: TGetOpenRPCDocument, readSchem
 
     let postDeref: OpenrpcDocument = parsedSchema;
     if (parseOptions.dereference) {
-      postDeref = await dereferenceDocument(parsedSchema, defaultResolver);
+      if(parseOptions.resolver !== undefined){
+        postDeref = await dereferenceDocument(parsedSchema, parseOptions.resolver);
+      } else {
+        postDeref = await dereferenceDocument(parsedSchema, defaultResolver);
+      }
     }
 
     if (parseOptions.validate) {
@@ -119,4 +132,8 @@ const makeParseOpenRPCDocument = (fetchUrlSchema: TGetOpenRPCDocument, readSchem
   };
 };
 
+export function makeCustomResolver(protocolMapHandler: ProtocolHandlerMap): ReferenceResolver{
+  return new ReferenceResolver(protocolMapHandler);
+}
+
 export default makeParseOpenRPCDocument;