@vuer-ai/vuer-rtc-server 0.1.1

package/tests/integration/repositories.test.ts

@@ -0,0 +1,320 @@
+import { describe, it, expect, beforeAll, afterAll, beforeEach } from '@jest/globals';
+import type { PrismaClient } from '@prisma/client';
+
+// Repository interfaces we'll implement
+interface IDocumentRepository {
+  create(data: { name: string; ownerId: string }): Promise<any>;
+  findById(id: string): Promise<any | null>;
+  update(id: string, data: any): Promise<any>;
+  delete(id: string): Promise<void>;
+}
+
+interface ISessionRepository {
+  create(data: {
+    documentId: string;
+    userId: string;
+    clientId: string;
+  }): Promise<any>;
+  findById(id: string): Promise<any | null>;
+  findByDocument(documentId: string): Promise<any[]>;
+  updatePresence(id: string, presence: any): Promise<any>;
+  disconnect(id: string): Promise<any>;
+}
+
+// Try to import - will fail until implemented
+let createPrismaClient: () => PrismaClient;
+let DocumentRepository: new (prisma: PrismaClient) => IDocumentRepository;
+let SessionRepository: new (prisma: PrismaClient) => ISessionRepository;
+
+try {
+  const prismaModule = await import('../../src/persistence/PrismaClient.js');
+  const docModule = await import('../../src/persistence/DocumentRepository.js');
+  const sesModule = await import('../../src/persistence/SessionRepository.js');
+
+  createPrismaClient = prismaModule.createPrismaClient;
+  DocumentRepository = docModule.DocumentRepository;
+  SessionRepository = sesModule.SessionRepository;
+} catch {
+  // Not implemented yet
+  createPrismaClient = (() => {
+    throw new Error('Not implemented');
+  }) as any;
+  DocumentRepository = class {
+    create() {
+      throw new Error('Not implemented');
+    }
+    findById() {
+      throw new Error('Not implemented');
+    }
+    update() {
+      throw new Error('Not implemented');
+    }
+    delete() {
+      throw new Error('Not implemented');
+    }
+  } as any;
+  SessionRepository = class {
+    create() {
+      throw new Error('Not implemented');
+    }
+    findById() {
+      throw new Error('Not implemented');
+    }
+    findByDocument() {
+      throw new Error('Not implemented');
+    }
+    updatePresence() {
+      throw new Error('Not implemented');
+    }
+    disconnect() {
+      throw new Error('Not implemented');
+    }
+  } as any;
+}
+
+describe('Database Repositories', () => {
+  let prisma: PrismaClient;
+  let documentRepo: IDocumentRepository;
+  let sessionRepo: ISessionRepository;
+
+  beforeAll(() => {
+    prisma = createPrismaClient();
+    documentRepo = new DocumentRepository(prisma);
+    sessionRepo = new SessionRepository(prisma);
+  });
+
+  afterAll(async () => {
+    await prisma.$disconnect();
+  });
+
+  describe('DocumentRepository', () => {
+    let testDocId: string;
+
+    beforeEach(async () => {
+      // Clean up test data - check existence first to avoid Prisma error logs
+      if (testDocId) {
+        const exists = await documentRepo.findById(testDocId);
+        if (exists) {
+          await documentRepo.delete(testDocId);
+        }
+      }
+    });
+
+    it('should create a new document', async () => {
+      const doc = await documentRepo.create({
+        name: 'Test Document',
+        ownerId: 'user-123',
+      });
+
+      expect(doc).toBeDefined();
+      expect(doc.id).toBeDefined();
+      expect(doc.name).toBe('Test Document');
+      expect(doc.ownerId).toBe('user-123');
+      expect(doc.version).toBe(0);
+      expect(doc.createdAt).toBeDefined();
+      expect(doc.updatedAt).toBeDefined();
+
+      testDocId = doc.id;
+    });
+
+    it('should find document by ID', async () => {
+      const created = await documentRepo.create({
+        name: 'Find Test',
+        ownerId: 'user-456',
+      });
+      testDocId = created.id;
+
+      const found = await documentRepo.findById(created.id);
+
+      expect(found).toBeDefined();
+      expect(found!.id).toBe(created.id);
+      expect(found!.name).toBe('Find Test');
+    });
+
+    it('should return null for non-existent document', async () => {
+      const found = await documentRepo.findById('507f1f77bcf86cd799439011');
+
+      expect(found).toBeNull();
+    });
+
+    it('should update document', async () => {
+      const created = await documentRepo.create({
+        name: 'Original Name',
+        ownerId: 'user-789',
+      });
+      testDocId = created.id;
+
+      const updated = await documentRepo.update(created.id, {
+        name: 'Updated Name',
+        version: 1,
+      });
+
+      expect(updated.name).toBe('Updated Name');
+      expect(updated.version).toBe(1);
+    });
+
+    it('should delete document', async () => {
+      const created = await documentRepo.create({
+        name: 'To Delete',
+        ownerId: 'user-delete',
+      });
+
+      await documentRepo.delete(created.id);
+
+      const found = await documentRepo.findById(created.id);
+      expect(found).toBeNull();
+    });
+  });
+
+  describe('SessionRepository', () => {
+    let testDocId: string;
+    let testSessionId: string;
+
+    beforeAll(async () => {
+      // Create a document for session tests
+      const doc = await documentRepo.create({
+        name: 'Session Test Doc',
+        ownerId: 'user-session',
+      });
+      testDocId = doc.id;
+    });
+
+    afterAll(async () => {
+      if (testDocId) {
+        await documentRepo.delete(testDocId);
+      }
+    });
+
+    beforeEach(async () => {
+      // Clean up test sessions
+      try {
+        if (testSessionId) {
+          const session = await sessionRepo.findById(testSessionId);
+          if (session) {
+            await sessionRepo.disconnect(testSessionId);
+          }
+        }
+      } catch {
+        // Ignore errors
+      }
+    });
+
+    it('should create a new session', async () => {
+      const session = await sessionRepo.create({
+        documentId: testDocId,
+        userId: 'user-123',
+        clientId: 'client-abc',
+      });
+
+      expect(session).toBeDefined();
+      expect(session.id).toBeDefined();
+      expect(session.documentId).toBe(testDocId);
+      expect(session.userId).toBe('user-123');
+      expect(session.clientId).toBe('client-abc');
+      expect(session.clockValue).toBe(0);
+      expect(session.connected).toBe(true);
+      expect(session.connectedAt).toBeDefined();
+
+      testSessionId = session.id;
+    });
+
+    it('should find session by ID', async () => {
+      const created = await sessionRepo.create({
+        documentId: testDocId,
+        userId: 'user-456',
+        clientId: 'client-def',
+      });
+      testSessionId = created.id;
+
+      const found = await sessionRepo.findById(created.id);
+
+      expect(found).toBeDefined();
+      expect(found!.id).toBe(created.id);
+      expect(found!.userId).toBe('user-456');
+    });
+
+    it('should find sessions by document', async () => {
+      const session1 = await sessionRepo.create({
+        documentId: testDocId,
+        userId: 'user-1',
+        clientId: 'client-1',
+      });
+
+      const session2 = await sessionRepo.create({
+        documentId: testDocId,
+        userId: 'user-2',
+        clientId: 'client-2',
+      });
+
+      const sessions = await sessionRepo.findByDocument(testDocId);
+
+      expect(sessions.length).toBeGreaterThanOrEqual(2);
+      expect(sessions.some((s) => s.id === session1.id)).toBe(true);
+      expect(sessions.some((s) => s.id === session2.id)).toBe(true);
+
+      // Cleanup
+      await sessionRepo.disconnect(session1.id);
+      await sessionRepo.disconnect(session2.id);
+    });
+
+    it('should update session presence', async () => {
+      const session = await sessionRepo.create({
+        documentId: testDocId,
+        userId: 'user-presence',
+        clientId: 'client-presence',
+      });
+      testSessionId = session.id;
+
+      const presence = {
+        cursor: { x: 10, y: 20, z: 5 },
+        selection: ['obj-1', 'obj-2'],
+        color: '#00ff00',
+      };
+
+      const updated = await sessionRepo.updatePresence(session.id, presence);
+
+      expect(updated.presence).toBeDefined();
+      expect(updated.presence.cursor).toEqual({ x: 10, y: 20, z: 5 });
+      expect(updated.presence.selection).toEqual(['obj-1', 'obj-2']);
+      expect(updated.presence.color).toBe('#00ff00');
+    });
+
+    it('should disconnect session', async () => {
+      const session = await sessionRepo.create({
+        documentId: testDocId,
+        userId: 'user-disconnect',
+        clientId: 'client-disconnect',
+      });
+
+      const disconnected = await sessionRepo.disconnect(session.id);
+
+      expect(disconnected.connected).toBe(false);
+      expect(disconnected.disconnectedAt).toBeDefined();
+    });
+
+    it('should filter connected sessions', async () => {
+      const session1 = await sessionRepo.create({
+        documentId: testDocId,
+        userId: 'user-active-1',
+        clientId: 'client-active-1',
+      });
+
+      const session2 = await sessionRepo.create({
+        documentId: testDocId,
+        userId: 'user-active-2',
+        clientId: 'client-active-2',
+      });
+
+      await sessionRepo.disconnect(session2.id);
+
+      const allSessions = await sessionRepo.findByDocument(testDocId);
+      const connectedSessions = allSessions.filter((s) => s.connected);
+
+      expect(connectedSessions.some((s) => s.id === session1.id)).toBe(true);
+      expect(connectedSessions.some((s) => s.id === session2.id)).toBe(false);
+
+      // Cleanup
+      await sessionRepo.disconnect(session1.id);
+    });
+  });
+});

