@multiplatform.one/frappe 6.0.0

package/dist/cjs/sync/backfill.spec.cjs

@@ -0,0 +1,586 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from)) if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+// If the importer is in node compatibility mode or this is not an ESM
+// file that has been converted to a CommonJS file using a Babel-
+// compatible transform (i.e. "__esModule" has not been set), then set
+// "default" to the CommonJS "module.exports" for node compatibility.
+isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+  value: mod,
+  enumerable: true
+}) : target, mod));
+var import_vitest = require("vitest");
+var import_backfill = require("./backfill.cjs");
+var import_types = require("./types.cjs");
+var import_virtualPageManager = require("./virtualPageManager.cjs");
+import_vitest.vi.mock("./filters", () => ({
+  matchesFilters: import_vitest.vi.fn(() => true)
+}));
+(0, import_vitest.describe)("BackfillManager", () => {
+  let backfillManager;
+  let mockDb;
+  let mockNormalizedCache;
+  const mockDocs = Array.from({
+    length: 100
+  }, (_, i) => ({
+    name: `doc-${i}`,
+    doctype: "TestDoc",
+    owner: "user",
+    modified: new Date(2024, 0, 1, 0, 0, i).toISOString(),
+    creation: new Date(2024, 0, 1).toISOString(),
+    modified_by: "user",
+    value: i,
+    title: `Document ${i}`
+  }));
+  class MockVirtualSubscription extends import_virtualPageManager.VirtualSubscription {
+    constructor(id, query, docIds, progressiveCache, viewWindow, overrides) {
+      const baseSubscription = {
+        id,
+        query,
+        docIds,
+        checkpoint: void 0,
+        cursor: void 0,
+        boundaries: void 0,
+        lockExpiry: void 0,
+        pendingRehydration: void 0,
+        metadata: void 0,
+        tombstones: /* @__PURE__ */new Set(),
+        ...overrides
+      };
+      super(baseSubscription, progressiveCache, viewWindow);
+      if (overrides) {
+        Object.assign(this, overrides);
+      }
+    }
+    // Expose protected progressiveCache for testing
+    get testProgressiveCache() {
+      return this.progressiveCache;
+    }
+    set testProgressiveCache(value) {
+      this.progressiveCache = value;
+    }
+  }
+  const createMockSubscription = overrides => {
+    const defaultProgressiveCache = {
+      docIds: mockDocs.slice(0, 20).map(d => d.name),
+      nextCursor: "doc-19",
+      hasMore: true,
+      totalCount: void 0
+    };
+    const progressiveCache = overrides?.progressiveCache || defaultProgressiveCache;
+    const {
+      progressiveCache: _,
+      ...otherOverrides
+    } = overrides || {};
+    return new MockVirtualSubscription("sub-1", {
+      doctype: "TestDoc",
+      limit: 20,
+      orderBy: {
+        field: "modified",
+        order: import_types.Order.Asc
+      }
+    }, [], progressiveCache, {
+      currentPage: 1,
+      pageSize: 20
+    }, otherOverrides);
+  };
+  (0, import_vitest.beforeEach)(() => {
+    mockDb = {
+      getDocList: import_vitest.vi.fn(async (doctype, options) => {
+        let start;
+        if (options?.cursor) {
+          const cursorIndex = mockDocs.findIndex(d => d.name === options.cursor);
+          start = cursorIndex >= 0 ? cursorIndex + 1 : 0;
+        } else {
+          start = options?.limitStart || 0;
+        }
+        const limit = options?.limit || 20;
+        return mockDocs.slice(start, start + limit);
+      }),
+      backfill: import_vitest.vi.fn(async options => {
+        const modifiedAfter = options.modifiedAfter;
+        const limit = options.limit || 200;
+        const filtered = modifiedAfter ? mockDocs.filter(d => d.modified && d.modified > modifiedAfter) : mockDocs;
+        return {
+          rows: filtered.slice(0, limit),
+          deleted: []
+        };
+      }),
+      getCount: import_vitest.vi.fn(async () => mockDocs.length),
+      getDoc: import_vitest.vi.fn(),
+      createDoc: import_vitest.vi.fn(),
+      updateDoc: import_vitest.vi.fn(),
+      deleteDoc: import_vitest.vi.fn()
+    };
+    mockNormalizedCache = {
+      get: import_vitest.vi.fn((doctype, name) => {
+        const doc = mockDocs.find(d => d.name === name);
+        return doc || null;
+      }),
+      upsert: import_vitest.vi.fn(),
+      remove: import_vitest.vi.fn(),
+      delete: import_vitest.vi.fn(),
+      clear: import_vitest.vi.fn(),
+      getAll: import_vitest.vi.fn(),
+      hasDoc: import_vitest.vi.fn(),
+      getAllByDoctype: import_vitest.vi.fn(),
+      batchUpsert: import_vitest.vi.fn(),
+      batchDelete: import_vitest.vi.fn(),
+      clearByDoctype: import_vitest.vi.fn(),
+      size: import_vitest.vi.fn(),
+      sizeByDoctype: import_vitest.vi.fn()
+    };
+    backfillManager = new import_backfill.BackfillManager(mockDb, mockNormalizedCache, {
+      pageSize: 50,
+      maxRetries: 3,
+      retryDelay: 100
+    });
+  });
+  (0, import_vitest.describe)("backfill", () => {
+    (0, import_vitest.it)("should perform backfill for initial reason", async () => {
+      const subscription = createMockSubscription();
+      await backfillManager.backfill(subscription, import_backfill.BackfillReason.Initial);
+      (0, import_vitest.expect)(mockDb.getDocList).toHaveBeenCalled();
+      (0, import_vitest.expect)(subscription.testProgressiveCache.docIds).toHaveLength(50);
+      (0, import_vitest.expect)(subscription.testProgressiveCache.lastFetchedAt).toBeInstanceOf(Date);
+    });
+    (0, import_vitest.it)("should queue backfill if already in progress", async () => {
+      const subscription = createMockSubscription();
+      const firstPromise = backfillManager.backfill(subscription, import_backfill.BackfillReason.Initial);
+      const secondPromise = backfillManager.backfill(subscription, import_backfill.BackfillReason.Pagination);
+      await (0, import_vitest.expect)(firstPromise).resolves.toBeUndefined();
+      await (0, import_vitest.expect)(secondPromise).resolves.toBeUndefined();
+    });
+    (0, import_vitest.it)("should process queued backfills after completion", async () => {
+      const subscription = createMockSubscription();
+      mockDb.getDocList.mockImplementationOnce(async () => {
+        await new Promise(resolve => setTimeout(resolve, 50));
+        return mockDocs.slice(0, 50);
+      });
+      const promise1 = backfillManager.backfill(subscription, import_backfill.BackfillReason.Initial);
+      const promise2 = backfillManager.backfill(subscription, import_backfill.BackfillReason.Pagination);
+      const promise3 = backfillManager.backfill(subscription, import_backfill.BackfillReason.DeleteGap);
+      await Promise.all([promise1, promise2, promise3]);
+      await new Promise(resolve => setTimeout(resolve, 200));
+    });
+    (0, import_vitest.it)("should handle different backfill reasons", async () => {
+      const subscription = createMockSubscription();
+      await backfillManager.backfill(subscription, import_backfill.BackfillReason.Pagination);
+      (0, import_vitest.expect)(subscription.testProgressiveCache.docIds.length).toBeGreaterThan(0);
+      await backfillManager.backfill(subscription, import_backfill.BackfillReason.DeleteGap);
+      (0, import_vitest.expect)(subscription.pendingBackfill).toBe(false);
+      await backfillManager.backfill(subscription, import_backfill.BackfillReason.RemoteCreate);
+      (0, import_vitest.expect)(subscription.needsRehydration).toBe(false);
+    });
+  });
+  (0, import_vitest.describe)("backfillOne", () => {
+    (0, import_vitest.it)("should fetch and add one document", async () => {
+      const subscription = createMockSubscription();
+      const doc = await backfillManager.backfillOne(subscription);
+      (0, import_vitest.expect)(doc).toBeDefined();
+      (0, import_vitest.expect)(doc?.name).toBe("doc-20");
+      (0, import_vitest.expect)(subscription.testProgressiveCache.docIds).toContain("doc-20");
+      (0, import_vitest.expect)(mockNormalizedCache.upsert).toHaveBeenCalled();
+    });
+    (0, import_vitest.it)("should return null when no more documents", async () => {
+      const subscription = createMockSubscription({
+        progressiveCache: {
+          docIds: mockDocs.map(d => d.name),
+          nextCursor: "doc-99",
+          hasMore: false,
+          totalCount: 100
+        }
+      });
+      const doc = await backfillManager.backfillOne(subscription);
+      (0, import_vitest.expect)(doc).toBeNull();
+      (0, import_vitest.expect)(mockDb.getDocList).not.toHaveBeenCalled();
+    });
+    (0, import_vitest.it)("should handle fetch errors gracefully", async () => {
+      const subscription = createMockSubscription();
+      mockDb.getDocList.mockRejectedValueOnce(new Error("Network error"));
+      const doc = await backfillManager.backfillOne(subscription);
+      (0, import_vitest.expect)(doc).toBeNull();
+    });
+    (0, import_vitest.it)("should update hasMore flag when no documents returned", async () => {
+      const subscription = createMockSubscription();
+      mockDb.getDocList.mockResolvedValueOnce([]);
+      const doc = await backfillManager.backfillOne(subscription);
+      (0, import_vitest.expect)(doc).toBeNull();
+      (0, import_vitest.expect)(subscription.testProgressiveCache.hasMore).toBe(false);
+    });
+  });
+  (0, import_vitest.describe)("rehydrateCurrentPage", () => {
+    (0, import_vitest.it)("should refresh current page from server", async () => {
+      const subscription = createMockSubscription({
+        viewWindow: {
+          currentPage: 2,
+          pageSize: 20
+        },
+        needsRehydration: true
+      });
+      await backfillManager.rehydrateCurrentPage(subscription);
+      (0, import_vitest.expect)(mockDb.getDocList).toHaveBeenCalledWith("TestDoc", {
+        fields: void 0,
+        filters: void 0,
+        orderBy: {
+          field: "modified",
+          order: import_types.Order.Asc
+        },
+        limitStart: 20,
+        // Page 2 starts at index 20
+        limit: 20
+      });
+      (0, import_vitest.expect)(subscription.needsRehydration).toBe(false);
+    });
+    (0, import_vitest.it)("should update normalized cache with fetched documents", async () => {
+      const subscription = createMockSubscription();
+      await backfillManager.rehydrateCurrentPage(subscription);
+      (0, import_vitest.expect)(mockNormalizedCache.upsert).toHaveBeenCalledTimes(20);
+    });
+    (0, import_vitest.it)("should replace page in progressive cache", async () => {
+      const subscription = createMockSubscription({
+        progressiveCache: {
+          docIds: Array.from({
+            length: 40
+          }, (_, i) => `doc-${i}`),
+          nextCursor: "doc-39",
+          hasMore: true,
+          totalCount: void 0
+        },
+        viewWindow: {
+          currentPage: 1,
+          pageSize: 20
+        }
+      });
+      const originalSecondPage = subscription.testProgressiveCache.docIds.slice(20, 40);
+      await backfillManager.rehydrateCurrentPage(subscription);
+      (0, import_vitest.expect)(subscription.testProgressiveCache.docIds.slice(0, 20)).toEqual(mockDocs.slice(0, 20).map(d => d.name));
+      (0, import_vitest.expect)(subscription.testProgressiveCache.docIds.slice(20, 40)).toEqual(originalSecondPage);
+    });
+    (0, import_vitest.it)("should handle errors and propagate them", async () => {
+      const subscription = createMockSubscription();
+      mockDb.getDocList.mockRejectedValueOnce(new Error("Server error"));
+      await (0, import_vitest.expect)(backfillManager.rehydrateCurrentPage(subscription)).rejects.toThrow("Server error");
+    });
+  });
+  (0, import_vitest.describe)("strategy determination", () => {
+    (0, import_vitest.it)("should use FullRefresh for Initial reason", async () => {
+      const subscription = createMockSubscription();
+      subscription.testProgressiveCache.docIds = [];
+      await backfillManager.backfill(subscription, import_backfill.BackfillReason.Initial);
+      (0, import_vitest.expect)(subscription.testProgressiveCache.docIds.length).toBeGreaterThan(0);
+      (0, import_vitest.expect)(subscription.testProgressiveCache.lastFetchedAt).toBeDefined();
+    });
+    (0, import_vitest.it)("should use CursorFetch for Pagination with cursor", async () => {
+      const subscription = createMockSubscription({
+        progressiveCache: {
+          docIds: mockDocs.slice(0, 20).map(d => d.name),
+          nextCursor: "doc-19",
+          hasMore: true,
+          totalCount: void 0
+        }
+      });
+      const initialLength = subscription.testProgressiveCache.docIds.length;
+      await backfillManager.backfill(subscription, import_backfill.BackfillReason.Pagination);
+      (0, import_vitest.expect)(subscription.testProgressiveCache.docIds.length).toBeGreaterThan(initialLength);
+    });
+    (0, import_vitest.it)("should use GapFill for DeleteGap reason", async () => {
+      const subscription = createMockSubscription({
+        pendingBackfill: true
+      });
+      await backfillManager.backfill(subscription, import_backfill.BackfillReason.DeleteGap);
+      (0, import_vitest.expect)(subscription.pendingBackfill).toBe(false);
+    });
+    (0, import_vitest.it)("should use PageOnly for RemoteCreate/Update", async () => {
+      const subscription = createMockSubscription({
+        needsRehydration: true,
+        viewWindow: {
+          currentPage: 1,
+          pageSize: 20
+        }
+      });
+      await backfillManager.backfill(subscription, import_backfill.BackfillReason.RemoteCreate);
+      (0, import_vitest.expect)(subscription.needsRehydration).toBe(false);
+      (0, import_vitest.expect)(mockDb.getDocList).toHaveBeenCalledWith(import_vitest.expect.anything(), import_vitest.expect.objectContaining({
+        limitStart: 0,
+        limit: 20
+      }));
+    });
+    (0, import_vitest.it)("should use Incremental for Periodic with checkpoint", async () => {
+      const originalCheckpoint = new Date(2024, 0, 1, 0, 0, 10).toISOString();
+      const subscription = createMockSubscription({
+        checkpoint: originalCheckpoint
+      });
+      await backfillManager.backfill(subscription, import_backfill.BackfillReason.Periodic);
+      (0, import_vitest.expect)(mockDb.backfill).toHaveBeenCalledWith(import_vitest.expect.objectContaining({
+        modifiedAfter: originalCheckpoint
+      }));
+    });
+    (0, import_vitest.it)("should use FullRefresh for Recovery without checkpoint", async () => {
+      const subscription = createMockSubscription({
+        checkpoint: void 0
+      });
+      await backfillManager.backfill(subscription, import_backfill.BackfillReason.Recovery);
+      (0, import_vitest.expect)(subscription.testProgressiveCache.docIds).toBeDefined();
+      (0, import_vitest.expect)(subscription.testProgressiveCache.lastFetchedAt).toBeDefined();
+    });
+  });
+  (0, import_vitest.describe)("incremental backfill", () => {
+    (0, import_vitest.it)("should handle CDC backfill with updates", async () => {
+      const subscription = createMockSubscription({
+        checkpoint: new Date(2024, 0, 1, 0, 0, 10).toISOString(),
+        progressiveCache: {
+          docIds: mockDocs.slice(0, 20).map(d => d.name),
+          nextCursor: "doc-19",
+          hasMore: true,
+          totalCount: void 0
+        }
+      });
+      await backfillManager.backfill(subscription, import_backfill.BackfillReason.Periodic);
+      (0, import_vitest.expect)(mockDb.backfill).toHaveBeenCalled();
+      (0, import_vitest.expect)(subscription.checkpoint).toBeDefined();
+      (0, import_vitest.expect)(subscription.checkpoint).not.toBe(new Date(2024, 0, 1, 0, 0, 10).toISOString());
+    });
+    (0, import_vitest.it)("should process deletions from CDC response", async () => {
+      const subscription = createMockSubscription({
+        checkpoint: new Date(2024, 0, 1).toISOString(),
+        progressiveCache: {
+          docIds: ["doc-1", "doc-2", "doc-3"],
+          nextCursor: "doc-3",
+          hasMore: false,
+          totalCount: 3
+        }
+      });
+      mockDb.backfill.mockResolvedValueOnce({
+        rows: [],
+        deleted: [{
+          name: "doc-2"
+        }]
+      });
+      await backfillManager.backfill(subscription, import_backfill.BackfillReason.Periodic);
+      (0, import_vitest.expect)(subscription.testProgressiveCache.docIds).not.toContain("doc-2");
+      (0, import_vitest.expect)(subscription.testProgressiveCache.docIds).toContain("doc-1");
+      (0, import_vitest.expect)(subscription.testProgressiveCache.docIds).toContain("doc-3");
+      (0, import_vitest.expect)(mockNormalizedCache.remove).toHaveBeenCalledWith({
+        doctype: "TestDoc",
+        name: "doc-2"
+      });
+    });
+    (0, import_vitest.it)("should handle documents that no longer match filters", async () => {
+      const {
+        matchesFilters
+      } = await import("./filters");
+      import_vitest.vi.mocked(matchesFilters).mockImplementation((doc, _filters) => {
+        return doc.name !== "doc-1";
+      });
+      const subscription = createMockSubscription({
+        checkpoint: new Date(2024, 0, 1).toISOString(),
+        progressiveCache: {
+          docIds: ["doc-1", "doc-2", "doc-3"],
+          nextCursor: "doc-3",
+          hasMore: false,
+          totalCount: 3
+        }
+      });
+      mockDb.backfill.mockResolvedValueOnce({
+        rows: [{
+          name: "doc-1",
+          modified: (/* @__PURE__ */new Date()).toISOString()
+        }, {
+          name: "doc-2",
+          modified: (/* @__PURE__ */new Date()).toISOString()
+        }],
+        deleted: []
+      });
+      await backfillManager.backfill(subscription, import_backfill.BackfillReason.Periodic);
+      (0, import_vitest.expect)(subscription.testProgressiveCache.docIds).not.toContain("doc-1");
+      (0, import_vitest.expect)(subscription.testProgressiveCache.docIds).toContain("doc-2");
+    });
+    (0, import_vitest.it)("should mark for rehydration when new document matches", async () => {
+      const {
+        matchesFilters
+      } = await import("./filters");
+      import_vitest.vi.mocked(matchesFilters).mockReturnValue(true);
+      const subscription = createMockSubscription({
+        checkpoint: new Date(2024, 0, 1).toISOString(),
+        progressiveCache: {
+          docIds: ["doc-1", "doc-2"],
+          nextCursor: "doc-2",
+          hasMore: false,
+          totalCount: 2
+        }
+      });
+      mockDb.backfill.mockResolvedValueOnce({
+        rows: [{
+          name: "doc-3",
+          modified: (/* @__PURE__ */new Date()).toISOString()
+        }
+        // New doc that matches
+        ],
+        deleted: []
+      });
+      await backfillManager.backfill(subscription, import_backfill.BackfillReason.Periodic);
+      (0, import_vitest.expect)(subscription.needsRehydration).toBe(true);
+    });
+    (0, import_vitest.it)("should fallback to full refresh on error", async () => {
+      const subscription = createMockSubscription({
+        checkpoint: new Date(2024, 0, 1).toISOString()
+      });
+      mockDb.backfill.mockRejectedValueOnce(new Error("CDC error"));
+      await backfillManager.backfill(subscription, import_backfill.BackfillReason.Periodic);
+      (0, import_vitest.expect)(mockDb.getDocList).toHaveBeenCalled();
+      (0, import_vitest.expect)(subscription.testProgressiveCache.docIds.length).toBeGreaterThan(0);
+    });
+  });
+  (0, import_vitest.describe)("cursor-based fetching", () => {
+    (0, import_vitest.it)("should fetch next batch using cursor", async () => {
+      const subscription = createMockSubscription({
+        progressiveCache: {
+          docIds: mockDocs.slice(0, 20).map(d => d.name),
+          nextCursor: "doc-19",
+          hasMore: true,
+          totalCount: void 0
+        }
+      });
+      await backfillManager.backfill(subscription, import_backfill.BackfillReason.Pagination);
+      (0, import_vitest.expect)(mockDb.getDocList).toHaveBeenCalledWith("TestDoc", {
+        fields: void 0,
+        filters: void 0,
+        orderBy: {
+          field: "modified",
+          order: import_types.Order.Asc
+        },
+        cursor: "doc-19",
+        limit: 50
+        // batchSize (falls back to pageSize)
+      });
+      (0, import_vitest.expect)(subscription.testProgressiveCache.docIds.length).toBeGreaterThan(20);
+    });
+    (0, import_vitest.it)("should update cursor and hasMore flag", async () => {
+      const subscription = createMockSubscription({
+        progressiveCache: {
+          docIds: mockDocs.slice(0, 80).map(d => d.name),
+          nextCursor: "doc-79",
+          hasMore: true,
+          totalCount: void 0
+        }
+      });
+      mockDb.getDocList.mockResolvedValueOnce(mockDocs.slice(80, 100));
+      await backfillManager.backfill(subscription, import_backfill.BackfillReason.Pagination);
+      (0, import_vitest.expect)(subscription.testProgressiveCache.hasMore).toBe(false);
+      (0, import_vitest.expect)(subscription.testProgressiveCache.nextCursor).toBe("doc-99");
+    });
+    (0, import_vitest.it)("should not fetch if no more data available", async () => {
+      const subscription = createMockSubscription({
+        progressiveCache: {
+          docIds: mockDocs.map(d => d.name),
+          nextCursor: "doc-99",
+          hasMore: false,
+          totalCount: 100
+        }
+      });
+      const initialLength = subscription.testProgressiveCache.docIds.length;
+      await backfillManager.backfill(subscription, import_backfill.BackfillReason.Pagination);
+      (0, import_vitest.expect)(subscription.testProgressiveCache.docIds.length).toBe(initialLength);
+    });
+  });
+  (0, import_vitest.describe)("queue management", () => {
+    (0, import_vitest.it)("should not queue duplicate reasons", async () => {
+      const subscription = createMockSubscription();
+      let resolveFirst;
+      const firstPromise = new Promise(resolve => {
+        resolveFirst = resolve;
+      });
+      mockDb.getDocList.mockImplementationOnce(async () => {
+        await firstPromise;
+        return mockDocs.slice(0, 50);
+      });
+      const promise1 = backfillManager.backfill(subscription, import_backfill.BackfillReason.Initial);
+      const promise2 = backfillManager.backfill(subscription, import_backfill.BackfillReason.Pagination);
+      const promise3 = backfillManager.backfill(subscription, import_backfill.BackfillReason.Pagination);
+      const promise4 = backfillManager.backfill(subscription, import_backfill.BackfillReason.Pagination);
+      resolveFirst();
+      await Promise.all([promise1, promise2, promise3, promise4]);
+      (0, import_vitest.expect)(mockDb.getDocList).toHaveBeenCalledTimes(2);
+    });
+    (0, import_vitest.it)("should process queue in FIFO order", async () => {
+      const subscription = createMockSubscription();
+      const callOrder = [];
+      mockDb.getDocList.mockImplementation(async () => {
+        await new Promise(resolve => setTimeout(resolve, 10));
+        return mockDocs.slice(0, 50);
+      });
+      const originalPerform = backfillManager.performBackfill;
+      backfillManager.performBackfill = async function (sub, reason) {
+        callOrder.push(reason);
+        return originalPerform.call(this, sub, reason);
+      };
+      const promise1 = backfillManager.backfill(subscription, import_backfill.BackfillReason.Initial);
+      const promise2 = backfillManager.backfill(subscription, import_backfill.BackfillReason.Pagination);
+      const promise3 = backfillManager.backfill(subscription, import_backfill.BackfillReason.DeleteGap);
+      await Promise.all([promise1, promise2, promise3]);
+      await new Promise(resolve => setTimeout(resolve, 200));
+      (0, import_vitest.expect)(callOrder).toEqual([import_backfill.BackfillReason.Initial, import_backfill.BackfillReason.Pagination, import_backfill.BackfillReason.DeleteGap]);
+    });
+  });
+  (0, import_vitest.describe)("checkpoint calculation", () => {
+    (0, import_vitest.it)("should calculate checkpoint from highest modified timestamp", async () => {
+      const subscription = createMockSubscription({
+        checkpoint: void 0
+      });
+      const testDocs = [{
+        ...mockDocs[0],
+        modified: "2024-01-01T00:00:00Z"
+      }, {
+        ...mockDocs[1],
+        modified: "2024-01-01T00:00:30Z"
+      }, {
+        ...mockDocs[2],
+        modified: "2024-01-01T00:00:15Z"
+      }];
+      mockDb.getDocList.mockResolvedValueOnce(testDocs);
+      await backfillManager.backfill(subscription, import_backfill.BackfillReason.Initial);
+      (0, import_vitest.expect)(subscription.checkpoint).toBe("2024-01-01T00:00:30Z");
+    });
+    (0, import_vitest.it)("should handle documents without modified field", async () => {
+      const subscription = createMockSubscription({
+        checkpoint: void 0
+      });
+      const testDocs = [{
+        name: "doc-1",
+        doctype: "TestDoc"
+      }, {
+        name: "doc-2",
+        doctype: "TestDoc",
+        modified: "2024-01-01T00:00:00Z"
+      }, {
+        name: "doc-3",
+        doctype: "TestDoc"
+      }];
+      mockDb.getDocList.mockResolvedValueOnce(testDocs);
+      await backfillManager.backfill(subscription, import_backfill.BackfillReason.Initial);
+      (0, import_vitest.expect)(subscription.checkpoint).toBe("2024-01-01T00:00:00Z");
+    });
+    (0, import_vitest.it)("should return undefined for empty document list", async () => {
+      const subscription = createMockSubscription({
+        checkpoint: void 0
+      });
+      mockDb.getDocList.mockResolvedValueOnce([]);
+      await backfillManager.backfill(subscription, import_backfill.BackfillReason.Initial);
+      (0, import_vitest.expect)(subscription.checkpoint).toBeUndefined();
+    });
+  });
+});