fix(walker): reuse allOfs correctly (#7)

* fix(walker): reuse allOfs correctly

* chore(walker): oneOf/anyOf should also reuse initialFragment

Author: P0lip

src/__tests__/__fixtures__/combiners/allOfs/circular-regular-level.json

@@ -0,0 +1,29 @@
+{
+  "properties": {
+    "someProp": {
+      "$ref": "#/__bundled__/repo"
+    }
+  },
+  "__bundled__": {
+    "repo": {
+      "properties": {
+        "parent": {
+          "allOf": [
+            {
+              "$ref": "#/__bundled__/repo"
+            },
+            {
+              "type": "object",
+              "properties": {
+                "foo": {
+                  "type": "string"
+                }
+              }
+            }
+          ]
+        }
+      },
+      "type": "object"
+    }
+  }
+}

src/__tests__/__fixtures__/combiners/allOfs/circular-top-level.json

@@ -0,0 +1,20 @@
+{
+  "$ref": "#/__bundled__/repo",
+  "__bundled__": {
+    "repo": {
+      "properties": {
+        "parent": {
+          "allOf": [
+            {
+              "$ref": "#/__bundled__/repo"
+            },
+            {
+              "type": "object"
+            }
+          ]
+        }
+      },
+      "type": "object"
+    }
+  }
+}

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

@@ -554,6 +554,53 @@ exports[`SchemaTree output should generate valid tree for combiners/allOfs/base.
 "
 `;
 
+exports[`SchemaTree output should generate valid tree for combiners/allOfs/circular-regular-level.json 1`] = `
+"└─ #
+   ├─ types
+   │  └─ 0: object
+   ├─ primaryType: object
+   └─ children
+      └─ 0
+         └─ #/properties/someProp
+            ├─ types
+            │  └─ 0: object
+            ├─ primaryType: object
+            └─ children
+               └─ 0
+                  └─ #/properties/someProp/properties/parent
+                     ├─ types
+                     │  └─ 0: object
+                     ├─ primaryType: object
+                     └─ children
+                        ├─ 0
+                        │  └─ #/properties/someProp/properties/parent/properties/parent
+                        │     └─ mirrors: #/properties/someProp/properties/parent
+                        └─ 1
+                           └─ #/properties/someProp/properties/parent/properties/foo
+                              ├─ types
+                              │  └─ 0: string
+                              └─ primaryType: string
+"
+`;
+
+exports[`SchemaTree output should generate valid tree for combiners/allOfs/circular-top-level.json 1`] = `
+"└─ #
+   ├─ types
+   │  └─ 0: object
+   ├─ primaryType: object
+   └─ children
+      └─ 0
+         └─ #/properties/parent
+            ├─ types
+            │  └─ 0: object
+            ├─ primaryType: object
+            └─ children
+               └─ 0
+                  └─ #/properties/parent/properties/parent
+                     └─ mirrors: #/properties/parent
+"
+`;
+
 exports[`SchemaTree output should generate valid tree for combiners/allOfs/complex.json 1`] = `
 "└─ #
    ├─ types

src/walker/walker.ts

@@ -19,14 +19,16 @@ type InternalWalkerState = {
   schemaNode: RegularNode | RootNode;
 };
 
+type ProcessedFragment = SchemaFragment | SchemaFragment[];
+
 export class Walker extends EventEmitter<WalkerEmitter> {
   public readonly path: string[];
   public depth: number;
 
   protected fragment: SchemaFragment;
   protected schemaNode: RegularNode | RootNode;
 
-  private processedFragments: WeakMap<SchemaFragment, SchemaNode>;
+  private processedFragments: WeakMap<ProcessedFragment, SchemaNode>;
   private readonly hooks: Partial<Dictionary<WalkerHookHandler, WalkerHookAction>>;
 
   constructor(protected readonly root: RootNode, protected readonly walkingOptions: WalkingOptions) {
@@ -103,10 +105,12 @@ export class Walker extends EventEmitter<WalkerEmitter> {
     const state = this.dumpInternalWalkerState();
 
     super.emit('enterFragment', fragment);
-    const schemaNode = this.processFragment();
+    const [schemaNode, initialFragment] = this.processFragment();
     super.emit('enterNode', schemaNode);
 
-    this.processedFragments.set(schemaNode.fragment, isMirroredNode(schemaNode) ? schemaNode.mirroredNode : schemaNode);
+    const actualNode = isMirroredNode(schemaNode) ? schemaNode.mirroredNode : schemaNode;
+    this.processedFragments.set(schemaNode.fragment, actualNode);
+    this.processedFragments.set(initialFragment, actualNode);
 
     this.fragment = schemaNode.fragment;
     this.depth = initialDepth + 1;
@@ -237,23 +241,23 @@ export class Walker extends EventEmitter<WalkerEmitter> {
     this.schemaNode = schemaNode;
   }
 
-  protected retrieveFromFragment(fragment: SchemaFragment): MirroredSchemaNode | void {
+  protected retrieveFromFragment(fragment: ProcessedFragment): [MirroredSchemaNode, ProcessedFragment] | void {
     const processedSchemaNode = this.processedFragments.get(fragment);
     if (processedSchemaNode !== void 0) {
       if (isRegularNode(processedSchemaNode)) {
-        return new MirroredRegularNode(processedSchemaNode);
+        return [new MirroredRegularNode(processedSchemaNode), fragment];
       }
 
       if (isReferenceNode(processedSchemaNode)) {
-        return new MirroredReferenceNode(processedSchemaNode);
+        return [new MirroredReferenceNode(processedSchemaNode), fragment];
       }
 
       // whoops, we don't know what to do with it
       throw new TypeError('Cannot mirror the node');
     }
   }
 
-  protected processFragment(): SchemaNode {
+  protected processFragment(): [SchemaNode, ProcessedFragment] {
     const { walkingOptions, path } = this;
     let { fragment } = this;
 
@@ -265,23 +269,29 @@ export class Walker extends EventEmitter<WalkerEmitter> {
 
     if ('$ref' in fragment) {
       if (typeof fragment.$ref !== 'string') {
-        return new ReferenceNode(fragment, '$ref is not a string');
+        return [new ReferenceNode(fragment, '$ref is not a string'), fragment];
       } else if (walkingOptions.resolveRef !== null) {
         try {
           fragment = walkingOptions.resolveRef(path, fragment.$ref);
         } catch (ex) {
           super.emit('error', createMagicError(ex));
-          return new ReferenceNode(fragment, ex?.message ?? 'Unknown resolving error');
+          return [new ReferenceNode(fragment, ex?.message ?? 'Unknown resolving error'), fragment];
         }
       } else {
-        return new ReferenceNode(fragment, null);
+        return [new ReferenceNode(fragment, null), fragment];
       }
     }
 
+    let initialFragment: ProcessedFragment = fragment;
     if (walkingOptions.mergeAllOf && SchemaCombinerName.AllOf in fragment) {
       try {
+        if (Array.isArray(fragment.allOf)) {
+          initialFragment = fragment.allOf;
+        }
+
         fragment = mergeAllOf(fragment, path, walkingOptions);
       } catch (ex) {
+        initialFragment = fragment;
         super.emit('error', createMagicError(new MergingError(ex?.message ?? 'Unknown merging error')));
         // no the end of the world - we will render raw unprocessed fragment
       }
@@ -291,25 +301,28 @@ export class Walker extends EventEmitter<WalkerEmitter> {
       try {
         const merged = mergeOneOrAnyOf(fragment, path, walkingOptions);
         if (merged.length === 1) {
-          return new RegularNode(merged[0]);
+          return [new RegularNode(merged[0]), initialFragment];
         } else {
           const combiner = SchemaCombinerName.OneOf in fragment ? SchemaCombinerName.OneOf : SchemaCombinerName.AnyOf;
-          return new RegularNode({
-            [combiner]: merged,
-          });
+          return [
+            new RegularNode({
+              [combiner]: merged,
+            }),
+            initialFragment,
+          ];
         }
       } catch (ex) {
         super.emit('error', createMagicError(new MergingError(ex?.message ?? 'Unknown merging error')));
         // no the end of the world - we will render raw unprocessed fragment
       }
     }
 
-    retrieved = isNonNullable(fragment) ? this.retrieveFromFragment(fragment) : null;
+    retrieved = isNonNullable(fragment) ? this.retrieveFromFragment(initialFragment) : null;
 
     if (retrieved) {
       return retrieved;
     }
 
-    return new RegularNode(fragment);
+    return [new RegularNode(fragment), initialFragment];
   }
 }