fixes to mutation event system: do not deduplicate legitimate events coming through different paths, if no cycles are formed

Author: sbazerque

src/data/model/immutable/HashedObject.ts

@@ -314,28 +314,29 @@ abstract class HashedObject {
         }
     }
 
-    getMutationEventSource(seen?: Set<HashedObject>): EventRelay<HashedObject> {
+    getMutationEventSource(): EventRelay<HashedObject> {
 
         if (this._mutationEventSource === undefined) {
 
-            this._mutationEventSource = this.createMutationEventSource(seen);
+            this._mutationEventSource = this.createMutationEventSource();
 
         }
 
         return this._mutationEventSource;
 
     }
 
-    protected createMutationEventSource(seen=new Set<HashedObject>()): EventRelay<HashedObject> {
-
-        seen.add(this);
+    protected createMutationEventSource(): EventRelay<HashedObject> {
 
         const subObservers = new Map<string, EventRelay<HashedObject>>();
 
         for (const [fieldName, subobj] of this.getDirectSubObjects().entries()) {
-            if (!seen.has(subobj)) {
-                subObservers.set(fieldName, subobj.getMutationEventSource(seen));
-            }
+            //if (!seen.has(subobj)) {
+            //    console.log('adding subobject ' + fieldName + ' to ' + this.getLastHash() + '( a ' + this.getClassName() + ')');
+                subObservers.set(fieldName, subobj.getMutationEventSource());
+            //} else {
+            //    console.log('NOT adding subobject ' + fieldName + ' to ' + this.getLastHash() + '( a ' + this.getClassName() + ')');
+            //}
         }
 
         return new EventRelay(this, subObservers);

src/data/model/mutable/MutableObject.ts

@@ -542,28 +542,28 @@ abstract class  MutableObject extends HashedObject {
         return before;
     }
 
-    protected createMutationEventSource(seen=new Set<HashedObject>()): EventRelay<HashedObject> {
+    protected createMutationEventSource(): EventRelay<HashedObject> {
 
-        const ownMutationEventSource = super.createMutationEventSource(seen);
+        const ownMutationEventSource = super.createMutationEventSource();
 
-        this.updateCascadeMutableContentRelays(ownMutationEventSource, seen);
+        this.updateCascadeMutableContentRelays(ownMutationEventSource);
 
         return ownMutationEventSource;
 
     }
 
-    private updateCascadeMutableContentRelays(ownMutationEventSource?: EventRelay<HashedObject>, seen=new Set<HashedObject>()) {
+    private updateCascadeMutableContentRelays(ownMutationEventSource?: EventRelay<HashedObject>) {
 
         if (ownMutationEventSource !== undefined) {
 
             if (this.isCascadingMutableContentEvents()) {
                 ownMutationEventSource.addObserver(this._cascadeMutableContentObserver);
 
-                this.addEventRelaysForContents(ownMutationEventSource, seen);
+                this.addEventRelaysForContents(ownMutationEventSource);
             } else {
                 ownMutationEventSource.removeObserver(this._cascadeMutableContentObserver);
 
-                this.removeEventRelaysForContents(ownMutationEventSource, seen);
+                this.removeEventRelaysForContents(ownMutationEventSource);
             }
         }
     }

src/util/events.ts

@@ -79,28 +79,31 @@ class EventRelay<E extends hashable, D=any> {
 
         EventRelay.logger.debug('adding upstream ' + name + ' (' + upstream.emitter.getLastHash() + ') to ' + this.emitter.getLastHash());
 
-        //if (!this.wouldCreateACycle(upstream.emitterHash)) {
         if (!upstream.wouldCreateACycle(this.emitter.getLastHash())) {
 
             const observer = (upstreamEv: Event<E, D>) => {
 
-                const upstreamEmitters = upstreamEv.path === undefined? [] : Array.from(upstreamEv.path)
+                // if the original emitter and the current emitter are the same,it means that the event has
+                // somehow propagated back to its origin, we do not need to forward the event any more
+                if (upstreamEv.emitter.getLastHash() !== this.emitter.getLastHash()) {
 
-                upstreamEmitters.push({name: name, emitter: this.emitter});
+                    const upstreamEmitters = upstreamEv.path === undefined? [] : Array.from(upstreamEv.path)
 
-                const ev: Event<E, D> = {
-                    emitter: upstreamEv.emitter,
-                    path: upstreamEmitters,
-                    action: upstreamEv.action,
-                    data: upstreamEv.data                
-                };
-
-                EventRelay.logger.debug('upstream from ' + this.emitter.getLastHash() + ' name: ' + name);
-
-                this.emit(ev);
+                    upstreamEmitters.push({name: name, emitter: this.emitter});
+    
+                    const ev: Event<E, D> = {
+                        emitter: upstreamEv.emitter,
+                        path: upstreamEmitters,
+                        action: upstreamEv.action,
+                        data: upstreamEv.data                
+                    };
+    
+                    EventRelay.logger.debug('upstream from ' + this.emitter.getLastHash() + ' name: ' + name);
+    
+                    this.emit(ev);
+                }
 
                 return false;
-
             };
 
             this.upstreamRelays.set(name, [upstream, observer]);