Ensure objects are copied so that modifying by ref doesn't happen (#344)

Author: tsmith023

src/collections/filters/classes.ts

@@ -81,7 +81,6 @@ export class FilterBase {
           : undefined,
       });
     }
-
     let target = this.target;
     while (target.target !== undefined) {
       if (TargetGuards.isTargetRef(target.target)) {
@@ -222,32 +221,32 @@ export class FilterRef<T> implements Filter<T> {
 
   public byRef<K extends RefKeys<T> & string>(linkOn: K): Filter<ExtractCrossReferenceType<T[K]>> {
     this.target.target = { type_: 'single', linkOn: linkOn };
-    return new FilterRef<ExtractCrossReferenceType<T[K]>>(this.target);
+    return new FilterRef<ExtractCrossReferenceType<T[K]>>(Object.assign({}, this.target));
   }
 
   public byRefMultiTarget<K extends RefKeys<T> & string>(linkOn: K, targetCollection: string) {
     this.target.target = { type_: 'multi', linkOn: linkOn, targetCollection: targetCollection };
-    return new FilterRef<ExtractCrossReferenceType<T[K]>>(this.target);
+    return new FilterRef<ExtractCrossReferenceType<T[K]>>(Object.assign({}, this.target));
   }
 
   public byProperty<K extends NonRefKeys<T> & string>(name: K, length = false) {
-    return new FilterProperty<T[K]>(name, length, this.target);
+    return new FilterProperty<T[K]>(name, length, Object.assign({}, this.target));
   }
 
   public byRefCount<K extends RefKeys<T> & string>(linkOn: K) {
-    return new FilterCount(linkOn, this.target);
+    return new FilterCount(linkOn, Object.assign({}, this.target));
   }
 
   public byId() {
-    return new FilterId(this.target);
+    return new FilterId(Object.assign({}, this.target));
   }
 
   public byCreationTime() {
-    return new FilterCreationTime(this.target);
+    return new FilterCreationTime(Object.assign({}, this.target));
   }
 
   public byUpdateTime() {
-    return new FilterUpdateTime(this.target);
+    return new FilterUpdateTime(Object.assign({}, this.target));
   }
 }
 

src/collections/filters/unit.test.ts

@@ -313,6 +313,36 @@ describe('Unit testing of filters', () => {
       });
     });
 
+    it('should create two filters through a single ref used multiple times', () => {
+      const f = filter.byRef('self');
+      const f1 = f.byProperty('name').equal('Jim');
+      const f2 = f.byProperty('name').equal('Bob');
+      expect(f1).toEqual<FilterValue<string>>({
+        operator: 'Equal',
+        target: {
+          singleTarget: {
+            on: 'self',
+            target: {
+              property: 'name',
+            },
+          },
+        },
+        value: 'Jim',
+      });
+      expect(f2).toEqual<FilterValue<string>>({
+        operator: 'Equal',
+        target: {
+          singleTarget: {
+            on: 'self',
+            target: {
+              property: 'name',
+            },
+          },
+        },
+        value: 'Bob',
+      });
+    });
+
     it('should create a nested reference filter', () => {
       const f = filter.byRef('self').byRef('self').byProperty('name').isNull(true);
       expect(f).toEqual<FilterValue<boolean>>({