@multiplatform.one/frappe 6.0.0

package/dist/esm/sync/backfill.spec.native.js

@@ -0,0 +1,686 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { BackfillManager, BackfillReason } from "./backfill.native.js";
+import { Order } from "./types.native.js";
+import { VirtualSubscription } from "./virtualPageManager.native.js";
+function _assert_this_initialized(self) {
+  if (self === void 0) {
+    throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+  }
+  return self;
+}
+function _call_super(_this, derived, args) {
+  derived = _get_prototype_of(derived);
+  return _possible_constructor_return(_this, _is_native_reflect_construct() ? Reflect.construct(derived, args || [], _get_prototype_of(_this).constructor) : derived.apply(_this, args));
+}
+function _class_call_check(instance, Constructor) {
+  if (!(instance instanceof Constructor)) {
+    throw new TypeError("Cannot call a class as a function");
+  }
+}
+function _defineProperties(target, props) {
+  for (var i = 0; i < props.length; i++) {
+    var descriptor = props[i];
+    descriptor.enumerable = descriptor.enumerable || false;
+    descriptor.configurable = true;
+    if ("value" in descriptor) descriptor.writable = true;
+    Object.defineProperty(target, descriptor.key, descriptor);
+  }
+}
+function _create_class(Constructor, protoProps, staticProps) {
+  if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+  if (staticProps) _defineProperties(Constructor, staticProps);
+  return Constructor;
+}
+function _get_prototype_of(o) {
+  _get_prototype_of = Object.setPrototypeOf ? Object.getPrototypeOf : function getPrototypeOf(o2) {
+    return o2.__proto__ || Object.getPrototypeOf(o2);
+  };
+  return _get_prototype_of(o);
+}
+function _inherits(subClass, superClass) {
+  if (typeof superClass !== "function" && superClass !== null) {
+    throw new TypeError("Super expression must either be null or a function");
+  }
+  subClass.prototype = Object.create(superClass && superClass.prototype, {
+    constructor: {
+      value: subClass,
+      writable: true,
+      configurable: true
+    }
+  });
+  if (superClass) _set_prototype_of(subClass, superClass);
+}
+function _possible_constructor_return(self, call) {
+  if (call && (_type_of(call) === "object" || typeof call === "function")) {
+    return call;
+  }
+  return _assert_this_initialized(self);
+}
+function _set_prototype_of(o, p) {
+  _set_prototype_of = Object.setPrototypeOf || function setPrototypeOf(o2, p2) {
+    o2.__proto__ = p2;
+    return o2;
+  };
+  return _set_prototype_of(o, p);
+}
+function _type_of(obj) {
+  "@swc/helpers - typeof";
+
+  return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
+function _is_native_reflect_construct() {
+  try {
+    var result = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {}));
+  } catch (_) {}
+  return (_is_native_reflect_construct = function () {
+    return !!result;
+  })();
+}
+vi.mock("./filters", function () {
+  return {
+    matchesFilters: vi.fn(function () {
+      return true;
+    })
+  };
+});
+describe("BackfillManager", function () {
+  var backfillManager;
+  var mockDb;
+  var mockNormalizedCache;
+  var mockDocs = Array.from({
+    length: 100
+  }, function (_, i) {
+    return {
+      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}`
+    };
+  });
+  var MockVirtualSubscription = /* @__PURE__ */function (VirtualSubscription2) {
+    "use strict";
+
+    _inherits(MockVirtualSubscription2, VirtualSubscription2);
+    function MockVirtualSubscription2(id, query, docIds, progressiveCache, viewWindow, overrides) {
+      _class_call_check(this, MockVirtualSubscription2);
+      var _this;
+      var 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
+      };
+      _this = _call_super(this, MockVirtualSubscription2, [baseSubscription, progressiveCache, viewWindow]);
+      if (overrides) {
+        Object.assign(_this, overrides);
+      }
+      return _this;
+    }
+    _create_class(MockVirtualSubscription2, [{
+      key: "testProgressiveCache",
+      get:
+      // Expose protected progressiveCache for testing
+      function get() {
+        return this.progressiveCache;
+      },
+      set: function set(value) {
+        this.progressiveCache = value;
+      }
+    }]);
+    return MockVirtualSubscription2;
+  }(VirtualSubscription);
+  var createMockSubscription = function createMockSubscription2(overrides) {
+    var defaultProgressiveCache = {
+      docIds: mockDocs.slice(0, 20).map(function (d) {
+        return d.name;
+      }),
+      nextCursor: "doc-19",
+      hasMore: true,
+      totalCount: void 0
+    };
+    var progressiveCache = (overrides === null || overrides === void 0 ? void 0 : overrides.progressiveCache) || defaultProgressiveCache;
+    var {
+      progressiveCache: _,
+      ...otherOverrides
+    } = overrides || {};
+    return new MockVirtualSubscription("sub-1", {
+      doctype: "TestDoc",
+      limit: 20,
+      orderBy: {
+        field: "modified",
+        order: Order.Asc
+      }
+    }, [], progressiveCache, {
+      currentPage: 1,
+      pageSize: 20
+    }, otherOverrides);
+  };
+  beforeEach(function () {
+    mockDb = {
+      getDocList: vi.fn(async function (doctype, options) {
+        var start;
+        if (options === null || options === void 0 ? void 0 : options.cursor) {
+          var cursorIndex = mockDocs.findIndex(function (d) {
+            return d.name === options.cursor;
+          });
+          start = cursorIndex >= 0 ? cursorIndex + 1 : 0;
+        } else {
+          start = (options === null || options === void 0 ? void 0 : options.limitStart) || 0;
+        }
+        var limit = (options === null || options === void 0 ? void 0 : options.limit) || 20;
+        return mockDocs.slice(start, start + limit);
+      }),
+      backfill: vi.fn(async function (options) {
+        var modifiedAfter = options.modifiedAfter;
+        var limit = options.limit || 200;
+        var filtered = modifiedAfter ? mockDocs.filter(function (d) {
+          return d.modified && d.modified > modifiedAfter;
+        }) : mockDocs;
+        return {
+          rows: filtered.slice(0, limit),
+          deleted: []
+        };
+      }),
+      getCount: vi.fn(async function () {
+        return mockDocs.length;
+      }),
+      getDoc: vi.fn(),
+      createDoc: vi.fn(),
+      updateDoc: vi.fn(),
+      deleteDoc: vi.fn()
+    };
+    mockNormalizedCache = {
+      get: vi.fn(function (doctype, name) {
+        var doc = mockDocs.find(function (d) {
+          return d.name === name;
+        });
+        return doc || null;
+      }),
+      upsert: vi.fn(),
+      remove: vi.fn(),
+      delete: vi.fn(),
+      clear: vi.fn(),
+      getAll: vi.fn(),
+      hasDoc: vi.fn(),
+      getAllByDoctype: vi.fn(),
+      batchUpsert: vi.fn(),
+      batchDelete: vi.fn(),
+      clearByDoctype: vi.fn(),
+      size: vi.fn(),
+      sizeByDoctype: vi.fn()
+    };
+    backfillManager = new BackfillManager(mockDb, mockNormalizedCache, {
+      pageSize: 50,
+      maxRetries: 3,
+      retryDelay: 100
+    });
+  });
+  describe("backfill", function () {
+    it("should perform backfill for initial reason", async function () {
+      var subscription = createMockSubscription();
+      await backfillManager.backfill(subscription, BackfillReason.Initial);
+      expect(mockDb.getDocList).toHaveBeenCalled();
+      expect(subscription.testProgressiveCache.docIds).toHaveLength(50);
+      expect(subscription.testProgressiveCache.lastFetchedAt).toBeInstanceOf(Date);
+    });
+    it("should queue backfill if already in progress", async function () {
+      var subscription = createMockSubscription();
+      var firstPromise = backfillManager.backfill(subscription, BackfillReason.Initial);
+      var secondPromise = backfillManager.backfill(subscription, BackfillReason.Pagination);
+      await expect(firstPromise).resolves.toBeUndefined();
+      await expect(secondPromise).resolves.toBeUndefined();
+    });
+    it("should process queued backfills after completion", async function () {
+      var subscription = createMockSubscription();
+      mockDb.getDocList.mockImplementationOnce(async function () {
+        await new Promise(function (resolve) {
+          return setTimeout(resolve, 50);
+        });
+        return mockDocs.slice(0, 50);
+      });
+      var promise1 = backfillManager.backfill(subscription, BackfillReason.Initial);
+      var promise2 = backfillManager.backfill(subscription, BackfillReason.Pagination);
+      var promise3 = backfillManager.backfill(subscription, BackfillReason.DeleteGap);
+      await Promise.all([promise1, promise2, promise3]);
+      await new Promise(function (resolve) {
+        return setTimeout(resolve, 200);
+      });
+    });
+    it("should handle different backfill reasons", async function () {
+      var subscription = createMockSubscription();
+      await backfillManager.backfill(subscription, BackfillReason.Pagination);
+      expect(subscription.testProgressiveCache.docIds.length).toBeGreaterThan(0);
+      await backfillManager.backfill(subscription, BackfillReason.DeleteGap);
+      expect(subscription.pendingBackfill).toBe(false);
+      await backfillManager.backfill(subscription, BackfillReason.RemoteCreate);
+      expect(subscription.needsRehydration).toBe(false);
+    });
+  });
+  describe("backfillOne", function () {
+    it("should fetch and add one document", async function () {
+      var subscription = createMockSubscription();
+      var doc = await backfillManager.backfillOne(subscription);
+      expect(doc).toBeDefined();
+      expect(doc === null || doc === void 0 ? void 0 : doc.name).toBe("doc-20");
+      expect(subscription.testProgressiveCache.docIds).toContain("doc-20");
+      expect(mockNormalizedCache.upsert).toHaveBeenCalled();
+    });
+    it("should return null when no more documents", async function () {
+      var subscription = createMockSubscription({
+        progressiveCache: {
+          docIds: mockDocs.map(function (d) {
+            return d.name;
+          }),
+          nextCursor: "doc-99",
+          hasMore: false,
+          totalCount: 100
+        }
+      });
+      var doc = await backfillManager.backfillOne(subscription);
+      expect(doc).toBeNull();
+      expect(mockDb.getDocList).not.toHaveBeenCalled();
+    });
+    it("should handle fetch errors gracefully", async function () {
+      var subscription = createMockSubscription();
+      mockDb.getDocList.mockRejectedValueOnce(new Error("Network error"));
+      var doc = await backfillManager.backfillOne(subscription);
+      expect(doc).toBeNull();
+    });
+    it("should update hasMore flag when no documents returned", async function () {
+      var subscription = createMockSubscription();
+      mockDb.getDocList.mockResolvedValueOnce([]);
+      var doc = await backfillManager.backfillOne(subscription);
+      expect(doc).toBeNull();
+      expect(subscription.testProgressiveCache.hasMore).toBe(false);
+    });
+  });
+  describe("rehydrateCurrentPage", function () {
+    it("should refresh current page from server", async function () {
+      var subscription = createMockSubscription({
+        viewWindow: {
+          currentPage: 2,
+          pageSize: 20
+        },
+        needsRehydration: true
+      });
+      await backfillManager.rehydrateCurrentPage(subscription);
+      expect(mockDb.getDocList).toHaveBeenCalledWith("TestDoc", {
+        fields: void 0,
+        filters: void 0,
+        orderBy: {
+          field: "modified",
+          order: Order.Asc
+        },
+        limitStart: 20,
+        // Page 2 starts at index 20
+        limit: 20
+      });
+      expect(subscription.needsRehydration).toBe(false);
+    });
+    it("should update normalized cache with fetched documents", async function () {
+      var subscription = createMockSubscription();
+      await backfillManager.rehydrateCurrentPage(subscription);
+      expect(mockNormalizedCache.upsert).toHaveBeenCalledTimes(20);
+    });
+    it("should replace page in progressive cache", async function () {
+      var subscription = createMockSubscription({
+        progressiveCache: {
+          docIds: Array.from({
+            length: 40
+          }, function (_, i) {
+            return `doc-${i}`;
+          }),
+          nextCursor: "doc-39",
+          hasMore: true,
+          totalCount: void 0
+        },
+        viewWindow: {
+          currentPage: 1,
+          pageSize: 20
+        }
+      });
+      var originalSecondPage = subscription.testProgressiveCache.docIds.slice(20, 40);
+      await backfillManager.rehydrateCurrentPage(subscription);
+      expect(subscription.testProgressiveCache.docIds.slice(0, 20)).toEqual(mockDocs.slice(0, 20).map(function (d) {
+        return d.name;
+      }));
+      expect(subscription.testProgressiveCache.docIds.slice(20, 40)).toEqual(originalSecondPage);
+    });
+    it("should handle errors and propagate them", async function () {
+      var subscription = createMockSubscription();
+      mockDb.getDocList.mockRejectedValueOnce(new Error("Server error"));
+      await expect(backfillManager.rehydrateCurrentPage(subscription)).rejects.toThrow("Server error");
+    });
+  });
+  describe("strategy determination", function () {
+    it("should use FullRefresh for Initial reason", async function () {
+      var subscription = createMockSubscription();
+      subscription.testProgressiveCache.docIds = [];
+      await backfillManager.backfill(subscription, BackfillReason.Initial);
+      expect(subscription.testProgressiveCache.docIds.length).toBeGreaterThan(0);
+      expect(subscription.testProgressiveCache.lastFetchedAt).toBeDefined();
+    });
+    it("should use CursorFetch for Pagination with cursor", async function () {
+      var subscription = createMockSubscription({
+        progressiveCache: {
+          docIds: mockDocs.slice(0, 20).map(function (d) {
+            return d.name;
+          }),
+          nextCursor: "doc-19",
+          hasMore: true,
+          totalCount: void 0
+        }
+      });
+      var initialLength = subscription.testProgressiveCache.docIds.length;
+      await backfillManager.backfill(subscription, BackfillReason.Pagination);
+      expect(subscription.testProgressiveCache.docIds.length).toBeGreaterThan(initialLength);
+    });
+    it("should use GapFill for DeleteGap reason", async function () {
+      var subscription = createMockSubscription({
+        pendingBackfill: true
+      });
+      await backfillManager.backfill(subscription, BackfillReason.DeleteGap);
+      expect(subscription.pendingBackfill).toBe(false);
+    });
+    it("should use PageOnly for RemoteCreate/Update", async function () {
+      var subscription = createMockSubscription({
+        needsRehydration: true,
+        viewWindow: {
+          currentPage: 1,
+          pageSize: 20
+        }
+      });
+      await backfillManager.backfill(subscription, BackfillReason.RemoteCreate);
+      expect(subscription.needsRehydration).toBe(false);
+      expect(mockDb.getDocList).toHaveBeenCalledWith(expect.anything(), expect.objectContaining({
+        limitStart: 0,
+        limit: 20
+      }));
+    });
+    it("should use Incremental for Periodic with checkpoint", async function () {
+      var originalCheckpoint = new Date(2024, 0, 1, 0, 0, 10).toISOString();
+      var subscription = createMockSubscription({
+        checkpoint: originalCheckpoint
+      });
+      await backfillManager.backfill(subscription, BackfillReason.Periodic);
+      expect(mockDb.backfill).toHaveBeenCalledWith(expect.objectContaining({
+        modifiedAfter: originalCheckpoint
+      }));
+    });
+    it("should use FullRefresh for Recovery without checkpoint", async function () {
+      var subscription = createMockSubscription({
+        checkpoint: void 0
+      });
+      await backfillManager.backfill(subscription, BackfillReason.Recovery);
+      expect(subscription.testProgressiveCache.docIds).toBeDefined();
+      expect(subscription.testProgressiveCache.lastFetchedAt).toBeDefined();
+    });
+  });
+  describe("incremental backfill", function () {
+    it("should handle CDC backfill with updates", async function () {
+      var subscription = createMockSubscription({
+        checkpoint: new Date(2024, 0, 1, 0, 0, 10).toISOString(),
+        progressiveCache: {
+          docIds: mockDocs.slice(0, 20).map(function (d) {
+            return d.name;
+          }),
+          nextCursor: "doc-19",
+          hasMore: true,
+          totalCount: void 0
+        }
+      });
+      await backfillManager.backfill(subscription, BackfillReason.Periodic);
+      expect(mockDb.backfill).toHaveBeenCalled();
+      expect(subscription.checkpoint).toBeDefined();
+      expect(subscription.checkpoint).not.toBe(new Date(2024, 0, 1, 0, 0, 10).toISOString());
+    });
+    it("should process deletions from CDC response", async function () {
+      var 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, BackfillReason.Periodic);
+      expect(subscription.testProgressiveCache.docIds).not.toContain("doc-2");
+      expect(subscription.testProgressiveCache.docIds).toContain("doc-1");
+      expect(subscription.testProgressiveCache.docIds).toContain("doc-3");
+      expect(mockNormalizedCache.remove).toHaveBeenCalledWith({
+        doctype: "TestDoc",
+        name: "doc-2"
+      });
+    });
+    it("should handle documents that no longer match filters", async function () {
+      var {
+        matchesFilters
+      } = await import("./filters.native.js");
+      vi.mocked(matchesFilters).mockImplementation(function (doc, _filters) {
+        return doc.name !== "doc-1";
+      });
+      var 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, BackfillReason.Periodic);
+      expect(subscription.testProgressiveCache.docIds).not.toContain("doc-1");
+      expect(subscription.testProgressiveCache.docIds).toContain("doc-2");
+    });
+    it("should mark for rehydration when new document matches", async function () {
+      var {
+        matchesFilters
+      } = await import("./filters.native.js");
+      vi.mocked(matchesFilters).mockReturnValue(true);
+      var 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, BackfillReason.Periodic);
+      expect(subscription.needsRehydration).toBe(true);
+    });
+    it("should fallback to full refresh on error", async function () {
+      var subscription = createMockSubscription({
+        checkpoint: new Date(2024, 0, 1).toISOString()
+      });
+      mockDb.backfill.mockRejectedValueOnce(new Error("CDC error"));
+      await backfillManager.backfill(subscription, BackfillReason.Periodic);
+      expect(mockDb.getDocList).toHaveBeenCalled();
+      expect(subscription.testProgressiveCache.docIds.length).toBeGreaterThan(0);
+    });
+  });
+  describe("cursor-based fetching", function () {
+    it("should fetch next batch using cursor", async function () {
+      var subscription = createMockSubscription({
+        progressiveCache: {
+          docIds: mockDocs.slice(0, 20).map(function (d) {
+            return d.name;
+          }),
+          nextCursor: "doc-19",
+          hasMore: true,
+          totalCount: void 0
+        }
+      });
+      await backfillManager.backfill(subscription, BackfillReason.Pagination);
+      expect(mockDb.getDocList).toHaveBeenCalledWith("TestDoc", {
+        fields: void 0,
+        filters: void 0,
+        orderBy: {
+          field: "modified",
+          order: Order.Asc
+        },
+        cursor: "doc-19",
+        limit: 50
+      });
+      expect(subscription.testProgressiveCache.docIds.length).toBeGreaterThan(20);
+    });
+    it("should update cursor and hasMore flag", async function () {
+      var subscription = createMockSubscription({
+        progressiveCache: {
+          docIds: mockDocs.slice(0, 80).map(function (d) {
+            return d.name;
+          }),
+          nextCursor: "doc-79",
+          hasMore: true,
+          totalCount: void 0
+        }
+      });
+      mockDb.getDocList.mockResolvedValueOnce(mockDocs.slice(80, 100));
+      await backfillManager.backfill(subscription, BackfillReason.Pagination);
+      expect(subscription.testProgressiveCache.hasMore).toBe(false);
+      expect(subscription.testProgressiveCache.nextCursor).toBe("doc-99");
+    });
+    it("should not fetch if no more data available", async function () {
+      var subscription = createMockSubscription({
+        progressiveCache: {
+          docIds: mockDocs.map(function (d) {
+            return d.name;
+          }),
+          nextCursor: "doc-99",
+          hasMore: false,
+          totalCount: 100
+        }
+      });
+      var initialLength = subscription.testProgressiveCache.docIds.length;
+      await backfillManager.backfill(subscription, BackfillReason.Pagination);
+      expect(subscription.testProgressiveCache.docIds.length).toBe(initialLength);
+    });
+  });
+  describe("queue management", function () {
+    it("should not queue duplicate reasons", async function () {
+      var subscription = createMockSubscription();
+      var resolveFirst;
+      var firstPromise = new Promise(function (resolve) {
+        resolveFirst = resolve;
+      });
+      mockDb.getDocList.mockImplementationOnce(async function () {
+        await firstPromise;
+        return mockDocs.slice(0, 50);
+      });
+      var promise1 = backfillManager.backfill(subscription, BackfillReason.Initial);
+      var promise2 = backfillManager.backfill(subscription, BackfillReason.Pagination);
+      var promise3 = backfillManager.backfill(subscription, BackfillReason.Pagination);
+      var promise4 = backfillManager.backfill(subscription, BackfillReason.Pagination);
+      resolveFirst();
+      await Promise.all([promise1, promise2, promise3, promise4]);
+      expect(mockDb.getDocList).toHaveBeenCalledTimes(2);
+    });
+    it("should process queue in FIFO order", async function () {
+      var subscription = createMockSubscription();
+      var callOrder = [];
+      mockDb.getDocList.mockImplementation(async function () {
+        await new Promise(function (resolve) {
+          return setTimeout(resolve, 10);
+        });
+        return mockDocs.slice(0, 50);
+      });
+      var originalPerform = backfillManager.performBackfill;
+      backfillManager.performBackfill = async function (sub, reason) {
+        callOrder.push(reason);
+        return originalPerform.call(this, sub, reason);
+      };
+      var promise1 = backfillManager.backfill(subscription, BackfillReason.Initial);
+      var promise2 = backfillManager.backfill(subscription, BackfillReason.Pagination);
+      var promise3 = backfillManager.backfill(subscription, BackfillReason.DeleteGap);
+      await Promise.all([promise1, promise2, promise3]);
+      await new Promise(function (resolve) {
+        return setTimeout(resolve, 200);
+      });
+      expect(callOrder).toEqual([BackfillReason.Initial, BackfillReason.Pagination, BackfillReason.DeleteGap]);
+    });
+  });
+  describe("checkpoint calculation", function () {
+    it("should calculate checkpoint from highest modified timestamp", async function () {
+      var subscription = createMockSubscription({
+        checkpoint: void 0
+      });
+      var 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, BackfillReason.Initial);
+      expect(subscription.checkpoint).toBe("2024-01-01T00:00:30Z");
+    });
+    it("should handle documents without modified field", async function () {
+      var subscription = createMockSubscription({
+        checkpoint: void 0
+      });
+      var 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, BackfillReason.Initial);
+      expect(subscription.checkpoint).toBe("2024-01-01T00:00:00Z");
+    });
+    it("should return undefined for empty document list", async function () {
+      var subscription = createMockSubscription({
+        checkpoint: void 0
+      });
+      mockDb.getDocList.mockResolvedValueOnce([]);
+      await backfillManager.backfill(subscription, BackfillReason.Initial);
+      expect(subscription.checkpoint).toBeUndefined();
+    });
+  });
+});
+//# sourceMappingURL=backfill.spec.native.js.map