@multiplatform.one/frappe 6.1.0 → 6.3.0

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

@@ -1,712 +0,0 @@
-"use strict";
-
-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.native.js");
-var import_types = require("./types.native.js");
-var import_virtualPageManager = require("./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;
-  })();
-}
-import_vitest.vi.mock("./filters", function () {
-  return {
-    matchesFilters: import_vitest.vi.fn(function () {
-      return true;
-    })
-  };
-});
-(0, import_vitest.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;
-  }(import_virtualPageManager.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: import_types.Order.Asc
-      }
-    }, [], progressiveCache, {
-      currentPage: 1,
-      pageSize: 20
-    }, otherOverrides);
-  };
-  (0, import_vitest.beforeEach)(function () {
-    mockDb = {
-      getDocList: import_vitest.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: import_vitest.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: import_vitest.vi.fn(async function () {
-        return 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(function (doctype, name) {
-        var doc = mockDocs.find(function (d) {
-          return 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", function () {
-    (0, import_vitest.it)("should perform backfill for initial reason", async function () {
-      var 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 function () {
-      var subscription = createMockSubscription();
-      var firstPromise = backfillManager.backfill(subscription, import_backfill.BackfillReason.Initial);
-      var 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 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, import_backfill.BackfillReason.Initial);
-      var promise2 = backfillManager.backfill(subscription, import_backfill.BackfillReason.Pagination);
-      var promise3 = backfillManager.backfill(subscription, import_backfill.BackfillReason.DeleteGap);
-      await Promise.all([promise1, promise2, promise3]);
-      await new Promise(function (resolve) {
-        return setTimeout(resolve, 200);
-      });
-    });
-    (0, import_vitest.it)("should handle different backfill reasons", async function () {
-      var 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", function () {
-    (0, import_vitest.it)("should fetch and add one document", async function () {
-      var subscription = createMockSubscription();
-      var doc = await backfillManager.backfillOne(subscription);
-      (0, import_vitest.expect)(doc).toBeDefined();
-      (0, import_vitest.expect)(doc === null || doc === void 0 ? void 0 : 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 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);
-      (0, import_vitest.expect)(doc).toBeNull();
-      (0, import_vitest.expect)(mockDb.getDocList).not.toHaveBeenCalled();
-    });
-    (0, import_vitest.it)("should handle fetch errors gracefully", async function () {
-      var subscription = createMockSubscription();
-      mockDb.getDocList.mockRejectedValueOnce(new Error("Network error"));
-      var doc = await backfillManager.backfillOne(subscription);
-      (0, import_vitest.expect)(doc).toBeNull();
-    });
-    (0, import_vitest.it)("should update hasMore flag when no documents returned", async function () {
-      var subscription = createMockSubscription();
-      mockDb.getDocList.mockResolvedValueOnce([]);
-      var 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", function () {
-    (0, import_vitest.it)("should refresh current page from server", async function () {
-      var 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 function () {
-      var 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 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);
-      (0, import_vitest.expect)(subscription.testProgressiveCache.docIds.slice(0, 20)).toEqual(mockDocs.slice(0, 20).map(function (d) {
-        return 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 function () {
-      var 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", function () {
-    (0, import_vitest.it)("should use FullRefresh for Initial reason", async function () {
-      var 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 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, 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 function () {
-      var 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 function () {
-      var 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 function () {
-      var originalCheckpoint = new Date(2024, 0, 1, 0, 0, 10).toISOString();
-      var 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 function () {
-      var 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", function () {
-    (0, import_vitest.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, 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 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, 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 function () {
-      var {
-        matchesFilters
-      } = await import("./filters");
-      import_vitest.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, 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 function () {
-      var {
-        matchesFilters
-      } = await import("./filters");
-      import_vitest.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, import_backfill.BackfillReason.Periodic);
-      (0, import_vitest.expect)(subscription.needsRehydration).toBe(true);
-    });
-    (0, import_vitest.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, 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", function () {
-    (0, import_vitest.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, 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
-      });
-      (0, import_vitest.expect)(subscription.testProgressiveCache.docIds.length).toBeGreaterThan(20);
-    });
-    (0, import_vitest.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, 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 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, import_backfill.BackfillReason.Pagination);
-      (0, import_vitest.expect)(subscription.testProgressiveCache.docIds.length).toBe(initialLength);
-    });
-  });
-  (0, import_vitest.describe)("queue management", function () {
-    (0, import_vitest.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, import_backfill.BackfillReason.Initial);
-      var promise2 = backfillManager.backfill(subscription, import_backfill.BackfillReason.Pagination);
-      var promise3 = backfillManager.backfill(subscription, import_backfill.BackfillReason.Pagination);
-      var 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 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, import_backfill.BackfillReason.Initial);
-      var promise2 = backfillManager.backfill(subscription, import_backfill.BackfillReason.Pagination);
-      var promise3 = backfillManager.backfill(subscription, import_backfill.BackfillReason.DeleteGap);
-      await Promise.all([promise1, promise2, promise3]);
-      await new Promise(function (resolve) {
-        return 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", function () {
-    (0, import_vitest.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, 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 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, 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 function () {
-      var subscription = createMockSubscription({
-        checkpoint: void 0
-      });
-      mockDb.getDocList.mockResolvedValueOnce([]);
-      await backfillManager.backfill(subscription, import_backfill.BackfillReason.Initial);
-      (0, import_vitest.expect)(subscription.checkpoint).toBeUndefined();
-    });
-  });
-});
-//# sourceMappingURL=backfill.spec.native.js.map