@voidhash/mimic 0.0.4 → 0.0.6

package/tests/client/ClientDocument.test.ts

@@ -201,18 +201,325 @@ describe("ClientDocument", () => {
       expect(transport.sentTransactions[0]!.ops[0]!.kind).toBe("number.set");
     });
 
-    it("should throw when not connected", () => {
+    it("should queue transactions when not connected", () => {
       const client = ClientDocument.make({
         schema: TestSchema,
         transport,
         initialState: { title: "", count: 0, items: [] },
       });
 
+      // Transactions should work offline - they get queued in the transport
+      client.transaction((root) => {
+        root.title.set("Test");
+      });
+
+      // State should be optimistically updated
+      expect(client.get()?.title).toBe("Test");
+      // Transaction is pending
+      expect(client.hasPendingChanges()).toBe(true);
+      // Transaction was sent to transport (it will queue it)
+      expect(transport.sentTransactions.length).toBe(1);
+    });
+
+    it("should queue multiple transactions when not connected", () => {
+      const client = ClientDocument.make({
+        schema: TestSchema,
+        transport,
+        initialState: { title: "", count: 0, items: [] },
+      });
+
+      // Create multiple transactions while offline
+      client.transaction((root) => {
+        root.title.set("First");
+      });
+
+      client.transaction((root) => {
+        root.count.set(10);
+      });
+
+      client.transaction((root) => {
+        root.title.set("Second");
+      });
+
+      // All state changes should be applied optimistically
+      expect(client.get()?.title).toBe("Second");
+      expect(client.get()?.count).toBe(10);
+      // All transactions are pending
+      expect(client.getPendingCount()).toBe(3);
+      // All transactions were sent to transport
+      expect(transport.sentTransactions.length).toBe(3);
+    });
+
+    it("should throw when not ready (no initial state)", () => {
+      const client = ClientDocument.make({
+        schema: TestSchema,
+        transport,
+        // No initial state - client is not ready until snapshot received
+      });
+
       expect(() => {
         client.transaction((root) => {
           root.title.set("Test");
         });
-      }).toThrow("Transport is not connected");
+      }).toThrow("Client is not ready");
+    });
+  });
+
+  describe("offline transaction handling", () => {
+    it("should confirm queued transactions after reconnection", async () => {
+      const client = ClientDocument.make({
+        schema: TestSchema,
+        transport,
+        initialState: { title: "", count: 0, items: [] },
+      });
+
+      // Create transaction while offline
+      client.transaction((root) => {
+        root.title.set("Offline Change");
+      });
+
+      expect(client.hasPendingChanges()).toBe(true);
+      const pendingTx = transport.sentTransactions[0]!;
+
+      // Connect and simulate server confirming the transaction
+      await client.connect();
+
+      // Server broadcasts our transaction (confirming it)
+      transport.simulateServerMessage({
+        type: "transaction",
+        transaction: pendingTx,
+        version: 1,
+      });
+
+      // Transaction should be confirmed
+      expect(client.hasPendingChanges()).toBe(false);
+      expect(client.get()?.title).toBe("Offline Change");
+      expect(client.getServerState()?.title).toBe("Offline Change");
+    });
+
+    it("should handle multiple queued transactions being confirmed in order", async () => {
+      const client = ClientDocument.make({
+        schema: TestSchema,
+        transport,
+        initialState: { title: "", count: 0, items: [] },
+      });
+
+      // Create multiple transactions while offline
+      client.transaction((root) => {
+        root.title.set("First");
+      });
+
+      client.transaction((root) => {
+        root.count.set(42);
+      });
+
+      expect(client.getPendingCount()).toBe(2);
+      const tx1 = transport.sentTransactions[0]!;
+      const tx2 = transport.sentTransactions[1]!;
+
+      // Connect
+      await client.connect();
+
+      // Server confirms first transaction
+      transport.simulateServerMessage({
+        type: "transaction",
+        transaction: tx1,
+        version: 1,
+      });
+
+      expect(client.getPendingCount()).toBe(1);
+      expect(client.getServerState()?.title).toBe("First");
+
+      // Server confirms second transaction
+      transport.simulateServerMessage({
+        type: "transaction",
+        transaction: tx2,
+        version: 2,
+      });
+
+      expect(client.getPendingCount()).toBe(0);
+      expect(client.getServerState()?.count).toBe(42);
+    });
+
+    it("should handle rejection of queued transactions", async () => {
+      let rejectedTx: Transaction.Transaction | null = null;
+      let rejectionReason: string | null = null;
+
+      const client = ClientDocument.make({
+        schema: TestSchema,
+        transport,
+        initialState: { title: "Original", count: 0, items: [] },
+        onRejection: (tx, reason) => {
+          rejectedTx = tx;
+          rejectionReason = reason;
+        },
+      });
+
+      // Create transaction while offline
+      client.transaction((root) => {
+        root.title.set("Offline Change");
+      });
+
+      const pendingTx = transport.sentTransactions[0]!;
+
+      // Connect
+      await client.connect();
+
+      // Server rejects the transaction
+      transport.simulateServerMessage({
+        type: "error",
+        transactionId: pendingTx.id,
+        reason: "Conflict with another user",
+      });
+
+      // Transaction should be removed from pending
+      expect(client.hasPendingChanges()).toBe(false);
+      // Optimistic state should revert to server state
+      expect(client.get()?.title).toBe("Original");
+      // Rejection callback should be called
+      expect(rejectedTx).not.toBeNull();
+      expect(rejectionReason).toBe("Conflict with another user");
+    });
+
+    it("should rebase queued transactions against concurrent server changes", async () => {
+      const client = ClientDocument.make({
+        schema: TestSchema,
+        transport,
+        initialState: { title: "", count: 0, items: [] },
+      });
+
+      // Create transaction while offline
+      client.transaction((root) => {
+        root.title.set("My Title");
+      });
+
+      await client.connect();
+
+      // Another user's change comes in first
+      const otherUserTx = Transaction.make([
+        {
+          kind: "number.set" as const,
+          path: OperationPath.make("count"),
+          payload: 100,
+        },
+      ]);
+
+      transport.simulateServerMessage({
+        type: "transaction",
+        transaction: otherUserTx,
+        version: 1,
+      });
+
+      // Our transaction should still be pending
+      expect(client.hasPendingChanges()).toBe(true);
+      // Server state should reflect other user's change
+      expect(client.getServerState()?.count).toBe(100);
+      // Optimistic state should have both changes
+      expect(client.get()?.count).toBe(100);
+      expect(client.get()?.title).toBe("My Title");
+    });
+
+    it("should work with disconnect and reconnect cycle", async () => {
+      const client = ClientDocument.make({
+        schema: TestSchema,
+        transport,
+        initialState: { title: "", count: 0, items: [] },
+      });
+
+      // Connect first
+      await client.connect();
+
+      client.transaction((root) => {
+        root.title.set("Online Change");
+      });
+
+      // Disconnect
+      client.disconnect();
+
+      // Create transaction while disconnected
+      client.transaction((root) => {
+        root.count.set(50);
+      });
+
+      // State should still be optimistically updated
+      expect(client.get()?.title).toBe("Online Change");
+      expect(client.get()?.count).toBe(50);
+      expect(client.getPendingCount()).toBe(2);
+
+      // Reconnect
+      await client.connect();
+
+      // Server confirms both transactions
+      transport.simulateServerMessage({
+        type: "transaction",
+        transaction: transport.sentTransactions[0]!,
+        version: 1,
+      });
+
+      transport.simulateServerMessage({
+        type: "transaction",
+        transaction: transport.sentTransactions[1]!,
+        version: 2,
+      });
+
+      expect(client.hasPendingChanges()).toBe(false);
+      expect(client.getServerState()?.title).toBe("Online Change");
+      expect(client.getServerState()?.count).toBe(50);
+    });
+
+    it("should preserve pending transactions during brief disconnection", async () => {
+      const client = ClientDocument.make({
+        schema: TestSchema,
+        transport,
+        initialState: { title: "", count: 0, items: [] },
+      });
+
+      await client.connect();
+
+      // Create a transaction
+      client.transaction((root) => {
+        root.title.set("Before Disconnect");
+      });
+
+      const pendingCount = client.getPendingCount();
+      expect(pendingCount).toBe(1);
+
+      // Simulate brief disconnection
+      client.disconnect();
+
+      // Pending transactions should still be there
+      expect(client.getPendingCount()).toBe(pendingCount);
+      expect(client.get()?.title).toBe("Before Disconnect");
+    });
+
+    it("should handle multiple field changes while offline", () => {
+      const client = ClientDocument.make({
+        schema: TestSchema,
+        transport,
+        initialState: { title: "", count: 0, items: [] },
+      });
+
+      // Create multiple transactions affecting different fields while offline
+      client.transaction((root) => {
+        root.title.set("First Title");
+      });
+
+      client.transaction((root) => {
+        root.count.set(10);
+      });
+
+      client.transaction((root) => {
+        root.title.set("Final Title");
+        root.count.set(20);
+      });
+
+      // All changes should be applied optimistically
+      expect(client.get()?.title).toBe("Final Title");
+      expect(client.get()?.count).toBe(20);
+
+      // All transactions queued
+      expect(transport.sentTransactions.length).toBe(3);
+      expect(client.getPendingCount()).toBe(3);
     });
   });
 

