fix: handle combiners placed under arrays (#86)

Author: P0lip

src/components/__tests__/Property.spec.tsx

@@ -252,6 +252,80 @@ describe('Property component', () => {
       expect(wrapper.find('div').first()).toHaveText('foo');
     });
 
+    test('given an array with a combiner inside, should just render the type of combiner', () => {
+      const schema: JSONSchema4 = {
+        type: 'array',
+        items: {
+          oneOf: [
+            {
+              properties: {},
+            },
+          ],
+          type: 'object',
+        },
+      };
+
+      const tree = new SchemaTree(schema, new TreeState(), {
+        expandedDepth: Infinity,
+        mergeAllOf: false,
+        resolveRef: void 0,
+        shouldResolveEagerly: false,
+        onPopulate: void 0,
+      });
+
+      tree.populate();
+
+      const wrapper = shallow(<Property node={tree.itemAt(1)!} />);
+      expect(wrapper).toHaveHTML('<span class="text-orange-5 truncate">oneOf</span>');
+    });
+
+    test('given an array with an allOf inside and enabled allOf merging, should display the name of properties', () => {
+      const schema: JSONSchema4 = {
+        type: 'object',
+        properties: {
+          'array-all-objects': {
+            type: 'array',
+            items: {
+              allOf: [
+                {
+                  properties: {
+                    foo: {
+                      type: 'string',
+                    },
+                  },
+                },
+                {
+                  properties: {
+                    bar: {
+                      type: 'string',
+                    },
+                  },
+                },
+              ],
+              type: 'object',
+            },
+          },
+        },
+      };
+
+      const tree = new SchemaTree(schema, new TreeState(), {
+        expandedDepth: Infinity,
+        mergeAllOf: true,
+        resolveRef: void 0,
+        shouldResolveEagerly: false,
+        onPopulate: void 0,
+      });
+
+      tree.populate();
+
+      expect(shallow(<Property node={tree.itemAt(2)!} />)).toHaveHTML(
+        '<div class="mr-2">foo</div><span class="text-green-7 dark:text-green-5 truncate">string</span>',
+      );
+      expect(shallow(<Property node={tree.itemAt(3)!} />)).toHaveHTML(
+        '<div class="mr-2">bar</div><span class="text-green-7 dark:text-green-5 truncate">string</span>',
+      );
+    });
+
     test('given a ref pointing at primitive type, should not display property name', () => {
       const schema: JSONSchema4 = {
         properties: {

src/components/shared/Property.tsx

@@ -31,10 +31,11 @@ function shouldShowPropertyName(treeNode: SchemaTreeListNode) {
       return false;
     }
 
-    let type = getPrimaryType(schemaNode);
+    const type = getPrimaryType(schemaNode);
 
     if (type === SchemaKind.Array && (schemaNode as IArrayNode).items) {
-      type = getPrimaryType((schemaNode as IArrayNode).items!);
+      const { schemaNode: itemsSchemaNode } = getSchemaNodeMetadata(treeNode);
+      return !('combiner' in itemsSchemaNode);
     }
 
     return type === SchemaKind.Object;

src/__fixtures__/array-of-allofs.json …ests__/__fixtures__/array-of-allofs.jsonsrc/__fixtures__/array-of-allofs.json renamed to src/tree/__tests__/__fixtures__/array-of-allofs.json src/__fixtures__/array-of-allofs.json renamed to src/tree/__tests__/__fixtures__/array-of-allofs.json

@@ -1,27 +1,5 @@
 // Jest Snapshot v1, https://goo.gl/fbAQLP
 
-exports[`populateTree util should match array-of-allofs.json 1`] = `
-Object {
-  "children": Array [
-    Object {
-      "children": Array [
-        Object {
-          "id": "random-id",
-          "name": "",
-          "parent": [Circular],
-        },
-      ],
-      "id": "random-id",
-      "name": "",
-      "parent": [Circular],
-    },
-  ],
-  "id": "random-id",
-  "name": "",
-  "parent": null,
-}
-`;
-
 exports[`populateTree util should match array-of-objects.json 1`] = `
 Object {
   "children": Array [

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

@@ -1,5 +1,23 @@
 // Jest Snapshot v1, https://goo.gl/fbAQLP
 
+exports[` 1`] = `
+"└─ #
+   ├─ type: object
+   └─ children
+      └─ 0
+         └─ #/properties/array-all-objects
+            ├─ type: array
+            ├─ subtype: object
+            └─ children
+               ├─ 0
+               │  └─ #/properties/array-all-objects/items/properties/foo
+               │     └─ type: string
+               └─ 1
+                  └─ #/properties/array-all-objects/items/properties/bar
+                     └─ type: string
+"
+`;
+
 exports[`SchemaTree expanding $refs in allOf given very complex model with circular references, should bail out and display unmerged allOf 1`] = `
 "└─ #
    ├─ type: object

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

@@ -19,7 +19,6 @@ describe('populateTree util', () => {
     'combiner-schema.json',
     'array-of-objects.json',
     'array-of-refs.json',
-    'array-of-allofs.json',
     'todo-allof.schema.json',
     'tickets.schema.json',
     'nullish-ref.schema.json',
@@ -37,7 +36,6 @@ describe('populateTree util', () => {
     'combiner-schema.json',
     'array-of-objects.json',
     'array-of-refs.json',
-    'array-of-allofs.json',
     'tickets.schema.json',
   ])('should not mutate original object %s', filename => {
     const content = fs.readFileSync(path.resolve(BASE_PATH, filename), 'utf8');

src/tree/__tests__/populateTree.spec.ts

@@ -1,5 +1,7 @@
 import { TreeListParentNode } from '@stoplight/tree-list';
+import * as fs from 'fs';
 import { JSONSchema4 } from 'json-schema';
+import * as path from 'path';
 import { ResolvingError } from '../../errors';
 import { ViewMode } from '../../types';
 import { getNodeMetadata } from '../metadata';
@@ -1434,6 +1436,20 @@ describe('SchemaTree', () => {
       tree.populate();
       expect(tree.count).toEqual(mode === 'standalone' ? 3 : 2);
     });
+
+    describe.each(['array-of-allofs.json'])('should match %s', filename => {
+      const schema = JSON.parse(fs.readFileSync(path.resolve(__dirname, '__fixtures__', filename), 'utf8'));
+      const tree = new SchemaTree(schema, new SchemaTreeState(), {
+        expandedDepth: Infinity,
+        mergeAllOf: true,
+        resolveRef: void 0,
+        shouldResolveEagerly: true,
+        onPopulate: void 0,
+      });
+
+      tree.populate();
+      expect(printTree(tree)).toMatchSnapshot();
+    });
   });
 
   test('given visible $ref node, should try to inject the title immediately', () => {

src/tree/__tests__/tree.spec.ts

@@ -2,9 +2,9 @@ import { TreeListNode, TreeListParentNode } from '@stoplight/tree-list';
 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 { getCombiners } from '../../utils/getCombiners';
 import { getPrimaryType } from '../../utils/getPrimaryType';
 import { isCombinerNode, isRefNode } from '../../utils/guards';
 import { getNodeMetadata, getSchemaNodeMetadata, metadataStore } from '../metadata';
@@ -139,18 +139,31 @@ function processArray(
       }
     }
   } else {
-    const subtype = getPrimaryType(items);
-    switch (subtype) {
-      case SchemaKind.Object:
-        return processObject(node, items as IObjectNode, level, [...path, 'items'], options);
-      case SchemaKind.Array:
-        return processArray(node, items as IObjectNode, level, [...path, 'items'], options);
-      default:
-        const combiners = getCombiners(items);
-        if (combiners !== void 0) {
-          (node as TreeListParentNode).children = [];
-          populateTree(items, node as TreeListParentNode, level, [...path, 'items'], options);
+    const children: TreeListNode[] = [];
+    (node as TreeListParentNode).children = children;
+    populateTree(items, node as TreeListParentNode, level, [...path, 'items'], options);
+
+    // optional flattening
+    if (children.length === 1) {
+      let schemaNode;
+      try {
+        ({ schemaNode } = getSchemaNodeMetadata(children[0]));
+      } catch {
+        return node;
+      }
+
+      if (!('children' in children[0])) {
+        // we'll render this in subtype next to array, i.e. array[subtype], so let's get rid of these redundant nodes
+        // @ts-ignore
+        delete node.children;
+      } else if (!('combiner' in schemaNode)) {
+        for (const child of children[0].children) {
+          // re-parenting
+          child.parent = node as TreeListParentNode;
         }
+
+        children.splice(0, children.length, ...children[0].children);
+      }
     }
   }