@vuer-ai/vuer-rtc 0.7.0 → 0.8.2

package/tests/client/coalesce-graph-operations.test.ts

@@ -14,7 +14,7 @@ describe('Graph Operation Coalescence (end-to-end)', () => {
     it('should coalesce consecutive text.insert operations when coalescingEnabled', async () => {
       const messages: CRDTMessage[] = [];
       const store = createGraph({
-        sessionId: 'alice',
+        client: 'alice',
         onSend: (msg) => messages.push(msg),
         coalescingEnabled: true,
         coalescingDelayMs: 50, // Short delay for testing
@@ -22,17 +22,17 @@ describe('Graph Operation Coalescence (end-to-end)', () => {
       });
 
       // Create node first (insert as child of root '')
-      store.edit({ otype: 'node.insert', key: '', path: 'children', value: { key: 'doc', tag: 'Doc', name: 'Document' } });
+      store.edit({ ot: 'node.insert', key: '', path: 'children', value: { key: 'doc', tag: 'Doc', name: 'Document' } });
 
       // Initialize a text property
-      store.edit({ otype: 'text.init', key: 'doc', path: 'content', value: '' });
+      store.edit({ ot: 'text.init', key: 'doc', path: 'content', value: '' });
 
       // Simulate typing "Hello" quickly (within 300ms)
-      store.edit({ otype: 'text.insert', key: 'doc', path: 'content', position: 0, value: 'H' });
-      store.edit({ otype: 'text.insert', key: 'doc', path: 'content', position: 1, value: 'e' });
-      store.edit({ otype: 'text.insert', key: 'doc', path: 'content', position: 2, value: 'l' });
-      store.edit({ otype: 'text.insert', key: 'doc', path: 'content', position: 3, value: 'l' });
-      store.edit({ otype: 'text.insert', key: 'doc', path: 'content', position: 4, value: 'o' });
+      store.edit({ ot: 'text.insert', key: 'doc', path: 'content', position: 0, value: 'H' });
+      store.edit({ ot: 'text.insert', key: 'doc', path: 'content', position: 1, value: 'e' });
+      store.edit({ ot: 'text.insert', key: 'doc', path: 'content', position: 2, value: 'l' });
+      store.edit({ ot: 'text.insert', key: 'doc', path: 'content', position: 3, value: 'l' });
+      store.edit({ ot: 'text.insert', key: 'doc', path: 'content', position: 4, value: 'o' });
 
       // Wait for coalescing timer to fire
       await new Promise(resolve => setTimeout(resolve, 100));
@@ -42,66 +42,66 @@ describe('Graph Operation Coalescence (end-to-end)', () => {
 
       // The message should contain coalesced text.insert operations
       const msg = messages[0];
-      const textInserts = msg.ops.filter(op => op.otype === 'text.insert');
+      const textInserts = msg.ops.filter(op => op.ot === 'text.insert');
 
       // All 5 inserts should be coalesced into 1 operation
       expect(textInserts.length).toBeLessThan(5);
 
-      // The coalesced operation should have content "Hello"
+      // The coalesced operation should have value "Hello"
       const firstInsert = textInserts[0];
-      expect(firstInsert.content).toBe('Hello');
+      expect((firstInsert as any).value[1]).toBe('Hello');  // value is [anchor, content] tuple
     });
 
     it('should NOT coalesce when coalescingEnabled is false', async () => {
       const messages: CRDTMessage[] = [];
       const store = createGraph({
-        sessionId: 'alice',
+        client: 'alice',
         onSend: (msg) => messages.push(msg),
         coalescingEnabled: false, // Disabled
       });
 
-      store.edit({ otype: 'node.insert', key: '', path: 'children', value: { key: 'doc', tag: 'Doc', name: 'Document' } });
-      store.edit({ otype: 'text.init', key: 'doc', path: 'content', value: '' });
+      store.edit({ ot: 'node.insert', key: '', path: 'children', value: { key: 'doc', tag: 'Doc', name: 'Document' } });
+      store.edit({ ot: 'text.init', key: 'doc', path: 'content', value: '' });
 
       // Type "Hi" and commit immediately
-      store.edit({ otype: 'text.insert', key: 'doc', path: 'content', position: 0, value: 'H' });
-      store.edit({ otype: 'text.insert', key: 'doc', path: 'content', position: 1, value: 'i' });
+      store.edit({ ot: 'text.insert', key: 'doc', path: 'content', position: 0, value: 'H' });
+      store.edit({ ot: 'text.insert', key: 'doc', path: 'content', position: 1, value: 'i' });
       store.commit('typing');
 
       // Should send ONE message with init and 2 separate insert operations (not coalesced)
       expect(messages.length).toBe(1);
-      const textInserts = messages[0].ops.filter(op => op.otype === 'text.insert');
+      const textInserts = messages[0].ops.filter(op => op.ot === 'text.insert');
 
       // Should have 2 separate operations
       expect(textInserts.length).toBe(2);
-      expect(textInserts[0].content).toBe('H');
-      expect(textInserts[1].content).toBe('i');
+      expect((textInserts[0] as any).value[1]).toBe('H');  // value is [anchor, content] tuple
+      expect((textInserts[1] as any).value[1]).toBe('i');
     });
 
     it('should respect time threshold and create separate operations for slow typing', async () => {
       const messages: CRDTMessage[] = [];
       const store = createGraph({
-        sessionId: 'alice',
+        client: 'alice',
         onSend: (msg) => messages.push(msg),
         coalescingEnabled: true,
         coalescingDelayMs: 50,
         coalescingThresholdMs: 100, // 100ms threshold
       });
 
-      store.edit({ otype: 'node.insert', key: '', path: 'children', value: { key: 'doc', tag: 'Doc', name: 'Document' } });
-      store.edit({ otype: 'text.init', key: 'doc', path: 'content', value: '' });
+      store.edit({ ot: 'node.insert', key: '', path: 'children', value: { key: 'doc', tag: 'Doc', name: 'Document' } });
+      store.edit({ ot: 'text.init', key: 'doc', path: 'content', value: '' });
 
       // Type "H" and "e" quickly
-      store.edit({ otype: 'text.insert', key: 'doc', path: 'content', position: 0, value: 'H' });
-      store.edit({ otype: 'text.insert', key: 'doc', path: 'content', position: 1, value: 'e' });
+      store.edit({ ot: 'text.insert', key: 'doc', path: 'content', position: 0, value: 'H' });
+      store.edit({ ot: 'text.insert', key: 'doc', path: 'content', position: 1, value: 'e' });
 
       // Wait for first batch to be sent
       await new Promise(resolve => setTimeout(resolve, 100));
 
       // Type "l" and "l" quickly (after threshold)
       await new Promise(resolve => setTimeout(resolve, 150)); // Exceed threshold
-      store.edit({ otype: 'text.insert', key: 'doc', path: 'content', position: 2, value: 'l' });
-      store.edit({ otype: 'text.insert', key: 'doc', path: 'content', position: 3, value: 'l' });
+      store.edit({ ot: 'text.insert', key: 'doc', path: 'content', position: 2, value: 'l' });
+      store.edit({ ot: 'text.insert', key: 'doc', path: 'content', position: 3, value: 'l' });
 
       // Wait for second batch
       await new Promise(resolve => setTimeout(resolve, 100));
@@ -109,14 +109,14 @@ describe('Graph Operation Coalescence (end-to-end)', () => {
       // Should have sent TWO messages: one with "He", one with "ll"
       expect(messages.length).toBe(2);
 
-      const firstInserts = messages[0].ops.filter(op => op.otype === 'text.insert');
-      const secondInserts = messages[1].ops.filter(op => op.otype === 'text.insert');
+      const firstInserts = messages[0].ops.filter(op => op.ot === 'text.insert');
+      const secondInserts = messages[1].ops.filter(op => op.ot === 'text.insert');
 
       expect(firstInserts.length).toBe(1);
-      expect(firstInserts[0].content).toBe('He');
+      expect((firstInserts[0] as any).value[1]).toBe('He');  // value is [anchor, content] tuple
 
       expect(secondInserts.length).toBe(1);
-      expect(secondInserts[0].content).toBe('ll');
+      expect((secondInserts[0] as any).value[1]).toBe('ll');
     });
   });
 
@@ -124,7 +124,7 @@ describe('Graph Operation Coalescence (end-to-end)', () => {
     it('should coalesce consecutive text.delete operations', async () => {
       const messages: CRDTMessage[] = [];
       const store = createGraph({
-        sessionId: 'alice',
+        client: 'alice',
         onSend: (msg) => messages.push(msg),
         coalescingEnabled: true,
         coalescingDelayMs: 50,
@@ -132,17 +132,17 @@ describe('Graph Operation Coalescence (end-to-end)', () => {
       });
 
       // Create node and initialize with some text
-      store.edit({ otype: 'node.insert', key: '', path: 'children', value: { key: 'doc', tag: 'Doc', name: 'Document' } });
-      store.edit({ otype: 'text.init', key: 'doc', path: 'content', value: 'Hello World' });
+      store.edit({ ot: 'node.insert', key: '', path: 'children', value: { key: 'doc', tag: 'Doc', name: 'Document' } });
+      store.edit({ ot: 'text.init', key: 'doc', path: 'content', value: 'Hello World' });
       await new Promise(resolve => setTimeout(resolve, 100));
       messages.length = 0; // Clear init message
 
       // Delete "World" one character at a time (positions 6-10)
-      store.edit({ otype: 'text.delete', key: 'doc', path: 'content', position: 6, length: 1 }); // Delete 'W'
-      store.edit({ otype: 'text.delete', key: 'doc', path: 'content', position: 6, length: 1 }); // Delete 'o'
-      store.edit({ otype: 'text.delete', key: 'doc', path: 'content', position: 6, length: 1 }); // Delete 'r'
-      store.edit({ otype: 'text.delete', key: 'doc', path: 'content', position: 6, length: 1 }); // Delete 'l'
-      store.edit({ otype: 'text.delete', key: 'doc', path: 'content', position: 6, length: 1 }); // Delete 'd'
+      store.edit({ ot: 'text.delete', key: 'doc', path: 'content', position: 6, length: 1 }); // Delete 'W'
+      store.edit({ ot: 'text.delete', key: 'doc', path: 'content', position: 6, length: 1 }); // Delete 'o'
+      store.edit({ ot: 'text.delete', key: 'doc', path: 'content', position: 6, length: 1 }); // Delete 'r'
+      store.edit({ ot: 'text.delete', key: 'doc', path: 'content', position: 6, length: 1 }); // Delete 'l'
+      store.edit({ ot: 'text.delete', key: 'doc', path: 'content', position: 6, length: 1 }); // Delete 'd'
 
       // Wait for coalescing timer
       await new Promise(resolve => setTimeout(resolve, 100));
@@ -150,7 +150,7 @@ describe('Graph Operation Coalescence (end-to-end)', () => {
       // Should have ONE coalesced delete message
       expect(messages.length).toBe(1);
 
-      const deleteOps = messages[0].ops.filter(op => op.otype === 'text.delete');
+      const deleteOps = messages[0].ops.filter(op => op.ot === 'text.delete');
 
       // Should be coalesced into fewer operations
       expect(deleteOps.length).toBeLessThan(5);
@@ -158,33 +158,33 @@ describe('Graph Operation Coalescence (end-to-end)', () => {
       // If coalesced into 1 operation, it should have a deletions array
       if (deleteOps.length === 1) {
         const firstDelete = deleteOps[0] as any;
-        expect(firstDelete.deletions).toBeDefined();
-        expect(firstDelete.deletions.length).toBeGreaterThanOrEqual(1);
+        expect(firstDelete.rm).toBeDefined();  // rm field contains deletions
+        expect(firstDelete.rm.length).toBeGreaterThanOrEqual(1);  // rm is [[id, len], ...]
       }
     });
 
     it('should handle mixed insert and delete operations', async () => {
       const messages: CRDTMessage[] = [];
       const store = createGraph({
-        sessionId: 'alice',
+        client: 'alice',
         onSend: (msg) => messages.push(msg),
         coalescingEnabled: true,
         coalescingDelayMs: 50,
         coalescingThresholdMs: 300,
       });
 
-      store.edit({ otype: 'node.insert', key: '', path: 'children', value: { key: 'doc', tag: 'Doc', name: 'Document' } });
-      store.edit({ otype: 'text.init', key: 'doc', path: 'content', value: '' });
+      store.edit({ ot: 'node.insert', key: '', path: 'children', value: { key: 'doc', tag: 'Doc', name: 'Document' } });
+      store.edit({ ot: 'text.init', key: 'doc', path: 'content', value: '' });
 
       // Type "Hello", then delete "lo", then type "p"
-      store.edit({ otype: 'text.insert', key: 'doc', path: 'content', position: 0, value: 'H' });
-      store.edit({ otype: 'text.insert', key: 'doc', path: 'content', position: 1, value: 'e' });
-      store.edit({ otype: 'text.insert', key: 'doc', path: 'content', position: 2, value: 'l' });
-      store.edit({ otype: 'text.insert', key: 'doc', path: 'content', position: 3, value: 'l' });
-      store.edit({ otype: 'text.insert', key: 'doc', path: 'content', position: 4, value: 'o' });
-      store.edit({ otype: 'text.delete', key: 'doc', path: 'content', position: 3, length: 1 }); // Delete 'l'
-      store.edit({ otype: 'text.delete', key: 'doc', path: 'content', position: 3, length: 1 }); // Delete 'o'
-      store.edit({ otype: 'text.insert', key: 'doc', path: 'content', position: 3, value: 'p' });
+      store.edit({ ot: 'text.insert', key: 'doc', path: 'content', position: 0, value: 'H' });
+      store.edit({ ot: 'text.insert', key: 'doc', path: 'content', position: 1, value: 'e' });
+      store.edit({ ot: 'text.insert', key: 'doc', path: 'content', position: 2, value: 'l' });
+      store.edit({ ot: 'text.insert', key: 'doc', path: 'content', position: 3, value: 'l' });
+      store.edit({ ot: 'text.insert', key: 'doc', path: 'content', position: 4, value: 'o' });
+      store.edit({ ot: 'text.delete', key: 'doc', path: 'content', position: 3, length: 1 }); // Delete 'l'
+      store.edit({ ot: 'text.delete', key: 'doc', path: 'content', position: 3, length: 1 }); // Delete 'o'
+      store.edit({ ot: 'text.insert', key: 'doc', path: 'content', position: 3, value: 'p' });
 
       // Wait for coalescing timer
       await new Promise(resolve => setTimeout(resolve, 100));
@@ -193,8 +193,8 @@ describe('Graph Operation Coalescence (end-to-end)', () => {
       expect(messages.length).toBe(1);
 
       const msg = messages[0];
-      const inserts = msg.ops.filter(op => op.otype === 'text.insert');
-      const deletes = msg.ops.filter(op => op.otype === 'text.delete');
+      const inserts = msg.ops.filter(op => op.ot === 'text.insert');
+      const deletes = msg.ops.filter(op => op.ot === 'text.delete');
 
       // Should have some coalesced inserts and deletes
       expect(inserts.length).toBeGreaterThan(0);
@@ -206,16 +206,16 @@ describe('Graph Operation Coalescence (end-to-end)', () => {
     it('should coalesce operations when explicitly committing with coalescingEnabled', () => {
       const messages: CRDTMessage[] = [];
       const store = createGraph({
-        sessionId: 'alice',
+        client: 'alice',
         onSend: (msg) => messages.push(msg),
         coalescingEnabled: true,
         coalescingThresholdMs: 300,
       });
 
-      store.edit({ otype: 'node.insert', key: '', path: 'children', value: { key: 'doc', tag: 'Doc', name: 'Document' } });
-      store.edit({ otype: 'text.init', key: 'doc', path: 'content', value: '' });
-      store.edit({ otype: 'text.insert', key: 'doc', path: 'content', position: 0, value: 'H' });
-      store.edit({ otype: 'text.insert', key: 'doc', path: 'content', position: 1, value: 'i' });
+      store.edit({ ot: 'node.insert', key: '', path: 'children', value: { key: 'doc', tag: 'Doc', name: 'Document' } });
+      store.edit({ ot: 'text.init', key: 'doc', path: 'content', value: '' });
+      store.edit({ ot: 'text.insert', key: 'doc', path: 'content', position: 0, value: 'H' });
+      store.edit({ ot: 'text.insert', key: 'doc', path: 'content', position: 1, value: 'i' });
 
       // Explicitly commit (should clear timer and coalesce immediately)
       store.commit('typing');
@@ -223,9 +223,9 @@ describe('Graph Operation Coalescence (end-to-end)', () => {
       // Should send ONE message immediately with coalesced operations
       expect(messages.length).toBe(1);
 
-      const textInserts = messages[0].ops.filter(op => op.otype === 'text.insert');
+      const textInserts = messages[0].ops.filter(op => op.ot === 'text.insert');
       expect(textInserts.length).toBe(1);
-      expect(textInserts[0].content).toBe('Hi');
+      expect((textInserts[0] as any).value[1]).toBe('Hi');  // value is [anchor, content] tuple
     });
   });
 
@@ -233,7 +233,7 @@ describe('Graph Operation Coalescence (end-to-end)', () => {
     it('should coalesce operations on different documents independently', async () => {
       const messages: CRDTMessage[] = [];
       const store = createGraph({
-        sessionId: 'alice',
+        client: 'alice',
         onSend: (msg) => messages.push(msg),
         coalescingEnabled: true,
         coalescingDelayMs: 50,
@@ -241,16 +241,16 @@ describe('Graph Operation Coalescence (end-to-end)', () => {
       });
 
       // Edit doc1
-      store.edit({ otype: 'node.insert', key: '', path: 'children', value: { key: 'doc1', tag: 'Doc', name: 'Document 1' } });
-      store.edit({ otype: 'text.init', key: 'doc1', path: 'content', value: '' });
-      store.edit({ otype: 'text.insert', key: 'doc1', path: 'content', position: 0, value: 'A' });
-      store.edit({ otype: 'text.insert', key: 'doc1', path: 'content', position: 1, value: 'B' });
+      store.edit({ ot: 'node.insert', key: '', path: 'children', value: { key: 'doc1', tag: 'Doc', name: 'Document 1' } });
+      store.edit({ ot: 'text.init', key: 'doc1', path: 'content', value: '' });
+      store.edit({ ot: 'text.insert', key: 'doc1', path: 'content', position: 0, value: 'A' });
+      store.edit({ ot: 'text.insert', key: 'doc1', path: 'content', position: 1, value: 'B' });
 
       // Edit doc2
-      store.edit({ otype: 'node.insert', key: '', path: 'children', value: { key: 'doc2', tag: 'Doc', name: 'Document 2' } });
-      store.edit({ otype: 'text.init', key: 'doc2', path: 'content', value: '' });
-      store.edit({ otype: 'text.insert', key: 'doc2', path: 'content', position: 0, value: 'X' });
-      store.edit({ otype: 'text.insert', key: 'doc2', path: 'content', position: 1, value: 'Y' });
+      store.edit({ ot: 'node.insert', key: '', path: 'children', value: { key: 'doc2', tag: 'Doc', name: 'Document 2' } });
+      store.edit({ ot: 'text.init', key: 'doc2', path: 'content', value: '' });
+      store.edit({ ot: 'text.insert', key: 'doc2', path: 'content', position: 0, value: 'X' });
+      store.edit({ ot: 'text.insert', key: 'doc2', path: 'content', position: 1, value: 'Y' });
 
       // Wait for coalescing
       await new Promise(resolve => setTimeout(resolve, 100));
@@ -259,15 +259,15 @@ describe('Graph Operation Coalescence (end-to-end)', () => {
       expect(messages.length).toBe(1);
 
       const msg = messages[0];
-      const doc1Inserts = msg.ops.filter(op => op.otype === 'text.insert' && op.key === 'doc1');
-      const doc2Inserts = msg.ops.filter(op => op.otype === 'text.insert' && op.key === 'doc2');
+      const doc1Inserts = msg.ops.filter(op => op.ot === 'text.insert' && op.key === 'doc1');
+      const doc2Inserts = msg.ops.filter(op => op.ot === 'text.insert' && op.key === 'doc2');
 
       // Each document's operations should be coalesced independently
       expect(doc1Inserts.length).toBe(1);
-      expect(doc1Inserts[0].content).toBe('AB');
+      expect((doc1Inserts[0] as any).value[1]).toBe('AB');  // value is [anchor, content] tuple
 
       expect(doc2Inserts.length).toBe(1);
-      expect(doc2Inserts[0].content).toBe('XY');
+      expect((doc2Inserts[0] as any).value[1]).toBe('XY');
     });
   });
 
@@ -275,37 +275,37 @@ describe('Graph Operation Coalescence (end-to-end)', () => {
     it('should handle rapid commits without losing operations', async () => {
       const messages: CRDTMessage[] = [];
       const store = createGraph({
-        sessionId: 'alice',
+        client: 'alice',
         onSend: (msg) => messages.push(msg),
         coalescingEnabled: true,
         coalescingDelayMs: 100,
         coalescingThresholdMs: 300,
       });
 
-      store.edit({ otype: 'node.insert', key: '', path: 'children', value: { key: 'doc', tag: 'Doc', name: 'Document' } });
-      store.edit({ otype: 'text.init', key: 'doc', path: 'content', value: '' });
-      store.edit({ otype: 'text.insert', key: 'doc', path: 'content', position: 0, value: 'A' });
+      store.edit({ ot: 'node.insert', key: '', path: 'children', value: { key: 'doc', tag: 'Doc', name: 'Document' } });
+      store.edit({ ot: 'text.init', key: 'doc', path: 'content', value: '' });
+      store.edit({ ot: 'text.insert', key: 'doc', path: 'content', position: 0, value: 'A' });
       store.commit('first');
 
-      store.edit({ otype: 'text.insert', key: 'doc', path: 'content', position: 1, value: 'B' });
+      store.edit({ ot: 'text.insert', key: 'doc', path: 'content', position: 1, value: 'B' });
       store.commit('second');
 
-      store.edit({ otype: 'text.insert', key: 'doc', path: 'content', position: 2, value: 'C' });
+      store.edit({ ot: 'text.insert', key: 'doc', path: 'content', position: 2, value: 'C' });
       store.commit('third');
 
       // Should have 3 messages (one per commit)
       expect(messages.length).toBe(3);
 
       // Each message should contain the expected operation
-      expect(messages[0].ops.some(op => op.otype === 'text.insert' && op.content === 'A')).toBe(true);
-      expect(messages[1].ops.some(op => op.otype === 'text.insert' && op.content === 'B')).toBe(true);
-      expect(messages[2].ops.some(op => op.otype === 'text.insert' && op.content === 'C')).toBe(true);
+      expect(messages[0].ops.some(op => op.ot === 'text.insert' && (op as any).value[1] === 'A')).toBe(true);  // value is [anchor, content] tuple
+      expect(messages[1].ops.some(op => op.ot === 'text.insert' && (op as any).value[1] === 'B')).toBe(true);
+      expect(messages[2].ops.some(op => op.ot === 'text.insert' && (op as any).value[1] === 'C')).toBe(true);
     });
 
     it('should handle empty edits gracefully', async () => {
       const messages: CRDTMessage[] = [];
       const store = createGraph({
-        sessionId: 'alice',
+        client: 'alice',
         onSend: (msg) => messages.push(msg),
         coalescingEnabled: true,
         coalescingDelayMs: 50,