@multiplatform.one/frappe 6.0.0

package/dist/esm/sync/rehydration.spec.mjs

@@ -0,0 +1,732 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { RehydrationManager } from "./rehydration.mjs";
+import { Operation, Order, PendingRehydrationType, RehydrationReason, RehydrationStrategyType, Status } from "./types.mjs";
+describe("RehydrationManager", () => {
+  let rehydrationManager;
+  let mockDb;
+  let mockCache;
+  let mockSubscriptionManager;
+  let mockMutationJournal;
+  const mockDoc = {
+    name: "test-doc",
+    doctype: "TestDoc",
+    title: "Test Document",
+    modified: "2024-01-01T10:00:00",
+    creation: "2024-01-01T09:00:00",
+    owner: "test-user",
+    modified_by: "test-user"
+  };
+  const mockSubscription = {
+    id: "sub1",
+    query: {
+      doctype: "TestDoc",
+      fields: ["*"],
+      filters: {},
+      orderBy: {
+        field: "modified",
+        order: Order.Desc
+      },
+      limit: 20
+    },
+    docIds: ["doc1", "doc2", "doc3"],
+    checkpoint: "checkpoint1",
+    metadata: {},
+    boundaries: {
+      firstItem: {
+        ...mockDoc,
+        name: "doc1"
+      },
+      lastItem: {
+        ...mockDoc,
+        name: "doc3"
+      },
+      offset: 0,
+      pageSize: 20
+    }
+  };
+  beforeEach(() => {
+    vi.useFakeTimers();
+    mockDb = {
+      getDoc: vi.fn().mockResolvedValue(mockDoc),
+      getDocList: vi.fn().mockResolvedValue([{
+        ...mockDoc,
+        name: "fresh-doc1"
+      }, {
+        ...mockDoc,
+        name: "fresh-doc2"
+      }, {
+        ...mockDoc,
+        name: "fresh-doc3"
+      }])
+    };
+    mockCache = {
+      upsert: vi.fn(),
+      get: vi.fn().mockReturnValue(mockDoc),
+      remove: vi.fn()
+    };
+    mockSubscriptionManager = {
+      getSubscription: vi.fn().mockReturnValue(mockSubscription),
+      resortSubscriptionDocIds: vi.fn()
+    };
+    mockMutationJournal = {
+      listPending: vi.fn().mockReturnValue([])
+    };
+    vi.spyOn(console, "error").mockImplementation(() => {});
+    vi.spyOn(console, "warn").mockImplementation(() => {});
+    mockSubscription.docIds = ["doc1", "doc2", "doc3"];
+    mockSubscription.pendingRehydration = void 0;
+    mockSubscription.boundaries = {
+      firstItem: {
+        ...mockDoc,
+        name: "doc1"
+      },
+      lastItem: {
+        ...mockDoc,
+        name: "doc3"
+      },
+      offset: 0,
+      pageSize: 20
+    };
+  });
+  afterEach(() => {
+    if (rehydrationManager) {
+      rehydrationManager.clear();
+      rehydrationManager = void 0;
+    }
+    vi.restoreAllMocks();
+    vi.useRealTimers();
+  });
+  describe("constructor", () => {
+    it("should initialize successfully", () => {
+      rehydrationManager = new RehydrationManager(mockDb, mockCache, mockSubscriptionManager, mockMutationJournal);
+      expect(rehydrationManager).toBeDefined();
+    });
+  });
+  describe("scheduleRehydration", () => {
+    beforeEach(() => {
+      rehydrationManager = new RehydrationManager(mockDb, mockCache, mockSubscriptionManager, mockMutationJournal);
+    });
+    it("should schedule rehydration for create operations", async () => {
+      rehydrationManager.scheduleRehydration(mockSubscription, RehydrationReason.Create);
+      vi.advanceTimersByTime(100);
+      await vi.runAllTimersAsync();
+      expect(mockDb.getDoc).not.toHaveBeenCalled();
+    });
+    it("should schedule rehydration for delete operations", async () => {
+      rehydrationManager.scheduleRehydration(mockSubscription, RehydrationReason.Delete);
+      vi.advanceTimersByTime(500);
+      await vi.runAllTimersAsync();
+      expect(mockDb.getDocList).toHaveBeenCalledWith("TestDoc", {
+        fields: ["*"],
+        filters: {},
+        orderBy: {
+          field: "modified",
+          order: Order.Desc
+        },
+        limitStart: 0,
+        limit: 20
+      });
+    });
+    it("should schedule rehydration for remote-create operations", async () => {
+      rehydrationManager.scheduleRehydration(mockSubscription, RehydrationReason.RemoteCreate);
+      vi.advanceTimersByTime(500);
+      await vi.runAllTimersAsync();
+      expect(mockDb.getDocList).toHaveBeenCalled();
+    });
+    it("should schedule rehydration for overflow operations", async () => {
+      rehydrationManager.scheduleRehydration(mockSubscription, RehydrationReason.Overflow);
+      vi.advanceTimersByTime(1e3);
+      await vi.runAllTimersAsync();
+      expect(mockDb.getDocList).toHaveBeenCalled();
+    });
+    it("should schedule rehydration for uncertain operations", async () => {
+      rehydrationManager.scheduleRehydration(mockSubscription, RehydrationReason.Uncertain);
+      vi.advanceTimersByTime(2e3);
+      await vi.runAllTimersAsync();
+      expect(mockDb.getDocList).toHaveBeenCalled();
+    });
+    it("should coalesce multiple requests for same subscription", async () => {
+      rehydrationManager.scheduleRehydration(mockSubscription, RehydrationReason.Create);
+      rehydrationManager.scheduleRehydration(mockSubscription, RehydrationReason.Create);
+      rehydrationManager.scheduleRehydration(mockSubscription, RehydrationReason.Create);
+      vi.advanceTimersByTime(100);
+      await vi.runAllTimersAsync();
+      const queueSize = rehydrationManager.rehydrationQueue.size;
+      expect(queueSize).toBe(0);
+    });
+    it("should upgrade task priority when higher priority task is scheduled", async () => {
+      rehydrationManager.scheduleRehydration(mockSubscription, RehydrationReason.Uncertain);
+      rehydrationManager.scheduleRehydration(mockSubscription, RehydrationReason.Delete);
+      vi.advanceTimersByTime(500);
+      await vi.runAllTimersAsync();
+      expect(mockDb.getDocList).toHaveBeenCalled();
+    });
+    it("should not downgrade task priority", async () => {
+      rehydrationManager.scheduleRehydration(mockSubscription, RehydrationReason.Delete);
+      rehydrationManager.scheduleRehydration(mockSubscription, RehydrationReason.Uncertain);
+      vi.advanceTimersByTime(500);
+      await vi.runAllTimersAsync();
+      expect(mockDb.getDocList).toHaveBeenCalled();
+    });
+  });
+  describe("strategy determination", () => {
+    beforeEach(() => {
+      rehydrationManager = new RehydrationManager(mockDb, mockCache, mockSubscriptionManager, mockMutationJournal);
+    });
+    it("should return correct strategy for create", () => {
+      const manager = rehydrationManager;
+      const strategy = manager.determineStrategy(RehydrationReason.Create);
+      expect(strategy).toEqual({
+        type: RehydrationStrategyType.FetchItemOnly,
+        priority: 1,
+        delay: 100
+      });
+    });
+    it("should return correct strategy for remote-create", () => {
+      const manager = rehydrationManager;
+      const strategy = manager.determineStrategy(RehydrationReason.RemoteCreate);
+      expect(strategy).toEqual({
+        type: RehydrationStrategyType.FullRefresh,
+        priority: 2,
+        delay: 500
+      });
+    });
+    it("should return correct strategy for delete", () => {
+      const manager = rehydrationManager;
+      const strategy = manager.determineStrategy(RehydrationReason.Delete);
+      expect(strategy).toEqual({
+        type: RehydrationStrategyType.FullRefresh,
+        priority: 3,
+        delay: 500
+      });
+    });
+    it("should return correct strategy for overflow", () => {
+      const manager = rehydrationManager;
+      const strategy = manager.determineStrategy(RehydrationReason.Overflow);
+      expect(strategy).toEqual({
+        type: RehydrationStrategyType.FullRefresh,
+        priority: 2,
+        delay: 1e3
+      });
+    });
+    it("should return correct strategy for uncertain", () => {
+      const manager = rehydrationManager;
+      const strategy = manager.determineStrategy(RehydrationReason.Uncertain);
+      expect(strategy).toEqual({
+        type: RehydrationStrategyType.FullRefresh,
+        priority: 1,
+        delay: 2e3
+      });
+    });
+    it("should return default strategy for unknown reason", () => {
+      const manager = rehydrationManager;
+      const strategy = manager.determineStrategy("unknown");
+      expect(strategy).toEqual({
+        type: RehydrationStrategyType.FullRefresh,
+        priority: 1,
+        delay: 1e3
+      });
+    });
+  });
+  describe("processing queue", () => {
+    beforeEach(() => {
+      rehydrationManager = new RehydrationManager(mockDb, mockCache, mockSubscriptionManager, mockMutationJournal);
+    });
+    it("should process tasks in priority order", async () => {
+      const calls = [];
+      const sub1 = {
+        ...mockSubscription,
+        id: "sub1"
+      };
+      const sub2 = {
+        ...mockSubscription,
+        id: "sub2"
+      };
+      const sub3 = {
+        ...mockSubscription,
+        id: "sub3"
+      };
+      mockSubscriptionManager.getSubscription.mockImplementation(id => {
+        if (id === "sub1") return sub1;
+        if (id === "sub2") return sub2;
+        if (id === "sub3") return sub3;
+        return null;
+      });
+      mockDb.getDocList.mockImplementation(async doctype => {
+        calls.push(doctype);
+        return [];
+      });
+      rehydrationManager.scheduleRehydration(sub1, RehydrationReason.Uncertain);
+      rehydrationManager.scheduleRehydration(sub2, RehydrationReason.Delete);
+      rehydrationManager.scheduleRehydration(sub3, RehydrationReason.Overflow);
+      vi.advanceTimersByTime(2e3);
+      await vi.runAllTimersAsync();
+      expect(calls).toEqual(["TestDoc", "TestDoc", "TestDoc"]);
+    });
+    it("should handle processing errors gracefully", async () => {
+      mockDb.getDocList.mockRejectedValue(new Error("Network error"));
+      rehydrationManager.scheduleRehydration(mockSubscription, RehydrationReason.Delete);
+      vi.advanceTimersByTime(500);
+      await vi.runAllTimersAsync();
+      expect(console.error).toHaveBeenCalledWith(expect.stringContaining("Rehydration failed for sub1"), expect.any(Error));
+    });
+    it("should clear pending rehydration flag after successful execution", async () => {
+      mockSubscription.pendingRehydration = PendingRehydrationType.FullRefresh;
+      rehydrationManager.scheduleRehydration(mockSubscription, RehydrationReason.Delete);
+      vi.advanceTimersByTime(500);
+      await vi.runAllTimersAsync();
+      expect(mockSubscription.pendingRehydration).toBeUndefined();
+    });
+    it("should skip processing for non-existent subscriptions", async () => {
+      mockSubscriptionManager.getSubscription.mockReturnValue(null);
+      rehydrationManager.scheduleRehydration(mockSubscription, RehydrationReason.Delete);
+      vi.advanceTimersByTime(500);
+      await vi.runAllTimersAsync();
+      expect(mockDb.getDocList).not.toHaveBeenCalled();
+    });
+  });
+  describe("fetch optimistic items", () => {
+    beforeEach(() => {
+      rehydrationManager = new RehydrationManager(mockDb, mockCache, mockSubscriptionManager, mockMutationJournal);
+    });
+    it("should fetch items with registered temp ID mappings", async () => {
+      rehydrationManager.registerTempIdMapping("temp-123", "TASK-001");
+      const pendingCreate = {
+        doctype: "TestDoc",
+        docname: "temp-123",
+        values: {
+          title: "New Task"
+        },
+        operation: Operation.Create,
+        status: Status.Pending
+      };
+      mockMutationJournal.listPending.mockReturnValue([{
+        id: "mut1",
+        entry: pendingCreate
+      }]);
+      rehydrationManager.scheduleRehydration(mockSubscription, RehydrationReason.Create);
+      vi.advanceTimersByTime(100);
+      await vi.runAllTimersAsync();
+      expect(mockDb.getDoc).toHaveBeenCalledWith("TestDoc", "TASK-001");
+      expect(mockCache.upsert).toHaveBeenCalledWith(mockDoc);
+    });
+    it("should skip items without temp ID mappings", async () => {
+      const pendingCreate = {
+        doctype: "TestDoc",
+        docname: "temp-456",
+        values: {
+          title: "New Task"
+        },
+        operation: Operation.Create,
+        status: Status.Pending
+      };
+      mockMutationJournal.listPending.mockReturnValue([{
+        id: "mut2",
+        entry: pendingCreate
+      }]);
+      rehydrationManager.scheduleRehydration(mockSubscription, RehydrationReason.Create);
+      vi.advanceTimersByTime(100);
+      await vi.runAllTimersAsync();
+      expect(mockDb.getDoc).not.toHaveBeenCalled();
+    });
+    it("should handle fetch errors gracefully", async () => {
+      rehydrationManager.registerTempIdMapping("temp-789", "TASK-002");
+      const pendingCreate = {
+        doctype: "TestDoc",
+        docname: "temp-789",
+        values: {
+          title: "New Task"
+        },
+        operation: Operation.Create,
+        status: Status.Pending
+      };
+      mockMutationJournal.listPending.mockReturnValue([{
+        id: "mut3",
+        entry: pendingCreate
+      }]);
+      mockDb.getDoc.mockRejectedValue(new Error("Document not found"));
+      rehydrationManager.scheduleRehydration(mockSubscription, RehydrationReason.Create);
+      vi.advanceTimersByTime(100);
+      await vi.runAllTimersAsync();
+      expect(console.error).toHaveBeenCalledWith(expect.stringContaining("Failed to fetch TASK-002"), expect.any(Error));
+    });
+    it("should skip items without docname", async () => {
+      const pendingCreate = {
+        doctype: "TestDoc",
+        docname: void 0,
+        values: {
+          title: "New Task"
+        },
+        operation: Operation.Create,
+        status: Status.Pending
+      };
+      mockMutationJournal.listPending.mockReturnValue([{
+        id: "mut4",
+        entry: pendingCreate
+      }]);
+      rehydrationManager.scheduleRehydration(mockSubscription, RehydrationReason.Create);
+      vi.advanceTimersByTime(100);
+      await vi.runAllTimersAsync();
+      expect(mockDb.getDoc).not.toHaveBeenCalled();
+    });
+  });
+  describe("full page refresh", () => {
+    beforeEach(() => {
+      rehydrationManager = new RehydrationManager(mockDb, mockCache, mockSubscriptionManager, mockMutationJournal);
+    });
+    it("should perform full refresh with subscription parameters", async () => {
+      rehydrationManager.scheduleRehydration(mockSubscription, RehydrationReason.Delete);
+      vi.advanceTimersByTime(500);
+      await vi.runAllTimersAsync();
+      expect(mockDb.getDocList).toHaveBeenCalledWith("TestDoc", {
+        fields: ["*"],
+        filters: {},
+        orderBy: {
+          field: "modified",
+          order: Order.Desc
+        },
+        limitStart: 0,
+        limit: 20
+      });
+    });
+    it("should use subscription boundaries for pagination", async () => {
+      const subWithBoundaries = {
+        ...mockSubscription,
+        boundaries: {
+          ...mockSubscription.boundaries,
+          offset: 40,
+          pageSize: 25
+        }
+      };
+      mockSubscriptionManager.getSubscription.mockReturnValue(subWithBoundaries);
+      rehydrationManager.scheduleRehydration(subWithBoundaries, RehydrationReason.Delete);
+      vi.advanceTimersByTime(500);
+      await vi.runAllTimersAsync();
+      expect(mockDb.getDocList).toHaveBeenCalledWith("TestDoc", {
+        fields: ["*"],
+        filters: {},
+        orderBy: {
+          field: "modified",
+          order: Order.Desc
+        },
+        limitStart: 40,
+        limit: 25
+      });
+    });
+    it("should fall back to query parameters when boundaries missing", async () => {
+      const subWithoutBoundaries = {
+        ...mockSubscription,
+        boundaries: void 0,
+        query: {
+          ...mockSubscription.query,
+          limitStart: 10,
+          limit: 15
+        }
+      };
+      mockSubscriptionManager.getSubscription.mockReturnValue(subWithoutBoundaries);
+      rehydrationManager.scheduleRehydration(subWithoutBoundaries, RehydrationReason.Delete);
+      vi.advanceTimersByTime(500);
+      await vi.runAllTimersAsync();
+      expect(mockDb.getDocList).toHaveBeenCalledWith("TestDoc", {
+        fields: ["*"],
+        filters: {},
+        orderBy: {
+          field: "modified",
+          order: Order.Desc
+        },
+        limitStart: 10,
+        limit: 15
+      });
+    });
+    it("should update subscription boundaries after refresh", async () => {
+      const freshDocs = [{
+        ...mockDoc,
+        name: "fresh-doc1"
+      }, {
+        ...mockDoc,
+        name: "fresh-doc2"
+      }, {
+        ...mockDoc,
+        name: "fresh-doc3"
+      }];
+      mockDb.getDocList.mockResolvedValue(freshDocs);
+      rehydrationManager.scheduleRehydration(mockSubscription, RehydrationReason.Delete);
+      vi.advanceTimersByTime(500);
+      await vi.runAllTimersAsync();
+      expect(mockSubscription.boundaries).toEqual({
+        firstItem: {
+          ...freshDocs[0],
+          doctype: "TestDoc"
+        },
+        lastItem: {
+          ...freshDocs[2],
+          doctype: "TestDoc"
+        },
+        offset: 0,
+        pageSize: 20
+      });
+    });
+    it("should handle empty results", async () => {
+      mockDb.getDocList.mockResolvedValue([]);
+      rehydrationManager.scheduleRehydration(mockSubscription, RehydrationReason.Delete);
+      vi.advanceTimersByTime(500);
+      await vi.runAllTimersAsync();
+      expect(mockSubscription.boundaries).toEqual({
+        firstItem: {
+          ...mockDoc,
+          name: "doc1"
+        },
+        lastItem: {
+          ...mockDoc,
+          name: "doc3"
+        },
+        offset: 0,
+        pageSize: 20
+      });
+    });
+    it("should handle refresh errors", async () => {
+      mockDb.getDocList.mockRejectedValue(new Error("Server error"));
+      rehydrationManager.scheduleRehydration(mockSubscription, RehydrationReason.Delete);
+      vi.advanceTimersByTime(500);
+      await vi.runAllTimersAsync();
+      expect(console.error).toHaveBeenCalledWith(expect.stringContaining("Full refresh failed for sub1"), expect.any(Error));
+    });
+  });
+  describe("reconciliation", () => {
+    beforeEach(() => {
+      rehydrationManager = new RehydrationManager(mockDb, mockCache, mockSubscriptionManager, mockMutationJournal);
+    });
+    it("should reconcile server state with pending updates", async () => {
+      const serverDocs = [{
+        name: "doc1",
+        title: "Server Title 1"
+      }, {
+        name: "doc2",
+        title: "Server Title 2"
+      }];
+      const pendingUpdate = {
+        doctype: "TestDoc",
+        docname: "doc1",
+        values: {
+          title: "Optimistic Title 1"
+        },
+        operation: Operation.Update,
+        status: Status.Pending
+      };
+      mockDb.getDocList.mockResolvedValue(serverDocs);
+      mockMutationJournal.listPending.mockReturnValue([{
+        id: "mut1",
+        entry: pendingUpdate
+      }]);
+      rehydrationManager.scheduleRehydration(mockSubscription, RehydrationReason.Delete);
+      vi.advanceTimersByTime(500);
+      await vi.runAllTimersAsync();
+      expect(mockCache.upsert).toHaveBeenCalledWith({
+        name: "doc1",
+        title: "Optimistic Title 1",
+        // Optimistic value should win
+        doctype: "TestDoc"
+      });
+      expect(mockCache.upsert).toHaveBeenCalledWith({
+        name: "doc2",
+        title: "Server Title 2",
+        // No pending update, use server value
+        doctype: "TestDoc"
+      });
+    });
+    it("should include pending creates in reconciliation", async () => {
+      const serverDocs = [{
+        name: "doc1",
+        title: "Server Title 1"
+      }];
+      const pendingCreate = {
+        doctype: "TestDoc",
+        docname: "temp-123",
+        values: {
+          title: "Optimistic Create"
+        },
+        operation: Operation.Create,
+        status: Status.Pending
+      };
+      mockDb.getDocList.mockResolvedValue(serverDocs);
+      mockMutationJournal.listPending.mockReturnValue([{
+        id: "mut2",
+        entry: pendingCreate
+      }]);
+      rehydrationManager.scheduleRehydration(mockSubscription, RehydrationReason.Delete);
+      vi.advanceTimersByTime(500);
+      await vi.runAllTimersAsync();
+      expect(mockSubscription.docIds).toContain("temp-123");
+      expect(mockSubscription.docIds).toContain("doc1");
+    });
+    it("should exclude pending deletes from reconciliation", async () => {
+      const serverDocs = [{
+        name: "doc1",
+        title: "Server Title 1"
+      }, {
+        name: "doc2",
+        title: "Server Title 2"
+      }];
+      const pendingDelete = {
+        doctype: "TestDoc",
+        docname: "doc1",
+        operation: Operation.Delete,
+        status: Status.Pending
+      };
+      mockDb.getDocList.mockResolvedValue(serverDocs);
+      mockMutationJournal.listPending.mockReturnValue([{
+        id: "mut3",
+        entry: pendingDelete
+      }]);
+      rehydrationManager.scheduleRehydration(mockSubscription, RehydrationReason.Delete);
+      vi.advanceTimersByTime(500);
+      await vi.runAllTimersAsync();
+      expect(mockSubscription.docIds).not.toContain("doc1");
+      expect(mockSubscription.docIds).toContain("doc2");
+    });
+    it("should resort subscription doc IDs after reconciliation", async () => {
+      rehydrationManager.scheduleRehydration(mockSubscription, RehydrationReason.Delete);
+      vi.advanceTimersByTime(500);
+      await vi.runAllTimersAsync();
+      expect(mockSubscriptionManager.resortSubscriptionDocIds).toHaveBeenCalledWith(mockSubscription);
+    });
+  });
+  describe("temporary ID management", () => {
+    beforeEach(() => {
+      rehydrationManager = new RehydrationManager(mockDb, mockCache, mockSubscriptionManager, mockMutationJournal);
+    });
+    it("should register temp ID mappings", () => {
+      rehydrationManager.registerTempIdMapping("temp-123", "TASK-001");
+      rehydrationManager.registerTempIdMapping("temp-456", "TASK-002");
+      const tempMap = rehydrationManager.temporaryIdMap;
+      expect(tempMap.get("temp-123")).toBe("TASK-001");
+      expect(tempMap.get("temp-456")).toBe("TASK-002");
+    });
+    it("should use registered mappings during fetch", async () => {
+      rehydrationManager.registerTempIdMapping("temp-789", "TASK-003");
+      const pendingCreate = {
+        doctype: "TestDoc",
+        docname: "temp-789",
+        values: {
+          title: "New Task"
+        },
+        operation: Operation.Create,
+        status: Status.Pending
+      };
+      mockMutationJournal.listPending.mockReturnValue([{
+        id: "mut5",
+        entry: pendingCreate
+      }]);
+      rehydrationManager.scheduleRehydration(mockSubscription, RehydrationReason.Create);
+      vi.advanceTimersByTime(100);
+      await vi.runAllTimersAsync();
+      expect(mockDb.getDoc).toHaveBeenCalledWith("TestDoc", "TASK-003");
+    });
+  });
+  describe("queue management", () => {
+    beforeEach(() => {
+      rehydrationManager = new RehydrationManager(mockDb, mockCache, mockSubscriptionManager, mockMutationJournal);
+    });
+    it("should clear the rehydration queue", () => {
+      rehydrationManager.scheduleRehydration(mockSubscription, RehydrationReason.Create);
+      rehydrationManager.scheduleRehydration(mockSubscription, RehydrationReason.Delete);
+      const queueSize = rehydrationManager.rehydrationQueue.size;
+      expect(queueSize).toBeGreaterThan(0);
+      rehydrationManager.clear();
+      const clearedQueueSize = rehydrationManager.rehydrationQueue.size;
+      expect(clearedQueueSize).toBe(0);
+    });
+    it("should clear processing timer when clearing queue", async () => {
+      rehydrationManager.scheduleRehydration(mockSubscription, RehydrationReason.Create);
+      rehydrationManager.clear();
+      vi.advanceTimersByTime(2e3);
+      await vi.runAllTimersAsync();
+      expect(mockDb.getDocList).not.toHaveBeenCalled();
+    });
+    it("should handle clear when no timer is set", () => {
+      expect(() => rehydrationManager.clear()).not.toThrow();
+    });
+  });
+  describe("debouncing", () => {
+    beforeEach(() => {
+      rehydrationManager = new RehydrationManager(mockDb, mockCache, mockSubscriptionManager, mockMutationJournal);
+    });
+    it("should debounce multiple schedule calls", async () => {
+      rehydrationManager.scheduleRehydration(mockSubscription, RehydrationReason.Delete);
+      rehydrationManager.scheduleRehydration(mockSubscription, RehydrationReason.Delete);
+      rehydrationManager.scheduleRehydration(mockSubscription, RehydrationReason.Delete);
+      vi.advanceTimersByTime(500);
+      await vi.runAllTimersAsync();
+      expect(mockDb.getDocList).toHaveBeenCalledTimes(1);
+    });
+    it("should reset timer when new tasks are scheduled", () => {
+      rehydrationManager.scheduleRehydration(mockSubscription, RehydrationReason.Delete);
+      vi.advanceTimersByTime(200);
+      rehydrationManager.scheduleRehydration(mockSubscription, RehydrationReason.Create);
+      vi.advanceTimersByTime(300);
+      expect(mockDb.getDocList).not.toHaveBeenCalled();
+      vi.advanceTimersByTime(200);
+      expect(mockDb.getDocList).toHaveBeenCalled();
+    });
+  });
+  describe("error handling and edge cases", () => {
+    beforeEach(() => {
+      rehydrationManager = new RehydrationManager(mockDb, mockCache, mockSubscriptionManager, mockMutationJournal);
+    });
+    it("should handle missing subscription gracefully", async () => {
+      mockSubscriptionManager.getSubscription.mockReturnValue(null);
+      rehydrationManager.scheduleRehydration(mockSubscription, RehydrationReason.Delete);
+      vi.advanceTimersByTime(500);
+      await vi.runAllTimersAsync();
+      expect(mockDb.getDocList).not.toHaveBeenCalled();
+    });
+    it("should handle tasks with different scheduleAt times", async () => {
+      const sub1 = {
+        ...mockSubscription,
+        id: "sub1"
+      };
+      const sub2 = {
+        ...mockSubscription,
+        id: "sub2"
+      };
+      mockSubscriptionManager.getSubscription.mockImplementation(id => {
+        if (id === "sub1") return sub1;
+        if (id === "sub2") return sub2;
+        return null;
+      });
+      rehydrationManager.scheduleRehydration(sub1, RehydrationReason.Uncertain);
+      vi.advanceTimersByTime(100);
+      rehydrationManager.scheduleRehydration(sub2, RehydrationReason.Uncertain);
+      vi.advanceTimersByTime(2e3);
+      await vi.runAllTimersAsync();
+      expect(mockDb.getDocList).toHaveBeenCalledTimes(2);
+    });
+    it("should handle processing when queue becomes empty", async () => {
+      const manager = rehydrationManager;
+      manager.rehydrationQueue.clear();
+      vi.advanceTimersByTime(1e3);
+      await vi.runAllTimersAsync();
+      expect(mockDb.getDocList).not.toHaveBeenCalled();
+    });
+    it("should handle subscription boundaries edge cases", async () => {
+      const subWithPartialBoundaries = {
+        ...mockSubscription,
+        boundaries: {
+          firstItem: void 0,
+          lastItem: {
+            ...mockDoc,
+            name: "doc3"
+          },
+          offset: 0,
+          pageSize: 20
+        }
+      };
+      mockSubscriptionManager.getSubscription.mockReturnValue(subWithPartialBoundaries);
+      rehydrationManager.scheduleRehydration(subWithPartialBoundaries, RehydrationReason.Delete);
+      vi.advanceTimersByTime(500);
+      await vi.runAllTimersAsync();
+      expect(mockDb.getDocList).toHaveBeenCalled();
+    });
+  });
+});
+//# sourceMappingURL=rehydration.spec.mjs.map