fix: GCounter merge and compare not working

packages/crdt/src/builtins/2PSet/index.ts

@@ -17,7 +17,7 @@ export class TwoPSet<T> {
   add(element: T): void {
     this._adds.add(element);
   }
-
+ 
   remove(element: T): void {
     this._removes.add(element);
   }
@@ -41,4 +41,4 @@ export class TwoPSet<T> {
     this._adds.merge(peerSet.adds());
     this._removes.merge(peerSet.removes());
   }
-}
+}

packages/crdt/src/builtins/GCounter/index.ts

@@ -27,15 +27,20 @@ export class GCounter {
     }
     return true;
   }
-
+  
   merge(peerCounter: GCounter): void {
     let temp: { [nodeKey: string]: number } = Object.assign(
       {},
       this.counts,
       peerCounter.counts,
     );
+
     Object.keys(temp).forEach((key) => {
       this.counts[key] = Math.max(this.counts[key], peerCounter.counts[key]);
+
     });
+
+    this.globalCounter = Object.values(this.counts).reduce((a, b) => a + b, 0);
+
   }
-}
+}

packages/crdt/src/builtins/GSet/index.ts

@@ -19,10 +19,10 @@ export class GSet<T> {
   }
 
   compare(peerSet: GSet<T>): boolean {
-    return this._set === peerSet.set();
+    return (this._set.size == peerSet.set().size && [...this._set].every(value => peerSet.set().has(value)));
   }
 
   merge(peerSet: GSet<T>): void {
     this._set = new Set<T>([...this._set, ...peerSet.set()]);
   }
-}
+}

packages/crdt/src/builtins/LWWElementSet/index.ts

