feat: implement resolveInlineRef util (#68)

* feat: implement resolveInlineRef util

* fix: circular detection was screwed

* chore: tweak

Author: P0lip

src/__tests__/resolveInlineRef.spec.ts

@@ -0,0 +1,131 @@
+import { resolveInlineRef } from '../resolveInlineRef';
+
+describe('resolveInlineRef', () => {
+  test('should follow refs', () => {
+    const doc = {
+      a: {
+        $ref: '#/b/foo',
+      },
+      b: {
+        $ref: '#/c',
+      },
+      c: {
+        $ref: '#/d',
+      },
+      d: {
+        foo: 'woo!',
+      },
+    };
+
+    expect(resolveInlineRef(doc, '#/a')).toEqual('woo!');
+  });
+
+  test('should follow refs #2', () => {
+    const doc = {
+      a: {
+        $ref: '#/b/foo',
+      },
+      b: {
+        foo: {
+          $ref: '#/c',
+        },
+        bar: {
+          $ref: '#/e',
+        },
+      },
+      c: {
+        $ref: '#/b/bar',
+      },
+      e: 'woo!',
+    };
+
+    expect(resolveInlineRef(doc, '#/a')).toEqual('woo!');
+  });
+
+  test('should handle direct circular refs', () => {
+    const doc = {
+      a: {
+        $ref: '#/b',
+      },
+      b: {
+        $ref: '#/a',
+      },
+    };
+
+    expect(resolveInlineRef(doc, '#/a')).toEqual({
+      $ref: '#/a',
+    });
+  });
+
+  test('should handle direct circular refs #2', () => {
+    const doc = {
+      a: {
+        $ref: '#/b/foo',
+      },
+      b: {
+        foo: {
+          $ref: '#/c',
+        },
+        bar: {
+          $ref: '#/e',
+        },
+      },
+      c: {
+        $ref: '#/b/bar',
+      },
+      e: {
+        $ref: '#/a',
+      },
+    };
+
+    expect(resolveInlineRef(doc, '#/a')).toEqual({
+      $ref: '#/a',
+    });
+  });
+
+  test('given external reference, should throw', () => {
+    const doc = {
+      a: {
+        $ref: './foo#/b/foo',
+      },
+    };
+
+    expect(resolveInlineRef.bind(null, doc, '#/a')).toThrowError('Cannot resolve external references');
+  });
+
+  test('given missing segment, should throw', () => {
+    const doc = {
+      a: {
+        $ref: '#/b/foo',
+      },
+      b: {
+        bar: false,
+      },
+    };
+
+    expect(resolveInlineRef.bind(null, doc, '#/a')).toThrowError("Could not resolve '#/b/foo'");
+  });
+
+  test('given path pointing at invalid data, should throw', () => {
+    const doc = {
+      a: {
+        $ref: '#/b/foo/bar',
+      },
+      b: {
+        foo: null,
+      },
+    };
+
+    expect(resolveInlineRef.bind(null, doc, '#/a')).toThrowError("Could not resolve '#/b/foo/bar'");
+  });
+
+  test('given invalid $ref type, should throw', () => {
+    const doc = {
+      a: {
+        $ref: 2,
+      },
+    };
+
+    expect(resolveInlineRef.bind(null, doc, '#/a')).toThrowError('$ref should be a string');
+  });
+});

src/index.ts

@@ -15,6 +15,7 @@ export * from './parseWithPointers';
 export * from './pathToPointer';
 export * from './pointerToPath';
 export * from './renameObjectKey';
+export * from './resolveInlineRef';
 export * from './safeParse';
 export * from './safeStringify';
 export * from './startsWith';

src/resolveInlineRef.ts

@@ -0,0 +1,45 @@
+import { Dictionary } from '@stoplight/types';
+import { extractSourceFromRef } from './extractSourceFromRef';
+import { pointerToPath } from './pointerToPath';
+
+function isObject(maybeObj: unknown): maybeObj is { [key in PropertyKey]: unknown } {
+  return typeof maybeObj === 'object' && maybeObj !== null;
+}
+
+function _resolveInlineRef(document: Dictionary<unknown>, ref: string, seen: unknown[]): unknown {
+  const source = extractSourceFromRef(ref);
+  if (source !== null) {
+    throw new ReferenceError('Cannot resolve external references');
+  }
+
+  const path = pointerToPath(ref);
+  let value: unknown = document;
+  for (const segment of path) {
+    if (!isObject(value) || !(segment in value)) {
+      throw new ReferenceError(`Could not resolve '${ref}'`);
+    }
+
+    value = value[segment];
+
+    if (isObject(value) && '$ref' in value) {
+      if (seen.includes(value)) {
+        // circular, let's stop
+        return seen[seen.length - 1];
+      }
+
+      seen.push(value);
+
+      if (typeof value.$ref !== 'string') {
+        throw new TypeError('$ref should be a string');
+      }
+
+      value = _resolveInlineRef(document, value.$ref, seen);
+    }
+  }
+
+  return value;
+}
+
+export function resolveInlineRef(document: Dictionary<unknown>, ref: string): unknown {
+  return _resolveInlineRef(document, ref, []);
+}