package/tests/journal/journal-service.test.ts

@@ -0,0 +1,185 @@
+/**
+ * Tests for JournalService
+ *
+ * Note: These are integration tests that require a MongoDB connection.
+ * For unit tests, we mock the repositories.
+ */
+
+import { describe, it, expect, beforeEach, jest } from '@jest/globals';
+import { readFileSync } from 'fs';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+import type { CRDTMessage, SceneGraph } from '@vuer-ai/vuer-rtc';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+interface MessageFixture {
+  name: string;
+  msg: CRDTMessage;
+}
+
+function loadFixtures(): MessageFixture[] {
+  const filepath = join(__dirname, '../fixtures/messages.jsonl');
+  const content = readFileSync(filepath, 'utf-8');
+  return content
+    .trim()
+    .split('\n')
+    .map((line) => JSON.parse(line));
+}
+
+describe('JournalService', () => {
+  let fixtures: MessageFixture[];
+
+  beforeEach(() => {
+    fixtures = loadFixtures();
+  });
+
+  describe('Message Fixtures', () => {
+    it('should load fixtures correctly', () => {
+      expect(fixtures).toHaveLength(4);
+      expect(fixtures[0].name).toBe('simple_edit');
+      expect(fixtures[1].name).toBe('additive_edit');
+      expect(fixtures[2].name).toBe('undo_edit');
+      expect(fixtures[3].name).toBe('redo_edit');
+    });
+
+    it('should have valid CRDTMessage structure', () => {
+      for (const fixture of fixtures) {
+        const msg = fixture.msg;
+        expect(msg.id).toBeDefined();
+        expect(msg.sessionId).toBeDefined();
+        expect(msg.clock).toBeDefined();
+        expect(msg.lamportTime).toBeGreaterThanOrEqual(0);
+        expect(msg.timestamp).toBeGreaterThan(0);
+        expect(Array.isArray(msg.ops)).toBe(true);
+      }
+    });
+
+    it('should have valid meta.undo operation', () => {
+      const undoFixture = fixtures.find((f) => f.name === 'undo_edit');
+      expect(undoFixture).toBeDefined();
+
+      const undoOp = undoFixture!.msg.ops[0];
+      expect(undoOp.otype).toBe('meta.undo');
+      expect(undoOp.key).toBe('_meta');
+      expect((undoOp as any).targetMsgId).toBe('msg-1');
+    });
+
+    it('should have valid meta.redo operation', () => {
+      const redoFixture = fixtures.find((f) => f.name === 'redo_edit');
+      expect(redoFixture).toBeDefined();
+
+      const redoOp = redoFixture!.msg.ops[0];
+      expect(redoOp.otype).toBe('meta.redo');
+      expect(redoOp.key).toBe('_meta');
+      expect((redoOp as any).targetMsgId).toBe('msg-1');
+    });
+  });
+
+  describe('Message Validation', () => {
+    it('should validate simple edit message', async () => {
+      const { OperationValidator } = await import('@vuer-ai/vuer-rtc');
+      const validator = new OperationValidator();
+
+      const simpleEdit = fixtures.find((f) => f.name === 'simple_edit');
+      const result = validator.validateMessage(simpleEdit!.msg);
+
+      expect(result.valid).toBe(true);
+    });
+
+    it('should validate undo message', async () => {
+      const { OperationValidator } = await import('@vuer-ai/vuer-rtc');
+      const validator = new OperationValidator();
+
+      const undoEdit = fixtures.find((f) => f.name === 'undo_edit');
+      const result = validator.validateMessage(undoEdit!.msg);
+
+      expect(result.valid).toBe(true);
+    });
+
+    it('should validate redo message', async () => {
+      const { OperationValidator } = await import('@vuer-ai/vuer-rtc');
+      const validator = new OperationValidator();
+
+      const redoEdit = fixtures.find((f) => f.name === 'redo_edit');
+      const result = validator.validateMessage(redoEdit!.msg);
+
+      expect(result.valid).toBe(true);
+    });
+  });
+
+  describe('Graph Computation', () => {
+    it('should apply simple edit to empty graph', async () => {
+      const { createEmptyGraph, applyMessage } = await import('@vuer-ai/vuer-rtc');
+
+      // First create a node (key=parent, path='children', value.key=new node)
+      const nodeMsg: CRDTMessage = {
+        id: 'node-msg',
+        sessionId: 'session-1',
+        clock: { 'session-1': 0 },
+        lamportTime: 0,
+        timestamp: Date.now() / 1000,
+        ops: [
+          {
+            key: '',  // No parent for root node
+            otype: 'node.insert',
+            path: 'children',
+            value: {
+              key: 'cube-1',
+              tag: 'Mesh',
+              name: 'Cube',
+              position: [0, 0, 0],
+            },
+          },
+        ],
+      };
+
+      let graph = createEmptyGraph();
+      graph = applyMessage(graph, nodeMsg);
+
+      expect(graph.nodes['cube-1']).toBeDefined();
+      expect(graph.nodes['cube-1'].position).toEqual([0, 0, 0]);
+
+      // Now apply the simple edit
+      const simpleEdit = fixtures.find((f) => f.name === 'simple_edit');
+      graph = applyMessage(graph, simpleEdit!.msg);
+
+      expect(graph.nodes['cube-1'].position).toEqual([1, 2, 3]);
+    });
+
+    it('should apply additive edit', async () => {
+      const { createEmptyGraph, applyMessage } = await import('@vuer-ai/vuer-rtc');
+
+      // Create node (key=parent, path='children', value.key=new node)
+      const nodeMsg: CRDTMessage = {
+        id: 'node-msg',
+        sessionId: 'session-1',
+        clock: { 'session-1': 0 },
+        lamportTime: 0,
+        timestamp: Date.now() / 1000,
+        ops: [
+          {
+            key: '',  // No parent for root node
+            otype: 'node.insert',
+            path: 'children',
+            value: {
+              key: 'cube-1',
+              tag: 'Mesh',
+              name: 'Cube',
+              position: [0, 0, 0],
+            },
+          },
+        ],
+      };
+
+      let graph = createEmptyGraph();
+      graph = applyMessage(graph, nodeMsg);
+
+      // Apply additive edit
+      const additiveEdit = fixtures.find((f) => f.name === 'additive_edit');
+      graph = applyMessage(graph, additiveEdit!.msg);
+
+      expect(graph.nodes['cube-1'].position).toEqual([0.1, 0.2, 0.3]);
+    });
+  });
+});