package/tests/client/WebSocketTransport.test.ts

@@ -349,6 +349,196 @@ describe("WebSocketTransport", () => {
       const sent = JSON.parse(newWs.sentMessages[1]!);
       expect(sent.type).toBe("submit");
     });
+
+    it("should queue messages when disconnected (never connected)", () => {
+      const transport = WebSocketTransport.make({
+        url: "ws://localhost:8080",
+      });
+
+      // Queue message before connecting
+      const tx = Transaction.make([
+        {
+          kind: "string.set" as const,
+          path: OperationPath.make("title"),
+          payload: "offline",
+        },
+      ]);
+      transport.send(tx);
+
+      // No WebSocket created yet
+      expect(MockWebSocket.instances.length).toBe(0);
+
+      // Message should be queued internally
+      // (We can't directly verify the queue, but we can verify it's sent after connect)
+    });
+
+    it("should send queued messages after initial connection", async () => {
+      const transport = WebSocketTransport.make({
+        url: "ws://localhost:8080",
+      });
+
+      // Queue messages before connecting
+      const tx1 = Transaction.make([
+        {
+          kind: "string.set" as const,
+          path: OperationPath.make("title"),
+          payload: "first",
+        },
+      ]);
+      const tx2 = Transaction.make([
+        {
+          kind: "number.set" as const,
+          path: OperationPath.make("count"),
+          payload: 42,
+        },
+      ]);
+      transport.send(tx1);
+      transport.send(tx2);
+
+      // Now connect
+      const connectPromise = transport.connect();
+      const ws = MockWebSocket.getLatest()!;
+      await ws.simulateOpenWithAuth();
+      await connectPromise;
+
+      // Should have sent: auth + 2 queued transactions
+      expect(ws.sentMessages.length).toBe(3);
+
+      const authMsg = JSON.parse(ws.sentMessages[0]!);
+      expect(authMsg.type).toBe("auth");
+
+      const sent1 = JSON.parse(ws.sentMessages[1]!);
+      expect(sent1.type).toBe("submit");
+      expect(sent1.transaction.id).toBe(tx1.id);
+
+      const sent2 = JSON.parse(ws.sentMessages[2]!);
+      expect(sent2.type).toBe("submit");
+      expect(sent2.transaction.id).toBe(tx2.id);
+    });
+
+    it("should queue multiple messages during disconnection", async () => {
+      const transport = WebSocketTransport.make({
+        url: "ws://localhost:8080",
+        autoReconnect: true,
+      });
+
+      const connectPromise = transport.connect();
+      const ws = MockWebSocket.getLatest()!;
+      await ws.simulateOpenWithAuth();
+      await connectPromise;
+
+      // Simulate connection lost
+      ws.simulateClose(1006, "Connection lost");
+
+      // Queue multiple messages during disconnection
+      const tx1 = Transaction.make([
+        {
+          kind: "string.set" as const,
+          path: OperationPath.make("title"),
+          payload: "change1",
+        },
+      ]);
+      const tx2 = Transaction.make([
+        {
+          kind: "string.set" as const,
+          path: OperationPath.make("title"),
+          payload: "change2",
+        },
+      ]);
+      const tx3 = Transaction.make([
+        {
+          kind: "number.set" as const,
+          path: OperationPath.make("count"),
+          payload: 100,
+        },
+      ]);
+
+      transport.send(tx1);
+      transport.send(tx2);
+      transport.send(tx3);
+
+      // Reconnect
+      vi.advanceTimersByTime(1000);
+      const newWs = MockWebSocket.getLatest()!;
+      await newWs.simulateOpenWithAuth();
+
+      // Should have sent: auth + 3 queued transactions
+      expect(newWs.sentMessages.length).toBe(4);
+
+      const authMsg = JSON.parse(newWs.sentMessages[0]!);
+      expect(authMsg.type).toBe("auth");
+
+      // Verify all transactions were sent in order
+      const sent1 = JSON.parse(newWs.sentMessages[1]!);
+      expect(sent1.transaction.id).toBe(tx1.id);
+
+      const sent2 = JSON.parse(newWs.sentMessages[2]!);
+      expect(sent2.transaction.id).toBe(tx2.id);
+
+      const sent3 = JSON.parse(newWs.sentMessages[3]!);
+      expect(sent3.transaction.id).toBe(tx3.id);
+    });
+
+    it("should preserve queue across multiple reconnection attempts", async () => {
+      const transport = WebSocketTransport.make({
+        url: "ws://localhost:8080",
+        autoReconnect: true,
+        reconnectDelay: 100,
+      });
+
+      const connectPromise = transport.connect();
+      const ws = MockWebSocket.getLatest()!;
+      await ws.simulateOpenWithAuth();
+      await connectPromise;
+
+      // Simulate connection lost
+      ws.simulateClose(1006, "Connection lost");
+
+      // Queue message
+      const tx = Transaction.make([
+        {
+          kind: "string.set" as const,
+          path: OperationPath.make("title"),
+          payload: "important",
+        },
+      ]);
+      transport.send(tx);
+
+      // First reconnection attempt fails
+      vi.advanceTimersByTime(100);
+      MockWebSocket.getLatest()!.simulateClose(1006, "Failed again");
+
+      // Second reconnection attempt succeeds
+      vi.advanceTimersByTime(200);
+      const finalWs = MockWebSocket.getLatest()!;
+      await finalWs.simulateOpenWithAuth();
+
+      // Queued message should still be sent
+      expect(finalWs.sentMessages.length).toBe(2);
+      const sent = JSON.parse(finalWs.sentMessages[1]!);
+      expect(sent.type).toBe("submit");
+      expect(sent.transaction.id).toBe(tx.id);
+    });
+
+    it("should queue snapshot requests when disconnected", async () => {
+      const transport = WebSocketTransport.make({
+        url: "ws://localhost:8080",
+      });
+
+      // Queue snapshot request before connecting
+      transport.requestSnapshot();
+
+      // Connect
+      const connectPromise = transport.connect();
+      const ws = MockWebSocket.getLatest()!;
+      await ws.simulateOpenWithAuth();
+      await connectPromise;
+
+      // Should have sent: auth + request_snapshot
+      expect(ws.sentMessages.length).toBe(2);
+      const sent = JSON.parse(ws.sentMessages[1]!);
+      expect(sent.type).toBe("request_snapshot");
+    });
   });
 
   describe("requestSnapshot", () => {
@@ -811,16 +1001,51 @@ describe("WebSocketTransport", () => {
         expect(sent.data).toEqual({ cursor: { x: 50, y: 75 } });
       });
 
-      it("should not send when disconnected", async () => {
+      it("should queue presence_set when disconnected and send after connect", async () => {
         const transport = WebSocketTransport.make({
           url: "ws://localhost:8080",
         });
 
-        // Never connect - sendPresenceSet should be silently ignored
+        // Queue presence before connecting
         transport.sendPresenceSet({ x: 100, y: 200 });
 
-        // No WebSocket created, nothing sent
+        // No WebSocket created yet
         expect(MockWebSocket.instances.length).toBe(0);
+
+        // Now connect
+        const connectPromise = transport.connect();
+        const ws = MockWebSocket.getLatest()!;
+        await ws.simulateOpenWithAuth();
+        await connectPromise;
+
+        // Should have sent: auth + presence_set
+        expect(ws.sentMessages.length).toBe(2);
+        const sent = JSON.parse(ws.sentMessages[1]!);
+        expect(sent.type).toBe("presence_set");
+        expect(sent.data).toEqual({ x: 100, y: 200 });
+      });
+
+      it("should only keep latest presence_set when multiple are queued", async () => {
+        const transport = WebSocketTransport.make({
+          url: "ws://localhost:8080",
+        });
+
+        // Queue multiple presence updates before connecting
+        transport.sendPresenceSet({ x: 100, y: 200 });
+        transport.sendPresenceSet({ x: 150, y: 250 });
+        transport.sendPresenceSet({ x: 200, y: 300 });
+
+        // Now connect
+        const connectPromise = transport.connect();
+        const ws = MockWebSocket.getLatest()!;
+        await ws.simulateOpenWithAuth();
+        await connectPromise;
+
+        // Should have sent: auth + only the latest presence_set
+        expect(ws.sentMessages.length).toBe(2);
+        const sent = JSON.parse(ws.sentMessages[1]!);
+        expect(sent.type).toBe("presence_set");
+        expect(sent.data).toEqual({ x: 200, y: 300 });
       });
     });