fix: hande nullish $refs

Author: P0lip

src/__fixtures__/nullish-ref.schema.json

@@ -0,0 +1,3 @@
+{
+  "$ref": null
+}

src/components/__tests__/Property.spec.tsx

@@ -58,6 +58,27 @@ describe('Property component', () => {
     expect(wrapper).not.toBeEmptyRender();
   });
 
+  it('should handle nullish $ref', () => {
+    const treeNode: SchemaTreeListNode = {
+      id: 'foo',
+      name: '',
+      parent: null,
+    };
+
+    const schema: JSONSchema4 = {
+      $ref: null as any,
+    };
+
+    metadataStore.set(treeNode, {
+      schemaNode: walk(schema).next().value,
+      path: [],
+      schema,
+    });
+
+    const wrapper = shallow(<Property node={treeNode} onGoToRef={jest.fn()} />);
+    expect(wrapper).not.toBeEmptyRender();
+  });
+
   describe('properties counter', () => {
     it('given missing properties property, should not display the counter', () => {
       const treeNode: SchemaTreeListNode = {

src/components/shared/Property.tsx

@@ -40,7 +40,7 @@ function shouldShowPropertyName(treeNode: SchemaTreeListNode) {
 }
 
 function isExternalRefSchemaNode(schemaNode: SchemaNode) {
-  return '$ref' in schemaNode && !isLocalRef(schemaNode.$ref);
+  return isRefNode(schemaNode) && schemaNode.$ref !== null && !isLocalRef(schemaNode.$ref);
 }
 
 export const Property: React.FunctionComponent<IProperty> = ({ node: treeNode, onGoToRef }) => {
@@ -65,7 +65,7 @@ export const Property: React.FunctionComponent<IProperty> = ({ node: treeNode, o
   }, [node]);
 
   const handleGoToRef = React.useCallback<React.MouseEventHandler>(() => {
-    if (onGoToRef && isRefNode(node)) {
+    if (onGoToRef && isRefNode(node) && node.$ref !== null) {
       onGoToRef(node.$ref, node);
     }
   }, [onGoToRef, node]);
@@ -75,7 +75,7 @@ export const Property: React.FunctionComponent<IProperty> = ({ node: treeNode, o
       {path.length > 0 && shouldShowPropertyName(treeNode) && <div className="mr-2">{path[path.length - 1]}</div>}
 
       <Types type={type} subtype={subtype}>
-        {'$ref' in node ? `[${node.$ref}]` : null}
+        {isRefNode(node) && node.$ref !== null ? `[${node.$ref}]` : null}
       </Types>
 
       {onGoToRef && isExternalRefSchemaNode(node) ? (

src/tree/__tests__/__snapshots__/populateTree.spec.ts.snap

@@ -226,6 +226,21 @@ Object {
 }
 `;
 
+exports[`populateTree util should match nullish-ref.schema.json 1`] = `
+Object {
+  "children": Array [
+    Object {
+      "id": "random-id",
+      "name": "",
+      "parent": [Circular],
+    },
+  ],
+  "id": "random-id",
+  "name": "",
+  "parent": null,
+}
+`;
+
 exports[`populateTree util should match ref/original.json 1`] = `
 Object {
   "children": Array [

src/tree/__tests__/populateTree.spec.ts

@@ -20,6 +20,7 @@ describe('populateTree util', () => {
     'array-of-allofs.json',
     'todo-allof.schema.json',
     'tickets.schema.json',
+    'nullish-ref.schema.json',
   ])('should match %s', filename => {
     const schema = JSON.parse(fs.readFileSync(path.resolve(BASE_PATH, filename), 'utf8'));
     const root = Tree.createArtificialRoot();

src/tree/populateTree.ts

@@ -43,7 +43,7 @@ export const populateTree: Walker = (schema, parent, level, path, options): unde
       path,
     });
 
-    if (isRefNode(node) && isLocalRef(node.$ref) && node.$ref !== '#') {
+    if (isRefNode(node) && node.$ref !== null && isLocalRef(node.$ref) && node.$ref !== '#') {
       (treeNode as TreeListParentNode).children = [];
     } else if (!isCombinerNode(node)) {
       switch (getPrimaryType(node)) {

src/tree/tree.ts

@@ -37,7 +37,7 @@ export class SchemaTree extends Tree {
     populateTree(this.schema, this.root, 0, [], {
       mergeAllOf: this.mergeAllOf,
       onNode: (node, parentTreeNode, level): boolean => {
-        if (isRefNode(node) && isLocalRef(node.$ref)) {
+        if (isRefNode(node) && node.$ref !== null && isLocalRef(node.$ref)) {
           expanded[node.id] = false;
         }
 
@@ -81,7 +81,9 @@ export class SchemaTree extends Tree {
 
     const metadata = getNodeMetadata(node);
     const { path, schemaNode, schema } = metadata;
-    if (isRefNode(schemaNode)) {
+    if (!isRefNode(schemaNode)) {
+      this.populateTreeFragment(node, schema, path);
+    } else if (schemaNode.$ref !== null) {
       const refPath = pointerToPath(schemaNode.$ref);
       const schemaFragment = this.resolveRef ? this.resolveRef(refPath, this.schema) : _get(this.schema, refPath);
       if (!_isObject(schemaFragment)) {
@@ -91,7 +93,7 @@ export class SchemaTree extends Tree {
       this.populateTreeFragment(node, schemaFragment, path);
       metadata.schema = schemaFragment;
     } else {
-      this.populateTreeFragment(node, schema, path);
+      throw new Error(`I do know not how not expand node ${path.join('.')}`);
     }
 
     this.visited.add(node);

src/tree/walk.ts

@@ -1,5 +1,5 @@
 import { JSONSchema4 } from 'json-schema';
-import { IArrayNode, IBaseNode, ICombinerNode, IObjectNode, IRefNode, SchemaKind, SchemaNode } from '../types';
+import { IArrayNode, IBaseNode, ICombinerNode, IObjectNode, SchemaKind, SchemaNode } from '../types';
 import { flattenTypes } from '../utils/flattenTypes';
 import { generateId } from '../utils/generateId';
 import { getAnnotations } from '../utils/getAnnotations';
@@ -65,8 +65,8 @@ function processNode(node: JSONSchema4): SchemaNode | void {
   if ('$ref' in node) {
     return {
       id: generateId(),
-      $ref: node.$ref,
-    } as IRefNode;
+      $ref: typeof node.$ref !== 'string' ? null : node.$ref,
+    };
   }
 
   // if ('not' in node) {

src/types.ts

@@ -38,7 +38,7 @@ export interface IBaseNode extends Pick<JSONSchema4, 'enum'> {
 
 export interface IRefNode {
   id: string;
-  $ref: string;
+  $ref: string | null;
 }
 
 export interface IArrayNode extends IBaseNode, Pick<JSONSchema4, 'items' | 'additionalItems'> {}

src/utils/getPrimaryType.ts

@@ -1,9 +1,9 @@
 import { JSONSchema4 } from 'json-schema';
-import { SchemaKind } from '../types';
+import { SchemaKind, SchemaNode } from '../types';
 import { inferType } from './inferType';
 
-export function getPrimaryType(node: JSONSchema4) {
-  if (node.type !== undefined) {
+export function getPrimaryType(node: JSONSchema4 | SchemaNode) {
+  if ('type' in node && node.type !== undefined) {
     if (Array.isArray(node.type)) {
       if (node.type.includes(SchemaKind.Object)) {
         return SchemaKind.Object;