@vuer-ai/vuer-rtc-server 0.2.0 → 0.2.2

package/tests/journal/lww-ordering-bug.test.ts

@@ -0,0 +1,248 @@
+/**
+ * Test demonstrating LWW bug caused by session grouping in coalescing
+ *
+ * The bug: When coalescing groups all operations by session, it uses the
+ * last message's lamportTime for ALL operations from that session.
+ * This breaks LWW conflict resolution when operations are interleaved.
+ */
+
+import { describe, it, expect } from '@jest/globals';
+import type { CRDTMessage, Operation, SceneGraph } from '@vuer-ai/vuer-rtc';
+import { createEmptyGraph, applyMessage } from '@vuer-ai/vuer-rtc';
+
+/**
+ * Helper to coalesce messages using current (buggy) implementation
+ */
+function coalesceBuggy(messages: CRDTMessage[]): CRDTMessage[] {
+  if (messages.length === 0) return [];
+
+  // Current implementation: Group by session
+  const sessionGroups = new Map<string, CRDTMessage[]>();
+  for (const msg of messages) {
+    if (!sessionGroups.has(msg.sessionId)) {
+      sessionGroups.set(msg.sessionId, []);
+    }
+    sessionGroups.get(msg.sessionId)!.push(msg);
+  }
+
+  const coalesced: CRDTMessage[] = [];
+  for (const [sessionId, sessionMessages] of sessionGroups) {
+    // Flatten all ops from this session
+    const allOps: Operation[] = [];
+    for (const msg of sessionMessages) {
+      allOps.push(...msg.ops);
+    }
+
+    // Use last message's metadata (THIS IS THE BUG)
+    const lastMsg = sessionMessages[sessionMessages.length - 1];
+    coalesced.push({
+      ...lastMsg,
+      ops: allOps,
+    });
+  }
+
+  return coalesced;
+}
+
+/**
+ * Helper to coalesce messages preserving interleaved order
+ */
+function coalesceCorrect(messages: CRDTMessage[]): CRDTMessage[] {
+  if (messages.length === 0) return [];
+
+  // Correct implementation: Group into consecutive runs
+  const runs: CRDTMessage[][] = [];
+  let currentRun: CRDTMessage[] = [];
+  let lastSessionId: string | null = null;
+
+  for (const msg of messages) {
+    if (msg.sessionId !== lastSessionId && currentRun.length > 0) {
+      runs.push(currentRun);
+      currentRun = [];
+    }
+    currentRun.push(msg);
+    lastSessionId = msg.sessionId;
+  }
+  if (currentRun.length > 0) runs.push(currentRun);
+
+  // Coalesce each run
+  return runs.map(run => {
+    const allOps: Operation[] = [];
+    for (const msg of run) {
+      allOps.push(...msg.ops);
+    }
+    const lastMsg = run[run.length - 1];
+    return {
+      ...lastMsg,
+      ops: allOps,
+    };
+  });
+}
+
+describe('LWW Ordering Bug', () => {
+  /**
+   * Scenario:
+   * 1. Alice sets cube.color = "red" (lamport=10)
+   * 2. Bob sets cube.color = "blue" (lamport=15)
+   * 3. Alice sets cube.color = "green" (lamport=20)
+   *
+   * Expected: Final color should be "green" (lamport=20 wins)
+   *
+   * Bug: When coalescing groups all Alice's ops together and uses
+   * lamport=20 for both, BOTH red and green get lamport=20.
+   * This breaks LWW resolution.
+   */
+  it('should preserve LWW ordering when operations are interleaved', () => {
+    // Create the node first
+    let graph = createEmptyGraph();
+    graph = applyMessage(graph, {
+      id: 'init',
+      sessionId: 'init',
+      clock: { init: 1 },
+      lamportTime: 1,
+      timestamp: 0,
+      ops: [{ otype: 'node.insert', key: '__root', path: 'children', value: { key: 'cube', tag: 'Mesh', name: 'Cube' } }],
+    });
+
+    // Original messages in interleaved order
+    const messages: CRDTMessage[] = [
+      {
+        id: 'msg1',
+        sessionId: 'alice',
+        clock: { alice: 10 },
+        lamportTime: 10,
+        timestamp: 1000,
+        ops: [
+          {
+            otype: 'string.set',
+            key: 'cube',
+            path: 'color',
+            value: 'red',
+          },
+        ],
+      },
+      {
+        id: 'msg2',
+        sessionId: 'bob',
+        clock: { alice: 10, bob: 15 },
+        lamportTime: 15,
+        timestamp: 1500,
+        ops: [
+          {
+            otype: 'string.set',
+            key: 'cube',
+            path: 'color',
+            value: 'blue',
+          },
+        ],
+      },
+      {
+        id: 'msg3',
+        sessionId: 'alice',
+        clock: { alice: 20, bob: 15 },
+        lamportTime: 20,
+        timestamp: 2000,
+        ops: [
+          {
+            otype: 'string.set',
+            key: 'cube',
+            path: 'color',
+            value: 'green',
+          },
+        ],
+      },
+    ];
+
+    // Apply original messages - should result in green
+    let graphOriginal = graph;
+    for (const msg of messages) {
+      graphOriginal = applyMessage(graphOriginal, msg);
+    }
+    expect(graphOriginal.nodes['cube']?.color).toBe('green');
+
+    // Apply buggy coalescing
+    const coalescedBuggy = coalesceBuggy(messages);
+    console.log('Buggy coalescing:');
+    coalescedBuggy.forEach(msg => {
+      console.log(`  session=${msg.sessionId}, lamport=${msg.lamportTime}, ops=${msg.ops.length}`);
+      msg.ops.forEach(op => console.log(`    ${JSON.stringify(op)}`));
+    });
+
+    let graphBuggy = graph;
+    for (const msg of coalescedBuggy) {
+      graphBuggy = applyMessage(graphBuggy, msg);
+    }
+
+    // THIS WILL FAIL - buggy version might produce wrong result
+    console.log(`Buggy result: ${graphBuggy.nodes['cube']?.color}`);
+
+    // Apply correct coalescing
+    const coalescedCorrect = coalesceCorrect(messages);
+    console.log('\nCorrect coalescing:');
+    coalescedCorrect.forEach(msg => {
+      console.log(`  session=${msg.sessionId}, lamport=${msg.lamportTime}, ops=${msg.ops.length}`);
+      msg.ops.forEach(op => console.log(`    ${JSON.stringify(op)}`));
+    });
+
+    let graphCorrect = graph;
+    for (const msg of coalescedCorrect) {
+      graphCorrect = applyMessage(graphCorrect, msg);
+    }
+    console.log(`Correct result: ${graphCorrect.nodes['cube']?.color}`);
+
+    // Both should produce "green"
+    expect(graphCorrect.nodes['cube']?.color).toBe('green');
+
+    // This expectation will FAIL with buggy coalescing
+    expect(graphBuggy.nodes['cube']?.color).toBe('green');
+  });
+
+  it('demonstrates the metadata inheritance problem', () => {
+    const messages: CRDTMessage[] = [
+      {
+        id: 'msg1',
+        sessionId: 'alice',
+        clock: { alice: 10 },
+        lamportTime: 10,
+        timestamp: 1000,
+        ops: [{ otype: 'number.set', key: 'x', path: 'value', value: 1 }],
+      },
+      {
+        id: 'msg2',
+        sessionId: 'bob',
+        clock: { alice: 10, bob: 15 },
+        lamportTime: 15,
+        timestamp: 1500,
+        ops: [{ otype: 'number.set', key: 'x', path: 'value', value: 2 }],
+      },
+      {
+        id: 'msg3',
+        sessionId: 'alice',
+        clock: { alice: 20, bob: 15 },
+        lamportTime: 20,
+        timestamp: 2000,
+        ops: [{ otype: 'number.set', key: 'x', path: 'value', value: 3 }],
+      },
+    ];
+
+    const coalesced = coalesceBuggy(messages);
+
+    // Find alice's coalesced message
+    const aliceMsg = coalesced.find(m => m.sessionId === 'alice')!;
+
+    // Bug: ALL of Alice's ops inherit lamportTime=20 from msg3
+    expect(aliceMsg.lamportTime).toBe(20);
+    expect(aliceMsg.ops).toHaveLength(2); // Both set operations
+
+    // When these ops are applied, they BOTH get lamportTime=20
+    // This means the first operation (value=1) incorrectly gets lamport=20
+    // instead of its original lamport=10
+
+    console.log('Alice coalesced message:', {
+      lamportTime: aliceMsg.lamportTime,
+      ops: aliceMsg.ops,
+    });
+
+    // The problem: Both ops get lamport=20, so LWW resolution is broken
+  });
+});