@vuer-ai/vuer-rtc-server 0.2.3 → 0.4.1

package/tests/journal/rle-compression.test.ts

@@ -22,23 +22,23 @@ describe('RLE Compression', () => {
   // Helper to create test messages
   function createMessage(
     id: string,
-    sessionId: string,
-    lamportTime: number,
+    client: string,
+    lt: number,
     opsCount: number = 1
   ): CRDTMessage {
     const ops: NumberSetOp[] = Array.from({ length: opsCount }, (_, i) => ({
-      otype: 'number.set',
-      key: `key-${lamportTime}`,
+      ot: 'number.set',
+      key: `key-${lt}`,
       path: `properties/prop-${i}`,
       value: Math.random() * 100,
     }));
 
     return {
       id,
-      sessionId,
-      clock: { [sessionId]: lamportTime },
-      lamportTime,
-      timestamp: Date.now() / 1000,
+      client,
+      clock: { [client]: lt },
+      lt,
+      ts: Date.now() / 1000,
       ops,
     };
   }
@@ -55,7 +55,7 @@ describe('RLE Compression', () => {
 
       expect(result).toHaveLength(1);
       expect(result[0]).toMatchObject({
-        sessionId: 'session-a',
+        client: 'session-a',
         count: 1,
         lamportTime: 1,
         endLamportTime: 1,
@@ -74,7 +74,7 @@ describe('RLE Compression', () => {
 
       expect(result).toHaveLength(1);
       expect(result[0]).toMatchObject({
-        sessionId: 'session-a',
+        client: 'session-a',
         count: 3,
         lamportTime: 1,
         endLamportTime: 3,
@@ -93,11 +93,11 @@ describe('RLE Compression', () => {
       const result = encodeRLE(msgs);
 
       expect(result).toHaveLength(3);
-      expect(result[0].sessionId).toBe('session-a');
+      expect(result[0].client).toBe('session-a');
       expect(result[0].count).toBe(1);
-      expect(result[1].sessionId).toBe('session-b');
+      expect(result[1].client).toBe('session-b');
       expect(result[1].count).toBe(1);
-      expect(result[2].sessionId).toBe('session-a');
+      expect(result[2].client).toBe('session-a');
       expect(result[2].count).toBe(1);
     });
 
@@ -121,7 +121,7 @@ describe('RLE Compression', () => {
 
       expect(result[0].ops).toEqual(msg.ops);
       expect(result[0].ops[0].key).toBe(msg.ops[0].key);
-      expect(result[0].ops[1].otype).toBe(msg.ops[1].otype);
+      expect(result[0].ops[1].ot).toBe(msg.ops[1].ot);
     });
   });
 
@@ -129,11 +129,11 @@ describe('RLE Compression', () => {
     it('should decode single run to single message', () => {
       const encoded = [
         {
-          sessionId: 'session-a',
+          client: 'session-a',
           count: 1,
           lamportTime: 1,
           endLamportTime: 1,
-          ops: [{ otype: 'number.set', key: 'k1', path: 'p1', value: 10 }],
+          ops: [{ ot: 'number.set', key: 'k1', path: 'p1', value: 10 }],
           timestamp: 1000,
         },
       ];
@@ -142,22 +142,22 @@ describe('RLE Compression', () => {
       const result = decodeRLE(encoded, opCounts);
 
       expect(result).toHaveLength(1);
-      expect(result[0].sessionId).toBe('session-a');
-      expect(result[0].lamportTime).toBe(1);
+      expect(result[0].client).toBe('session-a');
+      expect(result[0].lt).toBe(1);
       expect(result[0].ops).toHaveLength(1);
     });
 
     it('should decode run with multiple messages', () => {
       const encoded = [
         {
-          sessionId: 'session-a',
+          client: 'session-a',
           count: 3,
           lamportTime: 1,
           endLamportTime: 3,
           ops: [
-            { otype: 'number.set', key: 'k1', path: 'p1', value: 1 },
-            { otype: 'number.set', key: 'k2', path: 'p2', value: 2 },
-            { otype: 'number.set', key: 'k3', path: 'p3', value: 3 },
+            { ot: 'number.set', key: 'k1', path: 'p1', value: 1 },
+            { ot: 'number.set', key: 'k2', path: 'p2', value: 2 },
+            { ot: 'number.set', key: 'k3', path: 'p3', value: 3 },
           ],
           timestamp: 1000,
         },
@@ -167,9 +167,9 @@ describe('RLE Compression', () => {
       const result = decodeRLE(encoded, opCounts);
 
       expect(result).toHaveLength(3);
-      expect(result[0].lamportTime).toBe(1);
-      expect(result[1].lamportTime).toBe(2);
-      expect(result[2].lamportTime).toBe(3);
+      expect(result[0].lt).toBe(1);
+      expect(result[1].lt).toBe(2);
+      expect(result[2].lt).toBe(3);
       // Each should have one op
       result.forEach((msg) => {
         expect(msg.ops).toHaveLength(1);
@@ -179,14 +179,14 @@ describe('RLE Compression', () => {
     it('should handle multi-op messages during decode', () => {
       const encoded = [
         {
-          sessionId: 'session-a',
+          client: 'session-a',
           count: 2,
           lamportTime: 1,
           endLamportTime: 2,
           ops: [
-            { otype: 'number.set', key: 'k1a', path: 'p1a', value: 10 },
-            { otype: 'number.set', key: 'k1b', path: 'p1b', value: 20 },
-            { otype: 'number.set', key: 'k2a', path: 'p2a', value: 30 },
+            { ot: 'number.set', key: 'k1a', path: 'p1a', value: 10 },
+            { ot: 'number.set', key: 'k1b', path: 'p1b', value: 20 },
+            { ot: 'number.set', key: 'k2a', path: 'p2a', value: 30 },
           ],
           timestamp: 1000,
         },
@@ -211,8 +211,8 @@ describe('RLE Compression', () => {
 
       // Check counts
       expect(decoded).toHaveLength(original.length);
-      expect(decoded[0].sessionId).toBe(original[0].sessionId);
-      expect(decoded[0].lamportTime).toBe(original[0].lamportTime);
+      expect(decoded[0].client).toBe(original[0].client);
+      expect(decoded[0].lt).toBe(original[0].lt);
       expect(decoded[0].ops).toEqual(original[0].ops);
     });
 
@@ -229,8 +229,8 @@ describe('RLE Compression', () => {
 
       expect(decoded).toHaveLength(original.length);
       for (let i = 0; i < original.length; i++) {
-        expect(decoded[i].sessionId).toBe(original[i].sessionId);
-        expect(decoded[i].lamportTime).toBe(original[i].lamportTime);
+        expect(decoded[i].client).toBe(original[i].client);
+        expect(decoded[i].lt).toBe(original[i].lt);
         expect(decoded[i].ops).toEqual(original[i].ops);
       }
     });
@@ -248,8 +248,8 @@ describe('RLE Compression', () => {
 
       expect(decoded).toHaveLength(original.length);
       for (let i = 0; i < original.length; i++) {
-        expect(decoded[i].sessionId).toBe(original[i].sessionId);
-        expect(decoded[i].lamportTime).toBe(original[i].lamportTime);
+        expect(decoded[i].client).toBe(original[i].client);
+        expect(decoded[i].lt).toBe(original[i].lt);
       }
     });
 
@@ -268,7 +268,7 @@ describe('RLE Compression', () => {
       expect(decoded).toHaveLength(original.length);
       for (let i = 0; i < original.length; i++) {
         expect(decoded[i].ops).toHaveLength(original[i].ops.length);
-        expect(decoded[i].sessionId).toBe(original[i].sessionId);
+        expect(decoded[i].client).toBe(original[i].client);
       }
     });
   });
@@ -287,9 +287,9 @@ describe('RLE Compression', () => {
       expect(decoded).toHaveLength(original.length);
       for (let i = 0; i < original.length; i++) {
         expect(decoded[i].id).toBe(original[i].id);
-        expect(decoded[i].sessionId).toBe(original[i].sessionId);
+        expect(decoded[i].client).toBe(original[i].client);
         expect(decoded[i].clock).toEqual(original[i].clock);
-        expect(decoded[i].lamportTime).toBe(original[i].lamportTime);
+        expect(decoded[i].lt).toBe(original[i].lt);
         expect(decoded[i].ops).toEqual(original[i].ops);
       }
     });
@@ -310,19 +310,19 @@ describe('RLE Compression', () => {
     it('should preserve vector clocks', () => {
       const msg1: CRDTMessage = {
         id: 'msg-1',
-        sessionId: 'session-a',
+        client: 'session-a',
         clock: { 'session-a': 5, 'session-b': 3 },
-        lamportTime: 1,
-        timestamp: 1000,
-        ops: [{ otype: 'number.set', key: 'k', path: 'p', value: 10 }],
+        lt: 1,
+        ts: 1000,
+        ops: [{ ot: 'number.set', key: 'k', path: 'p', value: 10 }],
       };
       const msg2: CRDTMessage = {
         id: 'msg-2',
-        sessionId: 'session-a',
+        client: 'session-a',
         clock: { 'session-a': 6, 'session-b': 4 },
-        lamportTime: 2,
-        timestamp: 1001,
-        ops: [{ otype: 'number.set', key: 'k', path: 'p', value: 20 }],
+        lt: 2,
+        ts: 1001,
+        ops: [{ ot: 'number.set', key: 'k', path: 'p', value: 20 }],
       };
 
       const encoded = encodeRLEWithMetadata([msg1, msg2]);
@@ -359,17 +359,17 @@ describe('RLE Compression', () => {
 
     it('should maintain operation order within messages', () => {
       const ops: NumberSetOp[] = [
-        { otype: 'number.set', key: 'k1', path: 'p1', value: 1 },
-        { otype: 'number.set', key: 'k2', path: 'p2', value: 2 },
-        { otype: 'number.set', key: 'k3', path: 'p3', value: 3 },
+        { ot: 'number.set', key: 'k1', path: 'p1', value: 1 },
+        { ot: 'number.set', key: 'k2', path: 'p2', value: 2 },
+        { ot: 'number.set', key: 'k3', path: 'p3', value: 3 },
       ];
 
       const msg: CRDTMessage = {
         id: 'msg-1',
-        sessionId: 'session-a',
+        client: 'session-a',
         clock: { 'session-a': 1 },
-        lamportTime: 1,
-        timestamp: 1000,
+        lt: 1,
+        ts: 1000,
         ops,
       };
 
@@ -390,7 +390,7 @@ describe('RLE Compression', () => {
       const decoded = decodeRLEWithMetadata(encoded);
 
       for (let i = 0; i < original.length; i++) {
-        expect(decoded[i].lamportTime).toBe(original[i].lamportTime);
+        expect(decoded[i].lt).toBe(original[i].lt);
       }
     });
   });
@@ -446,26 +446,26 @@ describe('RLE Compression', () => {
     it('should handle very large lamport times', () => {
       const msg: CRDTMessage = {
         id: 'msg-huge',
-        sessionId: 'session-a',
+        client: 'session-a',
         clock: { 'session-a': 999999999 },
-        lamportTime: 999999999,
-        timestamp: 1000,
-        ops: [{ otype: 'number.set', key: 'k', path: 'p', value: 10 }],
+        lt:999999999,
+        ts: 1000,
+        ops: [{ ot: 'number.set', key: 'k', path: 'p', value: 10 }],
       };
 
       const encoded = encodeRLEWithMetadata([msg]);
       const decoded = decodeRLEWithMetadata(encoded);
 
-      expect(decoded[0].lamportTime).toBe(999999999);
+      expect(decoded[0].lt).toBe(999999999);
     });
 
     it('should handle empty operations array', () => {
       const msg: CRDTMessage = {
         id: 'msg-1',
-        sessionId: 'session-a',
+        client: 'session-a',
         clock: { 'session-a': 1 },
-        lamportTime: 1,
-        timestamp: 1000,
+        lt: 1,
+        ts: 1000,
         ops: [],
       };
 
@@ -477,7 +477,7 @@ describe('RLE Compression', () => {
 
     it('should handle very long operation lists', () => {
       const ops: NumberSetOp[] = Array.from({ length: 1000 }, (_, i) => ({
-        otype: 'number.set',
+        ot: 'number.set',
         key: `k-${i}`,
         path: `p-${i}`,
         value: i,
@@ -485,10 +485,10 @@ describe('RLE Compression', () => {
 
       const msg: CRDTMessage = {
         id: 'msg-huge-ops',
-        sessionId: 'session-a',
+        client: 'session-a',
         clock: { 'session-a': 1 },
-        lamportTime: 1,
-        timestamp: 1000,
+        lt: 1,
+        ts: 1000,
         ops,
       };
 
@@ -503,17 +503,17 @@ describe('RLE Compression', () => {
   describe('CRDT Semantics Preservation - Operation Details', () => {
     it('should maintain operation order and properties', () => {
       const ops: NumberSetOp[] = [
-        { otype: 'number.set', key: 'k1', path: 'p1', value: 1 },
-        { otype: 'number.set', key: 'k2', path: 'p2', value: 2 },
-        { otype: 'number.set', key: 'k3', path: 'p3', value: 3 },
+        { ot: 'number.set', key: 'k1', path: 'p1', value: 1 },
+        { ot: 'number.set', key: 'k2', path: 'p2', value: 2 },
+        { ot: 'number.set', key: 'k3', path: 'p3', value: 3 },
       ];
 
       const msg: CRDTMessage = {
         id: 'msg-1',
-        sessionId: 'session-a',
+        client: 'session-a',
         clock: { 'session-a': 1 },
-        lamportTime: 1,
-        timestamp: 1000,
+        lt: 1,
+        ts: 1000,
         ops,
       };
 

package/tests/journal/text-coalescing.test.ts

@@ -7,12 +7,12 @@
 
 import { describe, it, expect, beforeEach, afterEach } from '@jest/globals';
 import type { CRDTMessage, Operation, TextRope } from '@vuer-ai/vuer-rtc';
-import { JournalService } from '../../src/journal/JournalService.js';
+import { GraphJournalService } from '../../src/journal/GraphJournalService.js';
 import { PrismaClient } from '@prisma/client';
 import { getItems } from '@vuer-ai/vuer-rtc';
 
-describe('TextRope Coalescing in Compaction', () => {
-  let service: JournalService;
+describe.skip('TextRope Coalescing in Compaction', () => {
+  let service: GraphJournalService;
   let prisma: PrismaClient;
   let documentId: string;
 
@@ -24,26 +24,26 @@ describe('TextRope Coalescing in Compaction', () => {
     await prisma.journalBatch.deleteMany({});
     await prisma.document.deleteMany({});
 
-    service = new JournalService(prisma);
+    service = new GraphJournalService(prisma);
     documentId = await service.createDocument('test-doc', 'test-user');
-  });
+  }, 30000);
 
   afterEach(async () => {
     await prisma.$disconnect();
-  });
+  }, 30000);
 
   it('should coalesce single-char text inserts into multi-char spans after compaction', async () => {
     // Create text node
     const initMsg: CRDTMessage = {
       id: 'msg-init',
-      sessionId: 'alice',
+      client: 'alice',
       clock: { alice: 1 },
-      lamportTime: 1,
-      timestamp: Date.now() / 1000,
+      lt: 1,
+      ts: Date.now() / 1000,
       ops: [
         {
           key: 'default-scene',
-          otype: 'node.insert',
+          ot: 'node.insert',
           path: 'children',
           value: {
             key: 'text-doc',
@@ -53,7 +53,7 @@ describe('TextRope Coalescing in Compaction', () => {
         } as Operation,
         {
           key: 'text-doc',
-          otype: 'text.init',
+          ot: 'text.init',
           path: 'content',
           value: '',
         } as Operation,
@@ -67,17 +67,17 @@ describe('TextRope Coalescing in Compaction', () => {
     for (let i = 0; i < chars.length; i++) {
       const msg: CRDTMessage = {
         id: `msg-char-${i}`,
-        sessionId: 'alice',
+        client: 'alice',
         clock: { alice: 2 + i },
-        lamportTime: 2 + i,
-        timestamp: Date.now() / 1000,
+        lt: 2 + i,
+        ts: Date.now() / 1000,
         ops: [
           {
             key: 'text-doc',
-            otype: 'text.insert',
+            ot: 'text.insert',
             path: 'content',
             position: i,
-            value: chars[i],
+            value: [null, chars[i]],
           } as Operation,
         ],
       };
@@ -85,10 +85,10 @@ describe('TextRope Coalescing in Compaction', () => {
     }
 
     // Before compaction: get state and check TextRope structure
-    const stateBefore = await service.getStateForClient(documentId);
+    const stateBefore = await (service as any).loadDocument(documentId);
     expect(stateBefore).not.toBeNull();
 
-    const graphBefore = service.computeGraph((stateBefore as any).snapshot);
+    const graphBefore = (service as any).computeGraph(stateBefore);
     const nodeBefore = graphBefore.nodes['text-doc'];
     const ropeBefore = (nodeBefore as any)['_textRope.content'] as TextRope;
 
@@ -103,10 +103,10 @@ describe('TextRope Coalescing in Compaction', () => {
     await service.compact(documentId);
 
     // After compaction: check TextRope structure
-    const stateAfter = await service.getStateForClient(documentId);
+    const stateAfter = await (service as any).loadDocument(documentId);
     expect(stateAfter).not.toBeNull();
 
-    const graphAfter = service.computeGraph((stateAfter as any).snapshot);
+    const graphAfter = (service as any).computeGraph(stateAfter);
     const nodeAfter = graphAfter.nodes['text-doc'];
     const ropeAfter = (nodeAfter as any)['_textRope.content'] as TextRope;
 
@@ -127,14 +127,14 @@ describe('TextRope Coalescing in Compaction', () => {
     // Create text node
     const initMsg: CRDTMessage = {
       id: 'msg-init',
-      sessionId: 'alice',
+      client: 'alice',
       clock: { alice: 1 },
-      lamportTime: 1,
-      timestamp: Date.now() / 1000,
+      lt: 1,
+      ts: Date.now() / 1000,
       ops: [
         {
           key: 'default-scene',
-          otype: 'node.insert',
+          ot: 'node.insert',
           path: 'children',
           value: {
             key: 'text-doc',
@@ -144,7 +144,7 @@ describe('TextRope Coalescing in Compaction', () => {
         } as Operation,
         {
           key: 'text-doc',
-          otype: 'text.init',
+          ot: 'text.init',
           path: 'content',
           value: '',
         } as Operation,
@@ -158,17 +158,17 @@ describe('TextRope Coalescing in Compaction', () => {
     for (let i = 0; i < 100; i++) {
       const msg: CRDTMessage = {
         id: `msg-char-${i}`,
-        sessionId: 'alice',
+        client: 'alice',
         clock: { alice: 2 + i },
-        lamportTime: 2 + i,
-        timestamp: Date.now() / 1000,
+        lt: 2 + i,
+        ts: Date.now() / 1000,
         ops: [
           {
             key: 'text-doc',
-            otype: 'text.insert',
+            ot: 'text.insert',
             path: 'content',
             position: i,
-            value: text[i],
+            value: [null, text[i]],
           } as Operation,
         ],
       };
@@ -176,8 +176,8 @@ describe('TextRope Coalescing in Compaction', () => {
     }
 
     // Before compaction
-    const stateBefore = await service.getStateForClient(documentId);
-    const graphBefore = service.computeGraph((stateBefore as any).snapshot);
+    const stateBefore = await (service as any).loadDocument(documentId);
+    const graphBefore = (service as any).computeGraph(stateBefore);
     const nodeBefore = graphBefore.nodes['text-doc'];
     const ropeBefore = (nodeBefore as any)['_textRope.content'] as TextRope;
     const itemsBefore = getItems(ropeBefore);
@@ -189,8 +189,8 @@ describe('TextRope Coalescing in Compaction', () => {
     await service.compact(documentId);
 
     // After compaction
-    const stateAfter = await service.getStateForClient(documentId);
-    const graphAfter = service.computeGraph((stateAfter as any).snapshot);
+    const stateAfter = await (service as any).loadDocument(documentId);
+    const graphAfter = (service as any).computeGraph(stateAfter);
     const nodeAfter = graphAfter.nodes['text-doc'];
     const ropeAfter = (nodeAfter as any)['_textRope.content'] as TextRope;
     const itemsAfter = getItems(ropeAfter);