feat: handle hash fragment of json pointers

Author: BelfordZ

src/index.test.ts

@@ -87,3 +87,37 @@ describe("referenceResolver", () => {
     }
   });
 });
+
+
+describe("refs with hash fragment / internal reference component", () => {
+  it("works with file paths", async () => {
+    expect(await referenceResolver("./src/test-obj.json#/type", {})).toBe("string");
+  });
+
+  describe("urls", () => {
+    it("works with forward slashes surrounding the hash", async () => {
+      expect(await referenceResolver("https://meta.open-rpc.org/#/type", {})).toBe("object");
+    });
+    it("works without slash infront of hash, but with one after", async () => {
+      expect(await referenceResolver("https://meta.open-rpc.org#/type", {})).toBe("object");
+    });
+
+    it("errors when the json pointer is invalid", async () => {
+      expect.assertions(1);
+      try {
+        await referenceResolver("https://meta.open-rpc.org/#type", {});
+      } catch (e) {
+        expect(e).toBeInstanceOf(InvalidRemoteURLError);
+      }
+    });
+
+    it("errors when you have 2 hash fragments in 1 ref", async () => {
+      expect.assertions(1);
+      try {
+        await referenceResolver("https://meta.open-rpc.org/#properties/#openrpc", {});
+      } catch (e) {
+        expect(e).toBeInstanceOf(InvalidRemoteURLError);
+      }
+    });
+  });
+});

src/reference-resolver.ts

@@ -136,22 +136,55 @@ export default (fetch: any, fs: any) => {
       }
     }
 
-    if (await fileExistsAndReadable(ref) === true) {
-      const fileContents = await readFile(ref);
+    // copy hash fragment from the filepath / url
+    const hashFragmentSplit = ref.split("#");
+    let hashFragment;
+    if (hashFragmentSplit.length > 1) {
+      hashFragment = hashFragmentSplit[hashFragmentSplit.length - 1];
+    }
+
+    let hashlessRef = ref;
+    if (hashFragment) {
+      hashlessRef = ref.replace(`#${hashFragment}`, "");
+    }
+
+    if (await fileExistsAndReadable(hashlessRef) === true) {
+      // pull off the hash fragment first
+      const fileContents = await readFile(hashlessRef);
       let reffedSchema;
       try {
         reffedSchema = JSON.parse(fileContents);
       } catch (e) {
         throw new NonJsonRefError({ $ref: ref }, fileContents);
       }
 
+      if (hashFragment) {
+        try {
+          const pointer = Ptr.parse(hashFragment);
+          return Promise.resolve(pointer.eval(reffedSchema));
+        } catch (e) {
+          throw new InvalidJsonPointerRefError({ $ref: ref });
+        }
+      }
+
       return reffedSchema;
     } else if (isUrlLike(ref) === false) {
       throw new InvalidFileSystemPathError(ref);
     }
 
     try {
-      return await fetch(ref).then((r: any) => r.json());
+      // leave the hash fragment on
+      // but evaluate the result after
+      const result = await fetch(ref).then((r: any) => r.json());
+      if (hashFragment) {
+        try {
+          const pointer = Ptr.parse(hashFragment);
+          return Promise.resolve(pointer.eval(result));
+        } catch (e) {
+          throw new InvalidJsonPointerRefError({ $ref: ref });
+        }
+      }
+      return result;
     } catch (e) {
       throw new InvalidRemoteURLError(ref);
     }