fix: eager resolving errors (#81)

* fix: handle eager resolving errors

* test: handle eagerresolving errors

Author: Jakub Jankowski

src/tree/__tests__/tree.spec.ts

@@ -1131,6 +1131,35 @@ describe('SchemaTree', () => {
         "
       `);
     });
+
+    test('should handle resolving errors', () => {
+      const schema: JSONSchema4 = {
+        type: 'object',
+        properties: {
+          foo: {
+            type: 'string',
+          },
+          bar: {
+            $ref: 'http://localhost:8080/some/not/existing/path',
+          },
+        },
+      };
+
+      const tree = new SchemaTree(schema, new SchemaTreeState(), {
+        expandedDepth: Infinity,
+        mergeAllOf: true,
+        resolveRef: () => {
+          throw new Error('resolving error');
+        },
+        shouldResolveEagerly: true,
+        onPopulate: void 0,
+      });
+
+      tree.populate();
+
+      expect(tree.count).toEqual(4);
+      expect(getNodeMetadata(tree.itemAt(3)!)).toHaveProperty('error', 'resolving error');
+    });
   });
 
   describe('onPopulate handler', () => {

src/tree/utils/populateTree.ts

@@ -3,13 +3,14 @@ import { JsonPath, Optional } from '@stoplight/types';
 import { JSONSchema4 } from 'json-schema';
 import { isObject as _isObject } from 'lodash';
 import { IArrayNode, IObjectNode, SchemaKind, SchemaNode, SchemaTreeListNode } from '../../types';
+import { generateId } from '../../utils/generateId';
 import { getCombiner } from '../../utils/getCombiner';
 import { getPrimaryType } from '../../utils/getPrimaryType';
 import { isCombinerNode, isRefNode } from '../../utils/guards';
 import { getNodeMetadata, getSchemaNodeMetadata, metadataStore } from '../metadata';
 import { createErrorTreeNode } from './createErrorTreeNode';
 import { mergeAllOf } from './mergeAllOf';
-import { walk } from './walk';
+import { processNode, walk } from './walk';
 
 export type WalkerRefResolver = (path: JsonPath | null, $ref: string) => JSONSchema4;
 
@@ -245,7 +246,22 @@ function prepareSchema(
   try {
     return resolveSchema(schema, path, options);
   } catch (ex) {
-    (node as TreeListParentNode).children = [];
-    return void (node as TreeListParentNode).children.push(createErrorTreeNode(node as TreeListParentNode, ex.message));
+    const treeNode: SchemaTreeListNode = {
+      id: generateId(),
+      name: '',
+      parent: node as TreeListParentNode,
+      children: [],
+    };
+
+    (node as TreeListParentNode).children.push(treeNode);
+    metadataStore.set(treeNode, {
+      schemaNode: processNode(schema || {}),
+      schema: schema || {},
+      path,
+    });
+
+    treeNode.children.push(createErrorTreeNode(treeNode, ex.message));
+
+    return null;
   }
 }

src/tree/utils/walk.ts

@@ -29,7 +29,7 @@ function assignNodeSpecificFields(base: IBaseNode, node: JSONSchema4) {
   }
 }
 
-function processNode(node: JSONSchema4): SchemaNode | void {
+export function processNode(node: JSONSchema4): SchemaNode {
   const combiner = getCombiner(node);
   const type = node.type || inferType(node);
   const title = typeof node.title === 'string' ? { title: node.title } : null;