fix: all of circular references may freeze (#89)

* fix: better circular $refs handling in allOf

* chore: tune down the console log severity

* test: snapshot

Author: P0lip

src/tree/__tests__/tree.spec.ts

@@ -659,6 +659,96 @@ describe('SchemaTree', () => {
         `);
       });
 
+      test('given circular reference inside of resolved allOf member, should bail out and display unmerged allOf', () => {
+        const schema: JSONSchema4 = {
+          components: {
+            schemas: {
+              Campaign: {
+                type: 'object',
+                allOf: [
+                  {
+                    $ref: '#/components/schemas/Discount',
+                  },
+                  {
+                    properties: {
+                      startDate: {
+                        type: 'number',
+                      },
+                    },
+                  },
+                ],
+              },
+              Coupon: {
+                type: 'object',
+                allOf: [
+                  {
+                    $ref: '#/components/schemas/Discount',
+                  },
+                  {
+                    properties: {
+                      endDate: {
+                        type: 'number',
+                      },
+                    },
+                  },
+                ],
+              },
+              Discount: {
+                oneOf: [
+                  {
+                    $ref: '#/components/schemas/Coupon',
+                  },
+                  {
+                    $ref: '#/components/schemas/Campaign',
+                  },
+                ],
+              },
+            },
+          },
+          properties: {
+            Discount: {
+              $ref: '#/components/schemas/Discount',
+            },
+          },
+        };
+
+        const tree = new SchemaTree(schema, new SchemaTreeState(), {
+          expandedDepth: Infinity,
+          mergeAllOf: true,
+          resolveRef: void 0,
+          shouldResolveEagerly: false,
+          onPopulate: void 0,
+        });
+
+        expect(tree.populate.bind(tree)).not.toThrow();
+
+        tree.unwrap(tree.itemAt(1) as TreeListParentNode);
+        tree.unwrap(tree.itemAt(2) as TreeListParentNode);
+
+        expect(printTree(tree)).toMatchInlineSnapshot(`
+          "└─ #
+             ├─ type: object
+             └─ children
+                └─ 0
+                   └─ #/properties/Discount
+                      ├─ $ref: #/components/schemas/Discount
+                      └─ children
+                         └─ 0
+                            └─ #/properties/Discount
+                               ├─ combiner: oneOf
+                               └─ children
+                                  ├─ 0
+                                  │  └─ #/properties/Discount/oneOf/0
+                                  │     ├─ $ref: #/components/schemas/Coupon
+                                  │     └─ children
+                                  └─ 1
+                                     └─ #/properties/Discount/oneOf/1
+                                        ├─ $ref: #/components/schemas/Campaign
+                                        └─ children
+          "
+        `);
+      });
+
       test('given very complex model with circular references, should bail out and display unmerged allOf', () => {
         const schema = require('../../__fixtures__/complex-allOf-model.json');
 

src/tree/utils/mergeAllOf.ts

@@ -22,18 +22,29 @@ function _mergeAllOf(schema: JSONSchema4, path: JsonPath, opts: WalkingOptions)
       }
 
       const allRefs = store.get(opts)!;
-      const schemaRefs = allRefs.get(schema);
+      let schemaRefs = allRefs.get(schema);
 
       if (schemaRefs === void 0) {
-        allRefs.set(schema, [$ref]);
+        schemaRefs = [$ref];
+        allRefs.set(schema, schemaRefs);
       } else if (schemaRefs.includes($ref)) {
-        const resolved = JSON.parse(safeStringify(opts.resolveRef(null, $ref)));
-        return 'allOf' in resolved ? _mergeAllOf(resolved, path, opts) : resolved;
+        const safelyResolved = JSON.parse(safeStringify(opts.resolveRef(null, $ref)));
+        return 'allOf' in safelyResolved ? _mergeAllOf(safelyResolved, path, opts) : safelyResolved;
       } else {
         schemaRefs.push($ref);
       }
 
-      return opts.resolveRef(null, $ref);
+      const resolved = opts.resolveRef(null, $ref);
+
+      if (Array.isArray(resolved.allOf)) {
+        for (const member of resolved.allOf) {
+          if (typeof member.$ref === 'string' && schemaRefs.includes(member.$ref)) {
+            throw new ResolvingError('Circular reference detected');
+          }
+        }
+      }
+
+      return resolved;
     },
   });
 }
@@ -46,7 +57,7 @@ export const mergeAllOf = (schema: JSONSchema4, path: JsonPath, opts: WalkingOpt
 
     return _mergeAllOf(schema, path, opts);
   } catch (ex) {
-    console.error(ex.message);
+    console.info(ex.message);
     throw ex;
   }
 };