@@ -0,0 +1,76 @@
+export enum Bias {
+    ADD,
+    REMOVE
+}
+
+export class LWWElementSet<T> {
+    private _adds: Map<T, number>;
+    private _removes: Map<T, number>;
+    public _bias: Bias;
+
+    constructor(adds: Map<T, number>, removes: Map<T, number>, bias: Bias) {
+        this._adds = adds;
+        this._removes = removes;
+        this._bias = bias;
+    }
+
+    lookup(element: T): boolean {
+
+        const addTimestamp = this._adds.get(element);
+        const removeTimestamp = this._removes.get(element);
+
+        if (addTimestamp !== undefined) {
+            if (removeTimestamp === undefined || addTimestamp > removeTimestamp || (addTimestamp-removeTimestamp === 0 && this._bias === Bias.ADD)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    add(element: T): void {
+        this._adds.set(element, Date.now());
+    }
+
+    remove(element: T): void {
+        this._removes.set(element, Date.now());
+    }
+
+    getAdds(): Map<T, number> {
+        return this._adds;
+    }
+
+    getRemoves(): Map<T, number> {
+        return this._removes;
+    }
+
+    areSetsEqual(set1: Set<T>, set2: Set<T>): boolean {
+        return (set1.size == set2.size && [...set1].every(value => set2.has(value)));
+    }
+
+    compare(peerSet: LWWElementSet<T>): boolean {
+        const adds = new Set(this._adds.keys());
+        const rems = new Set(this._removes.keys());
+        const otherAdds = new Set(peerSet._adds.keys());
+        const otherRems = new Set(peerSet._removes.keys());
+
+        return (this.areSetsEqual(adds, otherAdds) && this.areSetsEqual(rems, otherRems));
+
+    }
+
+    merge(peerSet: LWWElementSet<T>): void {
+
+        for (let [element, timestamp] of peerSet._adds.entries()) {
+            const thisTimestamp = this._adds.get(element);
+            if (!thisTimestamp || thisTimestamp < timestamp) {
+                this._adds.set(element, timestamp);
+            }
+        }
+
+        for (let [element, timestamp] of peerSet._removes.entries()) {
+            const thisTimestamp = this._removes.get(element);
+            if (!thisTimestamp || thisTimestamp < timestamp) {
+                this._removes.set(element, timestamp);
+            }
+        }
+    }
+}

packages/crdt/src/builtins/ORSet/index.ts

@@ -0,0 +1,88 @@
+export interface ElementTuple<T> {
+    element: T,
+    tag: number,
+    replicaId: string
+}
+
+export class ORSet<T> {
+    private _elements: Set<ElementTuple<T>>;
+    private _summary: Map<string, number>;
+    public replicaId: string;
+
+    constructor(elements: Set<ElementTuple<T>>, replicaId: string) {
+        this._elements = elements;
+        this.replicaId = replicaId;
+        this._summary = new Map<string, number>([[this.replicaId, 0]]);
+
+    }
+
+    lookup(element: T): boolean {
+        return [...this._elements].some(elem => elem.element === element);
+    }
+
+    add(element: T): void {
+
+        let tag:number = this._summary.get(this.replicaId)! + 1;
+        this._summary.set(this.replicaId, tag);
+        this._elements.add({ element, tag, replicaId: this.replicaId });
+
+    }
+
+    remove(element: T): void {
+        for (let tuple of this._elements.values()) {
+            if (tuple.element === element) {
+                this._elements.delete(tuple); //removes element from the elements
+            }
+        }
+    }
+
+    getElements(): Set<ElementTuple<T>> {
+        return this._elements;
+    }
+
+    getSummary(): Map<string,number> {
+        return this._summary;
+    }
+
+    //here I just compare the elements set
+    compare(peerSet: ORSet<T>): boolean {
+        return (this._elements.size == peerSet.getElements().size && 
+            [...this._elements].every((value) => peerSet.getElements().has(value)));
+    }
+
+    merge(peerSet: ORSet<T>): void {
+
+        let M = new Set<ElementTuple<T>>();
+        let A = new Set<ElementTuple<T>>();
+        let B = new Set<ElementTuple<T>>();
+
+        // Adds the elements common to the two sets
+        this._elements.forEach((element) => {
+            if(peerSet.getElements().has(element)) {
+                M.add(element);
+            }
+        });
+
+        // in the local payload but not recently removed from the remote payload
+        this._elements.forEach((element) => {
+            const tag = peerSet.getSummary().get(element.replicaId);
+            if(!peerSet.getElements().has(element) && tag !== undefined && element.tag > tag ) {
+                A.add(element);
+            }
+        });
+
+        //vice-versa
+        peerSet.getElements().forEach((element) => {
+            const tag = this._summary.get(element.replicaId);
+            if(!this._elements.has(element) && tag !== undefined && element.tag > tag) {
+                B.add(element);
+            }
+        });
+
+        this._elements = new Set<ElementTuple<T>>([...M,...A,...B]);
+
+        for( let e of peerSet.getSummary().entries()) {
+            this._summary.set(e[0], Math.max(e[1], this._summary.get(e[0])!));
+        }
+    }
+}

packages/crdt/src/builtins/PNCounter/index.ts

@@ -22,11 +22,11 @@ export class PNCounter {
     return this._decrements;
   }
 
-  increment(nodeId: string, amount: number): void {
+  increment(nodeId: number, amount: number): void {
     this._increments.increment(nodeId, amount);
   }
 
-  decrement(nodeId: string, amount: number): void {
+  decrement(nodeId: number, amount: number): void {
     this._decrements.increment(nodeId, amount);
   }
 
@@ -41,4 +41,4 @@ export class PNCounter {
     this._increments.merge(peerCounter.increments());
     this._decrements.merge(peerCounter.decrements());
   }
-}
+}

packages/crdt/tests/GCounter.test.ts

@@ -0,0 +1,69 @@
+import { describe, test, expect, beforeEach } from "vitest";
+import { GCounter } from "../src/builtins/GCounter";
+
+describe("G-Counter Tests", () => {
+
+    let set1: GCounter;
+    let set2: GCounter; 
+
+    beforeEach(() => {
+        set1 = new GCounter({ "node1": 5, "node2": 10});
+        set2 = new GCounter({ "node1": 5, "node2": 10});
+    });
+
+    test("Test Initial Values", () => {
+        expect(set1.value()).toBe(15);
+        expect(set2.value()).toBe(15);
+    });
+
+    test("Test Increment", () => {
+
+        set1.increment("node1", 10);
+        set1.increment("node2", 5);
+
+        expect(set1.value()).toBe(30);
+    });
+
+    test("Test Compare", () => {
+
+        expect(set1.compare(set2)).toBe(true);
+
+        set2.increment("node1", 5);
+
+        expect(set1.compare(set2)).toBe(false);
+
+        let set3 = new GCounter({ "node1": 5, "node2": 10, "node3": 15 });
+
+        expect(set1.compare(set3)).toBe(false);
+    });
+
+    test("Test Merge", () => {
+
+        const counter1 = new GCounter({ "node1": 5 });
+        const counter2 = new GCounter({ "node2": 10 });
+
+        counter1.merge(counter2);
+
+        expect(counter1.counts).toEqual({ "node1": 5, "node2": 10 });
+        expect(counter1.value()).toBe(15);
+
+        set1.increment("node1", 5);
+        set2.increment("node2", 10);
+        expect(set1.value()).toBe(35);
+        expect(set2.value()).toBe(40);
+        set1.merge(set2);
+        expect(set1.value()).toBe(45);
+        expect(set1.counts[0]).toBe(10);
+        expect(set1.counts[1]).toBe(20);
+        expect(set1.counts[2]).toBe(15);
+
+        set2.merge(set1);
+        expect(set2.value()).toBe(45);
+        expect(set2.counts[0]).toBe(10);
+        expect(set2.counts[1]).toBe(20);
+        expect(set2.counts[2]).toBe(15);
+
+        expect(set2.compare(set1)).toBe(true);
+    });
+
+});

packages/crdt/tests/GSet.test.ts

@@ -0,0 +1,46 @@
+import { describe, test, expect, beforeEach, afterEach } from "vitest";
+import { GSet } from "../src/builtins/GSet";
+
+describe("G-Set Tests", () => {
+
+    let set1: GSet<string>;
+    let set2: GSet<string>;
+
+    beforeEach(() => {
+        set1 = new GSet<string>(new Set<string>(["walter", "jesse", "mike"]));
+        set2 = new GSet<string>(new Set<string>(["walter", "jesse", "mike"]));
+    });
+
+    test("Test Add", () => {
+        set1.add("gustavo");
+        set2.add("gustavo");
+
+        expect(set1.lookup("gustavo")).toBe(true);
+        expect(set2.lookup("gustavo")).toBe(true);
+    });
+
+    test("Test Compare", () => {
+        expect(set1.compare(set2)).toBe(true);
+
+        set1.add("gustavo");
+
+        expect(set1.compare(set2)).toBe(false);
+
+        set2.add("gustavo");
+
+        expect(set1.compare(set2)).toBe(true);
+    });
+
+    test("Test Merge", () => {
+        set1.add("gustavo");
+        set2.add("lalo");
+
+        expect(set1.compare(set2)).toBe(false);
+
+        set1.merge(set2);
+        set2.merge(set1);
+
+        expect(set1.compare(set2)).toBe(true);
+
+    });
+});