@multiplatform.one/frappe 6.0.0

package/dist/cjs/sync/rehydration.spec.native.js

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