Add sync version of resolveRef

.vscode/settings.json

@@ -1,3 +1,4 @@
 {
-    "editor.formatOnSave": true
+    "editor.formatOnSave": true,
+    "java.saveActions.organizeImports": false
 }

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@redneckz/json-ref",
-  "version": "0.0.4",
+  "version": "0.0.5",
   "license": "MIT",
   "author": {
     "name": "redneckz",

src/URIResolver.ts

@@ -1,3 +1,3 @@
 import type { JSONNode } from './JSONNode';
 
-export type URIResolver = (uri: string) => Promise<JSONNode> | JSONNode;
+export type URIResolver<R extends Promise<JSONNode> | JSONNode = Promise<JSONNode>> = (uri: string) => R;

src/collectRef.ts

@@ -0,0 +1,8 @@
+import { type JSONNode } from './JSONNode';
+import { visitRef } from './visitRef';
+
+export const collectRef = (json: JSONNode): string[] => {
+  const refs: string[] = [];
+  visitRef(json, _ => refs.push(_));
+  return refs;
+};

src/index.ts

@@ -1,5 +1,7 @@
 export { resolveRef } from './resolveRef';
+export { resolveRef as resolveRefSync } from './resolveRef.sync';
 export { visitRef, type RefVisitor } from './visitRef';
+export { collectRef } from './collectRef';
 
 export { resolveJPointer } from './resolveJPointer';
 

src/mapJSONNode.ts

@@ -0,0 +1,29 @@
+import {
+  isJSONArray,
+  isJSONRecord,
+  isJSONRef,
+  type JSONNode,
+  type JSONRecord,
+  type JSONRef,
+  type JSONScalar
+} from './JSONNode';
+
+export const mapJSONNode = <R extends JSONNode | Promise<JSONNode> | void>(
+  json: JSONNode,
+  handlers: {
+    ref: (json: JSONRef) => R;
+    record: (json: JSONRecord) => R;
+    array: (json: JSONNode[]) => R;
+    scalar?: (json: JSONScalar | null) => R;
+  }
+): R => {
+  if (isJSONRef(json)) {
+    return handlers.ref(json);
+  } else if (isJSONRecord(json)) {
+    return handlers.record(json);
+  } else if (isJSONArray(json)) {
+    return handlers.array(json);
+  } else {
+    return handlers.scalar ? handlers.scalar(json) : (json as R);
+  }
+};

src/mergeRecords.ts

@@ -0,0 +1,2 @@
+export const mergeRecords = <K extends string, V, R extends Record<K, V>>(entries: R[]): R =>
+  entries.reduce((acc, _) => Object.assign(acc, _), {} as R);

src/resolveRef.spec.ts

@@ -2,66 +2,46 @@ import { resolveRef } from './resolveRef';
 
 describe('resolveRef', () => {
   it('should substitute JSON addressed by URI in place of "$ref" declared inside object', async () => {
-    const constResolver = () => ({ some: { remote: 'json' } });
+    const constResolver = async () => ({ some: { remote: 'json' } });
 
     const result = await resolveRef(
       {
-        foo: {
-          bar: { $ref: 'http://some-remote.json' },
-          baz: [123]
-        }
+        foo: { bar: { $ref: 'http://some-remote.json' }, baz: [123] }
       },
       constResolver
     );
 
     expect(result).toEqual({
-      foo: {
-        bar: { some: { remote: 'json' } },
-        baz: [123]
-      }
+      foo: { bar: { some: { remote: 'json' } }, baz: [123] }
     });
   });
 
   it('should substitute JSON addressed by URI in place of "$ref" declared inside list', async () => {
-    const constResolver = () => ({ some: { remote: 'json' } });
+    const constResolver = async () => ({ some: { remote: 'json' } });
 
     const result = await resolveRef(
       {
-        foo: {
-          bar: 0,
-          baz: [123, { $ref: 'http://some-remote.json' }, 456]
-        }
+        foo: { bar: 0, baz: [123, { $ref: 'http://some-remote.json' }, 456] }
       },
       constResolver
     );
 
     expect(result).toEqual({
-      foo: {
-        bar: 0,
-        baz: [123, { some: { remote: 'json' } }, 456]
-      }
+      foo: { bar: 0, baz: [123, { some: { remote: 'json' } }, 456] }
     });
   });
 
   it('should substitute JSON addressed by URI in place of "$ref" with regard to URI fragment', async () => {
-    const constResolver = () => ({ some: { remote: 'json' } });
+    const constResolver = async () => ({ some: { remote: 'json' } });
 
     const result = await resolveRef(
       {
-        foo: {
-          bar: { $ref: 'http://some-remote.json#/some/remote' },
-          baz: [123]
-        }
+        foo: { bar: { $ref: 'http://some-remote.json#/some/remote' }, baz: [123] }
       },
       constResolver
     );
 
-    expect(result).toEqual({
-      foo: {
-        bar: 'json',
-        baz: [123]
-      }
-    });
+    expect(result).toEqual({ foo: { bar: 'json', baz: [123] } });
   });
 
   it('should "ask" URIResolver to resolve URI for each "$ref"', async () => {
@@ -84,24 +64,18 @@ describe('resolveRef', () => {
   });
 
   it('should recursively process "$ref" fields of fragments returned by URIresolver', async () => {
-    const constResolver = (uri: string) =>
+    const constResolver = async (uri: string) =>
       uri === '#some/remote/json' ? { some: { remote: { json: { $ref: '#/foo' } } } } : 'foo';
 
     const result = await resolveRef(
       {
-        foo: {
-          bar: { $ref: '#some/remote/json' },
-          baz: [123]
-        }
+        foo: { bar: { $ref: '#some/remote/json' }, baz: [123] }
       },
       constResolver
     );
 
     expect(result).toEqual({
-      foo: {
-        bar: 'foo',
-        baz: [123]
-      }
+      foo: { bar: 'foo', baz: [123] }
     });
   });
 });

src/resolveRef.sync.ts

@@ -0,0 +1,15 @@
+import { type JSONNode, type JSONRecord } from './JSONNode';
+import type { URIResolver } from './URIResolver';
+import { mapJSONNode } from './mapJSONNode';
+import { mergeRecords } from './mergeRecords';
+import { resolveJPointer } from './resolveJPointer';
+
+export const resolveRef = (json: JSONNode, resolver: URIResolver<JSONNode>): JSONNode =>
+  mapJSONNode(json, {
+    ref: ({ $ref, ...rest }) => resolveRef($ref ? resolveJPointer(resolver($ref), $ref) : rest, resolver),
+    record: record =>
+      mergeRecords(
+        Object.entries(record).map(([key, value]) => ({ [key]: resolveRef(value, resolver) } as JSONRecord))
+      ),
+    array: list => list.map(_ => resolveRef(_, resolver))
+  });

src/resolveRef.ts

@@ -1,30 +1,19 @@
-import { type JSONNode, type JSONRecord, type JSONRef, isJSONArray, isJSONRecord, isJSONRef } from './JSONNode';
+import { type JSONNode, type JSONRecord } from './JSONNode';
 import type { URIResolver } from './URIResolver';
+import { mapJSONNode } from './mapJSONNode';
+import { mergeRecords } from './mergeRecords';
 import { resolveJPointer } from './resolveJPointer';
 
-export const resolveRef = async (json: JSONNode, resolver: URIResolver): Promise<JSONNode> => {
-  if (isJSONRef(json)) {
-    return mapJSONRef(json, resolver);
-  } else if (isJSONRecord(json)) {
-    return mapJSONRecord(json, resolver);
-  } else if (isJSONArray(json)) {
-    return mapJSONArray(json, resolver);
-  } else {
-    return json;
-  }
-};
-
-const mapJSONArray = async (list: JSONNode[], resolver: URIResolver): Promise<JSONNode[]> =>
-  Promise.all(list.map(_ => resolveRef(_, resolver)));
-
-const mapJSONRecord = async (record: JSONRecord, resolver: URIResolver): Promise<JSONRecord> =>
-  (
-    await Promise.all(
-      Object.entries(record).map(async ([key, value]) => ({
-        [key]: await resolveRef(value, resolver)
-      }))
-    )
-  ).reduce((acc, _) => Object.assign(acc, _), {});
-
-const mapJSONRef = async ({ $ref, ...rest }: JSONRef, resolver: URIResolver): Promise<JSONNode> =>
-  resolveRef($ref ? resolveJPointer(await resolver($ref), $ref) : rest, resolver);
+export const resolveRef = async (json: JSONNode, resolver: URIResolver): Promise<JSONNode> =>
+  mapJSONNode(json, {
+    ref: async ({ $ref, ...rest }) => resolveRef($ref ? resolveJPointer(await resolver($ref), $ref) : rest, resolver),
+    record: async record =>
+      mergeRecords(
+        await Promise.all(
+          Object.entries(record).map(
+            async ([key, value]) => ({ [key]: await resolveRef(value, resolver) } as JSONRecord)
+          )
+        )
+      ),
+    array: async list => Promise.all(list.map(_ => resolveRef(_, resolver)))
+  });

src/visitRef.ts

@@ -1,22 +1,17 @@
-import { type JSONNode, isJSONArray, isJSONRecord, isJSONRef, type JSONRecord } from './JSONNode';
+import { type JSONNode } from './JSONNode';
+import { mapJSONNode } from './mapJSONNode';
 
 type JSONNodePath = (string | number)[];
 export type RefVisitor = (ref: string, path: JSONNodePath) => void;
 
 export const visitRef = (json: JSONNode, visitor: RefVisitor, path: JSONNodePath = []): void => {
-  if (isJSONRef(json)) {
-    visitor(json.$ref, path);
-  } else if (isJSONRecord(json)) {
-    visitJSONRecord(json, visitor, path);
-  } else if (isJSONArray(json)) {
-    visitJSONArray(json, visitor, path);
-  }
-};
-
-const visitJSONRecord = (record: JSONRecord, visitor: RefVisitor, path: JSONNodePath): void => {
-  for (const key in record) visitRef(record[key], visitor, [...path, key]);
-};
-
-const visitJSONArray = (list: JSONNode[], visitor: RefVisitor, path: JSONNodePath): void => {
-  for (let i = 0; i < list.length; i++) visitRef(list[i], visitor, [...path, i]);
+  mapJSONNode(json, {
+    ref: json => visitor(json.$ref, path),
+    record: record => {
+      for (const key in record) visitRef(record[key], visitor, [...path, key]);
+    },
+    array: list => {
+      for (let i = 0; i < list.length; i++) visitRef(list[i], visitor, [...path, i]);
+    }
+  });
 };