fix: resolve root inline JSON pointers

src/__tests__/fixtures/schemas/circular-root-reference.json

@@ -0,0 +1,14 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "": {
+    "type": "string"
+  },
+  "anyOf": [
+    {
+      "$ref": "#"
+    },
+    {
+      "$ref": "#/"
+    }
+  ]
+}

src/__tests__/resolver.spec.ts

@@ -1132,6 +1132,45 @@ describe('resolver', () => {
         ],
       });
     });
+
+    test('should handle circular local root reference', async () => {
+      const resolver = new Resolver({
+        resolvers: {
+          file: new FileReader(),
+        },
+      });
+      const docUri = join(__dirname, './fixtures/schemas/circular-root-reference.json');
+      const resolved = await resolver.resolve(JSON.parse(fs.readFileSync(docUri, 'utf8')), {
+        baseUri: docUri,
+      });
+
+      expect(resolved.errors).toEqual([]);
+      expect(resolved.result).toStrictEqual({
+        $schema: 'http://json-schema.org/draft-07/schema#',
+        '': {
+          type: 'string',
+        },
+        anyOf: [
+          {
+            $schema: 'http://json-schema.org/draft-07/schema#',
+            '': {
+              type: 'string',
+            },
+            anyOf: [
+              {
+                $ref: '#',
+              },
+              {
+                $ref: '#/',
+              },
+            ],
+          },
+          {
+            type: 'string',
+          },
+        ],
+      });
+    });
   });
 
   describe('cache', () => {

src/crawler.ts

@@ -101,7 +101,7 @@ export class ResolveCrawler implements Types.ICrawler {
          * Protects against circular references back to something higher up in the tree
          * Will stop #/definitions/columns/rows -> #/definitions/columns
          */
-        let referencesParent = true;
+        let referencesParent = targetPath.length > 0;
         for (const i in targetPath) {
           if (parentPath[i] !== targetPath[i]) {
             referencesParent = false;

src/runner.ts

@@ -221,7 +221,7 @@ export class ResolveRunner implements Types.IResolveRunner {
               if (!dependants.length) continue;
 
               const pointerPath = pointerToPath(pointer);
-              const val = get(draft, pointerPath);
+              const val = pointerPath.length === 0 ? original(draft) : get(draft, pointerPath);
               for (const dependant of dependants) {
                 // check to prevent circular references in the resulting JS object
                 // this implementation is MUCH more performant than decycling the final object to remove circulars
@@ -323,7 +323,7 @@ export class ResolveRunner implements Types.IResolveRunner {
     let ref = new URI(refStr);
 
     // Does ref only have a fragment
-    if (ref.toString().charAt(0) !== '#') {
+    if (refStr[0] !== '#') {
       const isFile = this.isFile(ref);
 
       // if we're working with a file, resolve any path diferences and make sure the scheme is set
@@ -426,7 +426,7 @@ export class ResolveRunner implements Types.IResolveRunner {
     const { val, ref, resolvingPointer, parentPointer, pointerStack } = opts;
 
     // slice to make a fresh copy since we mutate in crawler for performance
-    const parentPath = (opts.parentPath || []).slice();
+    const parentPath = opts.parentPath ? opts.parentPath.slice() : [];
 
     const uriCacheKey = this.computeUriCacheKey(ref);
     const lookupResult: Types.IUriResult = {

src/utils.ts

@@ -32,10 +32,10 @@ export const addToJSONPointer = (pointer: string, part: string): string => {
 
 /** @hidden */
 export const uriToJSONPointer = (uri: uri.URI): string => {
-  return uri && uri.fragment() ? `#${uri.fragment()}` : '';
+  return uri.fragment() ? `#${uri.fragment()}` : '#';
 };
 
 /** @hidden */
 export const uriIsJSONPointer = (ref: uri.URI): boolean => {
-  return ref.toString().slice(0, 2) === '#/';
+  return ref.path() === '';
 };