@multiplatform.one/frappe 6.1.0 → 6.4.0

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

@@ -1,586 +0,0 @@
-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();
-    });
-  });
-});