@multiplatform.one/frappe 6.1.0 → 6.4.0

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

@@ -1,1136 +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_subscriptionManager = require("./subscriptionManager.native.js");
-var import_types = require("./types.native.js");
-var import_types2 = require("./types.native.js");
-var filters = __toESM(require("./filters.native.js"));
-(0, import_vitest.describe)("SubscriptionManager", function () {
-  var subscriptionManager;
-  var mockDb;
-  var mockNormalizedCache;
-  var mockDoc = {
-    name: "test-doc",
-    doctype: "TestDoc",
-    title: "Test Document",
-    modified: "2024-01-01T10:00:00",
-    creation: "2024-01-01T09:00:00",
-    owner: "test-user",
-    modified_by: "test-user"
-  };
-  var mockDocs = [{
-    name: "doc1",
-    doctype: "TestDoc",
-    modified: "2024-01-01T09:00:00",
-    title: "Document 1"
-  }, {
-    name: "doc2",
-    doctype: "TestDoc",
-    modified: "2024-01-01T10:00:00",
-    title: "Document 2"
-  }, {
-    name: "doc3",
-    doctype: "TestDoc",
-    modified: "2024-01-01T11:00:00",
-    title: "Document 3"
-  }];
-  var uuidCount = 0;
-  (0, import_vitest.beforeEach)(function () {
-    uuidCount = 0;
-    import_vitest.vi.spyOn(filters, "matchesFilters").mockReturnValue(true);
-    import_vitest.vi.spyOn(filters, "extractSingleName").mockReturnValue(void 0);
-    mockDb = {
-      getDoc: import_vitest.vi.fn().mockResolvedValue(mockDoc),
-      getDocList: import_vitest.vi.fn().mockResolvedValue(mockDocs),
-      backfill: import_vitest.vi.fn().mockResolvedValue({
-        rows: [],
-        checkpoint: "2024-01-01T12:00:00"
-      })
-    };
-    mockNormalizedCache = {
-      upsert: import_vitest.vi.fn(),
-      get: import_vitest.vi.fn().mockImplementation(function (param) {
-        var {
-          name
-        } = param;
-        return mockDocs.find(function (doc) {
-          return doc.name === name;
-        }) || mockDoc;
-      }),
-      remove: import_vitest.vi.fn()
-    };
-    Object.defineProperty(global, "crypto", {
-      value: {
-        randomUUID: import_vitest.vi.fn().mockImplementation(function () {
-          return `uuid-${++uuidCount}`;
-        })
-      },
-      writable: true
-    });
-  });
-  (0, import_vitest.afterEach)(function () {
-    import_vitest.vi.restoreAllMocks();
-  });
-  (0, import_vitest.describe)("constructor", function () {
-    (0, import_vitest.it)("should initialize with default options", function () {
-      subscriptionManager = new import_subscriptionManager.SubscriptionManager(mockDb, mockNormalizedCache);
-      (0, import_vitest.expect)(subscriptionManager).toBeDefined();
-    });
-    (0, import_vitest.it)("should initialize with custom options", function () {
-      var options = {
-        pageSize: 50,
-        useCursorPagination: true,
-        onBackfill: import_vitest.vi.fn()
-      };
-      subscriptionManager = new import_subscriptionManager.SubscriptionManager(mockDb, mockNormalizedCache, options);
-      (0, import_vitest.expect)(subscriptionManager).toBeDefined();
-    });
-  });
-  (0, import_vitest.describe)("subscribe", function () {
-    (0, import_vitest.beforeEach)(function () {
-      subscriptionManager = new import_subscriptionManager.SubscriptionManager(mockDb, mockNormalizedCache);
-    });
-    (0, import_vitest.it)("should create a subscription successfully", async function () {
-      var query = {
-        doctype: "TestDoc",
-        fields: ["title", "description"],
-        filters: {
-          status: "Active"
-        },
-        orderBy: {
-          field: "modified",
-          order: import_types2.Order.Desc
-        },
-        limit: 20
-      };
-      var result = await subscriptionManager.subscribe(query);
-      (0, import_vitest.expect)(result.subscriptionId).toBe("uuid-1");
-      (0, import_vitest.expect)(result.rows).toEqual(mockDocs);
-      (0, import_vitest.expect)(result.checkpoint).toBe("2024-01-01T11:00:00");
-      (0, import_vitest.expect)(mockDb.getDocList).toHaveBeenCalledWith("TestDoc", {
-        fields: ["title", "description", "modified", "name"],
-        filters: {
-          status: "Active"
-        },
-        orderBy: {
-          field: "modified",
-          order: import_types2.Order.Desc
-        }
-      });
-    });
-    (0, import_vitest.it)("should handle single document queries", async function () {
-      filters.extractSingleName.mockReturnValue("specific-doc");
-      var query = {
-        doctype: "TestDoc",
-        fields: ["*"],
-        filters: {
-          name: "specific-doc"
-        }
-      };
-      var result = await subscriptionManager.subscribe(query);
-      (0, import_vitest.expect)(mockDb.getDoc).toHaveBeenCalledWith("TestDoc", "specific-doc");
-      (0, import_vitest.expect)(result.rows).toEqual([mockDoc]);
-    });
-    (0, import_vitest.it)("should handle single document query errors", async function () {
-      filters.extractSingleName.mockReturnValue("non-existent-doc");
-      mockDb.getDoc.mockRejectedValue(Object.assign(new Error("Document not found"), {
-        status: 404
-      }));
-      var query = {
-        doctype: "TestDoc",
-        fields: ["*"],
-        filters: {
-          name: "non-existent-doc"
-        }
-      };
-      var result = await subscriptionManager.subscribe(query);
-      (0, import_vitest.expect)(result.rows).toEqual([]);
-    });
-    (0, import_vitest.it)("should handle cursor pagination", async function () {
-      subscriptionManager = new import_subscriptionManager.SubscriptionManager(mockDb, mockNormalizedCache, {
-        useCursorPagination: true
-      });
-      mockDb.getDocList.mockResolvedValue({
-        data: mockDocs,
-        cursor: "cursor-123"
-      });
-      var query = {
-        doctype: "TestDoc",
-        fields: ["*"],
-        limit: 20
-      };
-      var result = await subscriptionManager.subscribe(query);
-      (0, import_vitest.expect)(mockDb.getDocList).toHaveBeenCalledWith("TestDoc", {
-        fields: ["*", "modified", "name"],
-        cursor: void 0
-      });
-      (0, import_vitest.expect)(result.rows).toEqual(mockDocs);
-      var subscription = subscriptionManager.getSubscription(result.subscriptionId);
-      (0, import_vitest.expect)(subscription === null || subscription === void 0 ? void 0 : subscription.cursor).toBe("cursor-123");
-    });
-    (0, import_vitest.it)("should seed normalized cache with returned documents", async function () {
-      var query = {
-        doctype: "TestDoc",
-        fields: ["*"]
-      };
-      await subscriptionManager.subscribe(query);
-      (0, import_vitest.expect)(mockNormalizedCache.upsert).toHaveBeenCalledTimes(3);
-      var _iteratorNormalCompletion = true,
-        _didIteratorError = false,
-        _iteratorError = void 0;
-      try {
-        for (var _iterator = mockDocs[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
-          var doc = _step.value;
-          (0, import_vitest.expect)(mockNormalizedCache.upsert).toHaveBeenCalledWith(doc);
-        }
-      } catch (err) {
-        _didIteratorError = true;
-        _iteratorError = err;
-      } finally {
-        try {
-          if (!_iteratorNormalCompletion && _iterator.return != null) {
-            _iterator.return();
-          }
-        } finally {
-          if (_didIteratorError) {
-            throw _iteratorError;
-          }
-        }
-      }
-    });
-    (0, import_vitest.it)("should compute checkpoint as max modified time", async function () {
-      var query = {
-        doctype: "TestDoc",
-        fields: ["*"]
-      };
-      var result = await subscriptionManager.subscribe(query);
-      (0, import_vitest.expect)(result.checkpoint).toBe("2024-01-01T11:00:00");
-    });
-    (0, import_vitest.it)("should set page boundaries", async function () {
-      var query = {
-        doctype: "TestDoc",
-        fields: ["*"],
-        limitStart: 10,
-        limit: 15
-      };
-      var result = await subscriptionManager.subscribe(query);
-      var subscription = subscriptionManager.getSubscription(result.subscriptionId);
-      (0, import_vitest.expect)(subscription === null || subscription === void 0 ? void 0 : subscription.boundaries).toEqual({
-        firstItem: mockDocs[0],
-        lastItem: mockDocs[2],
-        offset: 10,
-        pageSize: 15
-      });
-    });
-    (0, import_vitest.it)("should initialize metadata", async function () {
-      var query = {
-        doctype: "TestDoc",
-        fields: ["*"]
-      };
-      var result = await subscriptionManager.subscribe(query);
-      var subscription = subscriptionManager.getSubscription(result.subscriptionId);
-      (0, import_vitest.expect)(subscription === null || subscription === void 0 ? void 0 : subscription.metadata).toEqual({
-        itemsBeforePage: 0,
-        itemsAfterPage: 0
-      });
-    });
-    (0, import_vitest.it)("should handle empty results", async function () {
-      mockDb.getDocList.mockResolvedValue([]);
-      var query = {
-        doctype: "TestDoc",
-        fields: ["*"]
-      };
-      var result = await subscriptionManager.subscribe(query);
-      (0, import_vitest.expect)(result.rows).toEqual([]);
-      (0, import_vitest.expect)(result.checkpoint).toBeUndefined();
-      var subscription = subscriptionManager.getSubscription(result.subscriptionId);
-      (0, import_vitest.expect)(subscription === null || subscription === void 0 ? void 0 : subscription.boundaries).toBeUndefined();
-    });
-  });
-  (0, import_vitest.describe)("unsubscribe", function () {
-    (0, import_vitest.beforeEach)(function () {
-      subscriptionManager = new import_subscriptionManager.SubscriptionManager(mockDb, mockNormalizedCache);
-    });
-    (0, import_vitest.it)("should remove subscription", async function () {
-      var query = {
-        doctype: "TestDoc",
-        fields: ["*"]
-      };
-      var result = await subscriptionManager.subscribe(query);
-      (0, import_vitest.expect)(subscriptionManager.getSubscription(result.subscriptionId)).toBeDefined();
-      subscriptionManager.unsubscribe(result.subscriptionId);
-      (0, import_vitest.expect)(subscriptionManager.getSubscription(result.subscriptionId)).toBeUndefined();
-    });
-    (0, import_vitest.it)("should handle non-existent subscription", function () {
-      (0, import_vitest.expect)(function () {
-        subscriptionManager.unsubscribe("non-existent");
-      }).not.toThrow();
-    });
-  });
-  (0, import_vitest.describe)("getDocsForSubscription", function () {
-    (0, import_vitest.beforeEach)(function () {
-      subscriptionManager = new import_subscriptionManager.SubscriptionManager(mockDb, mockNormalizedCache);
-    });
-    (0, import_vitest.it)("should return documents from virtual page system when available", async function () {
-      var virtualPageManager = subscriptionManager.virtualPageManager;
-      import_vitest.vi.spyOn(virtualPageManager, "getSubscription").mockReturnValue({
-        query: {
-          doctype: "TestDoc"
-        },
-        getProgressiveCache: function getProgressiveCache() {
-          return {
-            docIds: ["doc1", "doc2"]
-          };
-        }
-      });
-      var query = {
-        doctype: "TestDoc",
-        fields: ["*"]
-      };
-      var result = await subscriptionManager.subscribe(query);
-      var docs = subscriptionManager.getDocsForSubscription(result.subscriptionId);
-      (0, import_vitest.expect)(docs).toHaveLength(2);
-    });
-    (0, import_vitest.it)("should resolve documents from the standard subscription map when virtual pages are absent", async function () {
-      var query = {
-        doctype: "TestDoc",
-        fields: ["*"]
-      };
-      var result = await subscriptionManager.subscribe(query);
-      var docs = subscriptionManager.getDocsForSubscription(result.subscriptionId);
-      (0, import_vitest.expect)(docs).toHaveLength(3);
-    });
-    (0, import_vitest.it)("should return empty array for non-existent subscription", function () {
-      var docs = subscriptionManager.getDocsForSubscription("non-existent");
-      (0, import_vitest.expect)(docs).toEqual([]);
-    });
-    (0, import_vitest.it)("should handle missing documents in cache", async function () {
-      mockNormalizedCache.get.mockReturnValue(void 0);
-      var query = {
-        doctype: "TestDoc",
-        fields: ["*"]
-      };
-      var result = await subscriptionManager.subscribe(query);
-      var docs = subscriptionManager.getDocsForSubscription(result.subscriptionId);
-      (0, import_vitest.expect)(docs).toEqual([]);
-    });
-  });
-  (0, import_vitest.describe)("virtual pagination methods", function () {
-    (0, import_vitest.beforeEach)(function () {
-      subscriptionManager = new import_subscriptionManager.SubscriptionManager(mockDb, mockNormalizedCache);
-    });
-    (0, import_vitest.it)("should delegate getPage to virtual page system", async function () {
-      var virtualPageManager = subscriptionManager.virtualPageManager;
-      var mockPageData = [mockDoc];
-      import_vitest.vi.spyOn(virtualPageManager, "getPage").mockResolvedValue(mockPageData);
-      var result = await subscriptionManager.getPage("sub1", 2);
-      (0, import_vitest.expect)(virtualPageManager.getPage).toHaveBeenCalledWith("sub1", 2);
-      (0, import_vitest.expect)(result).toEqual(mockPageData);
-    });
-    (0, import_vitest.it)("should delegate getNextBatch to virtual page system", async function () {
-      var virtualPageManager = subscriptionManager.virtualPageManager;
-      var mockAfterData = [mockDoc];
-      import_vitest.vi.spyOn(virtualPageManager, "getNextBatch").mockResolvedValue(mockAfterData);
-      var result = await subscriptionManager.getNextBatch("sub1", "cursor-doc", 10);
-      (0, import_vitest.expect)(virtualPageManager.getNextBatch).toHaveBeenCalledWith("sub1", "cursor-doc", 10);
-      (0, import_vitest.expect)(result).toEqual(mockAfterData);
-    });
-    (0, import_vitest.it)("should delegate getPageInfo to virtual page system", function () {
-      var virtualPageManager = subscriptionManager.virtualPageManager;
-      var mockPageInfo = {
-        currentPage: 2,
-        pageSize: 20,
-        totalPages: 5,
-        hasMore: true,
-        itemsInCache: 100
-      };
-      import_vitest.vi.spyOn(virtualPageManager, "getPageInfo").mockReturnValue(mockPageInfo);
-      var result = subscriptionManager.getPageInfo("sub1");
-      (0, import_vitest.expect)(virtualPageManager.getPageInfo).toHaveBeenCalledWith("sub1");
-      (0, import_vitest.expect)(result).toEqual(mockPageInfo);
-    });
-  });
-  (0, import_vitest.describe)("backfill", function () {
-    (0, import_vitest.beforeEach)(function () {
-      subscriptionManager = new import_subscriptionManager.SubscriptionManager(mockDb, mockNormalizedCache, {
-        pageSize: 100,
-        onBackfill: import_vitest.vi.fn()
-      });
-    });
-    (0, import_vitest.it)("should backfill all subscriptions", async function () {
-      var query1 = {
-        doctype: "TestDoc",
-        fields: ["*"]
-      };
-      var query2 = {
-        doctype: "OtherDoc",
-        fields: ["*"]
-      };
-      await subscriptionManager.subscribe(query1);
-      await subscriptionManager.subscribe(query2);
-      var backfillSpy = import_vitest.vi.spyOn(subscriptionManager, "backfillSub");
-      await subscriptionManager.backfill({
-        scope: import_types.BackfillScope.All
-      });
-      (0, import_vitest.expect)(backfillSpy).toHaveBeenCalledTimes(2);
-    });
-    (0, import_vitest.it)("should backfill specific subscriptions", async function () {
-      var result1 = await subscriptionManager.subscribe({
-        doctype: "TestDoc",
-        fields: ["*"]
-      });
-      var _result2 = await subscriptionManager.subscribe({
-        doctype: "OtherDoc",
-        fields: ["*"]
-      });
-      var backfillSpy = import_vitest.vi.spyOn(subscriptionManager, "backfillSub");
-      await subscriptionManager.backfill({
-        scope: import_types.BackfillScope.Subscriptions,
-        subscriptions: [result1.subscriptionId]
-      });
-      (0, import_vitest.expect)(backfillSpy).toHaveBeenCalledTimes(1);
-    });
-    (0, import_vitest.it)("should backfill by doctypes", async function () {
-      await subscriptionManager.subscribe({
-        doctype: "TestDoc",
-        fields: ["*"]
-      });
-      await subscriptionManager.subscribe({
-        doctype: "OtherDoc",
-        fields: ["*"]
-      });
-      var backfillSpy = import_vitest.vi.spyOn(subscriptionManager, "backfillSub");
-      await subscriptionManager.backfill({
-        scope: import_types.BackfillScope.Doctypes,
-        doctypes: ["TestDoc"]
-      });
-      (0, import_vitest.expect)(backfillSpy).toHaveBeenCalledTimes(1);
-    });
-    (0, import_vitest.it)("should backfill specific documents", async function () {
-      var docTargets = [{
-        doctype: "TestDoc",
-        name: "doc1"
-      }, {
-        doctype: "TestDoc",
-        name: "doc2"
-      }];
-      await subscriptionManager.backfill({
-        scope: import_types.BackfillScope.Docs,
-        docs: docTargets
-      });
-      (0, import_vitest.expect)(mockDb.getDoc).toHaveBeenCalledWith("TestDoc", "doc1");
-      (0, import_vitest.expect)(mockDb.getDoc).toHaveBeenCalledWith("TestDoc", "doc2");
-      (0, import_vitest.expect)(mockNormalizedCache.upsert).toHaveBeenCalledTimes(2);
-    });
-  });
-  (0, import_vitest.describe)("backfillSub", function () {
-    (0, import_vitest.beforeEach)(function () {
-      subscriptionManager = new import_subscriptionManager.SubscriptionManager(mockDb, mockNormalizedCache, {
-        onBackfill: import_vitest.vi.fn()
-      });
-    });
-    (0, import_vitest.it)("should perform CDC backfill for subscription", async function () {
-      var result = await subscriptionManager.subscribe({
-        doctype: "TestDoc",
-        fields: ["*"],
-        filters: {
-          status: "Active"
-        }
-      });
-      var subscription = subscriptionManager.getSubscription(result.subscriptionId);
-      var backfillResponse = {
-        rows: [{
-          name: "doc4",
-          doctype: "TestDoc",
-          modified: "2024-01-02T10:00:00"
-        }],
-        checkpoint: "2024-01-02T10:00:00"
-      };
-      mockDb.backfill.mockResolvedValue(backfillResponse);
-      await subscriptionManager.backfillSub(subscription);
-      (0, import_vitest.expect)(mockDb.backfill).toHaveBeenCalledWith({
-        doctype: "TestDoc",
-        fields: ["*"],
-        filters: {
-          status: "Active"
-        },
-        modifiedAfter: "2024-01-01T11:00:00",
-        limit: 200
-      });
-      (0, import_vitest.expect)(subscription.checkpoint).toBe("2024-01-02T10:00:00");
-    });
-    (0, import_vitest.it)("should handle tombstones (deleted documents)", async function () {
-      var _subscription_tombstones;
-      var result = await subscriptionManager.subscribe({
-        doctype: "TestDoc",
-        fields: ["*"]
-      });
-      var subscription = subscriptionManager.getSubscription(result.subscriptionId);
-      var backfillResponse = {
-        rows: [],
-        deleted: [{
-          doctype: "TestDoc",
-          name: "doc2"
-        }],
-        checkpoint: "2024-01-02T10:00:00"
-      };
-      mockDb.backfill.mockResolvedValue(backfillResponse);
-      await subscriptionManager.backfillSub(subscription);
-      (0, import_vitest.expect)(mockNormalizedCache.remove).toHaveBeenCalledWith({
-        doctype: "TestDoc",
-        name: "doc2"
-      });
-      (0, import_vitest.expect)(subscription.docIds).not.toContain("doc2");
-      (0, import_vitest.expect)((_subscription_tombstones = subscription.tombstones) === null || _subscription_tombstones === void 0 ? void 0 : _subscription_tombstones.has("doc2")).toBe(true);
-    });
-    (0, import_vitest.it)("should reconcile membership with filters", async function () {
-      var result = await subscriptionManager.subscribe({
-        doctype: "TestDoc",
-        fields: ["*"],
-        filters: {
-          status: "Active"
-        }
-      });
-      var subscription = subscriptionManager.getSubscription(result.subscriptionId);
-      var newDoc = {
-        name: "doc4",
-        doctype: "TestDoc",
-        status: "Active",
-        modified: "2024-01-02T10:00:00"
-      };
-      var backfillResponse = {
-        rows: [newDoc],
-        checkpoint: "2024-01-02T10:00:00"
-      };
-      mockDb.backfill.mockResolvedValue(backfillResponse);
-      filters.matchesFilters.mockReturnValue(true);
-      await subscriptionManager.backfillSub(subscription);
-      (0, import_vitest.expect)(subscription.docIds).toContain("doc4");
-    });
-    (0, import_vitest.it)("should remove documents that no longer match filters", async function () {
-      var result = await subscriptionManager.subscribe({
-        doctype: "TestDoc",
-        fields: ["*"],
-        filters: {
-          status: "Active"
-        }
-      });
-      var subscription = subscriptionManager.getSubscription(result.subscriptionId);
-      var updatedDoc = {
-        name: "doc1",
-        doctype: "TestDoc",
-        status: "Inactive",
-        modified: "2024-01-02T10:00:00"
-      };
-      var backfillResponse = {
-        rows: [updatedDoc],
-        checkpoint: "2024-01-02T10:00:00"
-      };
-      mockDb.backfill.mockResolvedValue(backfillResponse);
-      filters.matchesFilters.mockReturnValue(false);
-      await subscriptionManager.backfillSub(subscription);
-      (0, import_vitest.expect)(subscription.docIds).not.toContain("doc1");
-    });
-    (0, import_vitest.it)("should update page boundaries after backfill", async function () {
-      var result = await subscriptionManager.subscribe({
-        doctype: "TestDoc",
-        fields: ["*"]
-      });
-      var subscription = subscriptionManager.getSubscription(result.subscriptionId);
-      await subscriptionManager.backfillSub(subscription);
-      (0, import_vitest.expect)(subscription.boundaries).toBeDefined();
-    });
-    (0, import_vitest.it)("should call onBackfill callback", async function () {
-      var onBackfill = import_vitest.vi.fn();
-      subscriptionManager = new import_subscriptionManager.SubscriptionManager(mockDb, mockNormalizedCache, {
-        onBackfill
-      });
-      var result = await subscriptionManager.subscribe({
-        doctype: "TestDoc",
-        fields: ["*"]
-      });
-      var subscription = subscriptionManager.getSubscription(result.subscriptionId);
-      await subscriptionManager.backfillSub(subscription);
-      (0, import_vitest.expect)(onBackfill).toHaveBeenCalledWith({
-        doctype: "TestDoc",
-        fetched: 0,
-        checkpoint: "2024-01-01T12:00:00"
-      });
-    });
-    (0, import_vitest.it)("should handle queries without filters", async function () {
-      var result = await subscriptionManager.subscribe({
-        doctype: "TestDoc",
-        fields: ["*"]
-      });
-      var subscription = subscriptionManager.getSubscription(result.subscriptionId);
-      var backfillResponse = {
-        rows: [{
-          name: "doc4",
-          doctype: "TestDoc"
-        }, {
-          name: "doc5",
-          doctype: "TestDoc"
-        }],
-        checkpoint: "2024-01-02T10:00:00"
-      };
-      mockDb.backfill.mockResolvedValue(backfillResponse);
-      await subscriptionManager.backfillSub(subscription);
-      (0, import_vitest.expect)(subscription.docIds).toEqual(["doc4", "doc5"]);
-    });
-  });
-  (0, import_vitest.describe)("resortSubscriptionDocIds", function () {
-    (0, import_vitest.beforeEach)(function () {
-      subscriptionManager = new import_subscriptionManager.SubscriptionManager(mockDb, mockNormalizedCache);
-    });
-    (0, import_vitest.it)("should sort by orderBy field ascending", async function () {
-      var result = await subscriptionManager.subscribe({
-        doctype: "TestDoc",
-        fields: ["*"],
-        orderBy: {
-          field: "modified",
-          order: import_types2.Order.Asc
-        }
-      });
-      var subscription = subscriptionManager.getSubscription(result.subscriptionId);
-      subscriptionManager.resortSubscriptionDocIds(subscription);
-      (0, import_vitest.expect)(subscription.docIds).toEqual(["doc1", "doc2", "doc3"]);
-    });
-    (0, import_vitest.it)("should sort by orderBy field descending", async function () {
-      var result = await subscriptionManager.subscribe({
-        doctype: "TestDoc",
-        fields: ["*"],
-        orderBy: {
-          field: "modified",
-          order: import_types2.Order.Desc
-        }
-      });
-      var subscription = subscriptionManager.getSubscription(result.subscriptionId);
-      subscriptionManager.resortSubscriptionDocIds(subscription);
-      (0, import_vitest.expect)(subscription.docIds).toEqual(["doc3", "doc2", "doc1"]);
-    });
-    (0, import_vitest.it)("should handle documents with null values", async function () {
-      var docWithNull = {
-        name: "doc4",
-        doctype: "TestDoc",
-        modified: null
-      };
-      mockNormalizedCache.get.mockImplementation(function (param) {
-        var {
-          name
-        } = param;
-        if (name === "doc4") return docWithNull;
-        return mockDocs.find(function (doc) {
-          return doc.name === name;
-        });
-      });
-      var result = await subscriptionManager.subscribe({
-        doctype: "TestDoc",
-        fields: ["*"],
-        orderBy: {
-          field: "modified",
-          order: import_types2.Order.Asc
-        }
-      });
-      var subscription = subscriptionManager.getSubscription(result.subscriptionId);
-      subscription.docIds = ["doc1", "doc4", "doc2"];
-      subscriptionManager.resortSubscriptionDocIds(subscription);
-      (0, import_vitest.expect)(subscription.docIds[0]).toBe("doc4");
-    });
-    (0, import_vitest.it)("should use name as tiebreaker", async function () {
-      var docsWithSameModified = [{
-        name: "doc-b",
-        doctype: "TestDoc",
-        modified: "2024-01-01T10:00:00"
-      }, {
-        name: "doc-a",
-        doctype: "TestDoc",
-        modified: "2024-01-01T10:00:00"
-      }, {
-        name: "doc-c",
-        doctype: "TestDoc",
-        modified: "2024-01-01T10:00:00"
-      }];
-      mockNormalizedCache.get.mockImplementation(function (param) {
-        var {
-          name
-        } = param;
-        return docsWithSameModified.find(function (doc) {
-          return doc.name === name;
-        });
-      });
-      var result = await subscriptionManager.subscribe({
-        doctype: "TestDoc",
-        fields: ["*"],
-        orderBy: {
-          field: "modified",
-          order: import_types2.Order.Asc
-        }
-      });
-      var subscription = subscriptionManager.getSubscription(result.subscriptionId);
-      subscription.docIds = ["doc-b", "doc-a", "doc-c"];
-      subscriptionManager.resortSubscriptionDocIds(subscription);
-      (0, import_vitest.expect)(subscription.docIds).toEqual(["doc-a", "doc-b", "doc-c"]);
-    });
-    (0, import_vitest.it)("should skip sorting when no orderBy", async function () {
-      var result = await subscriptionManager.subscribe({
-        doctype: "TestDoc",
-        fields: ["*"]
-      });
-      var subscription = subscriptionManager.getSubscription(result.subscriptionId);
-      var originalOrder = [...subscription.docIds];
-      subscriptionManager.resortSubscriptionDocIds(subscription);
-      (0, import_vitest.expect)(subscription.docIds).toEqual(originalOrder);
-    });
-  });
-  (0, import_vitest.describe)("updateSubscriptionMembership", function () {
-    (0, import_vitest.beforeEach)(function () {
-      subscriptionManager = new import_subscriptionManager.SubscriptionManager(mockDb, mockNormalizedCache);
-    });
-    (0, import_vitest.it)("should return subscriptions needing rehydration for new documents", async function () {
-      var result = await subscriptionManager.subscribe({
-        doctype: "TestDoc",
-        fields: ["*"],
-        filters: {
-          status: "Active"
-        }
-      });
-      var newDoc = {
-        name: "new-doc",
-        doctype: "TestDoc",
-        status: "Active"
-      };
-      filters.matchesFilters.mockReturnValue(true);
-      var needsRehydration = subscriptionManager.updateSubscriptionMembership(newDoc);
-      (0, import_vitest.expect)(needsRehydration).toHaveLength(1);
-      (0, import_vitest.expect)(needsRehydration[0]).toBe(subscriptionManager.getSubscription(result.subscriptionId));
-    });
-    (0, import_vitest.it)("should remove documents that no longer match filters", async function () {
-      var result = await subscriptionManager.subscribe({
-        doctype: "TestDoc",
-        fields: ["*"],
-        filters: {
-          status: "Active"
-        }
-      });
-      var subscription = subscriptionManager.getSubscription(result.subscriptionId);
-      var updatedDoc = {
-        name: "doc1",
-        doctype: "TestDoc",
-        status: "Inactive"
-      };
-      filters.matchesFilters.mockReturnValue(false);
-      subscriptionManager.updateSubscriptionMembership(updatedDoc);
-      (0, import_vitest.expect)(subscription.docIds).not.toContain("doc1");
-    });
-    (0, import_vitest.it)("should resort existing documents", async function () {
-      var result = await subscriptionManager.subscribe({
-        doctype: "TestDoc",
-        fields: ["*"],
-        orderBy: {
-          field: "modified",
-          order: import_types2.Order.Desc
-        }
-      });
-      var subscription = subscriptionManager.getSubscription(result.subscriptionId);
-      var resortSpy = import_vitest.vi.spyOn(subscriptionManager, "resortSubscriptionDocIds");
-      var existingDoc = {
-        name: "doc2",
-        doctype: "TestDoc",
-        modified: "2024-01-02T10:00:00"
-      };
-      filters.matchesFilters.mockReturnValue(true);
-      subscriptionManager.updateSubscriptionMembership(existingDoc);
-      (0, import_vitest.expect)(resortSpy).toHaveBeenCalledWith(subscription);
-    });
-    (0, import_vitest.it)("should skip subscriptions with different doctypes", async function () {
-      await subscriptionManager.subscribe({
-        doctype: "TestDoc",
-        fields: ["*"]
-      });
-      var needsRehydration = subscriptionManager.updateSubscriptionMembership({
-        name: "other-doc",
-        doctype: "OtherDoc"
-      });
-      (0, import_vitest.expect)(needsRehydration).toEqual([]);
-    });
-  });
-  (0, import_vitest.describe)("removeFromAllSubscriptions", function () {
-    (0, import_vitest.beforeEach)(function () {
-      subscriptionManager = new import_subscriptionManager.SubscriptionManager(mockDb, mockNormalizedCache);
-    });
-    (0, import_vitest.it)("should remove document from all matching subscriptions", async function () {
-      var result1 = await subscriptionManager.subscribe({
-        doctype: "TestDoc",
-        fields: ["*"]
-      });
-      var result2 = await subscriptionManager.subscribe({
-        doctype: "TestDoc",
-        fields: ["title"]
-      });
-      var affectedSubs = subscriptionManager.removeFromAllSubscriptions("TestDoc", "doc2");
-      (0, import_vitest.expect)(affectedSubs).toHaveLength(2);
-      var sub1 = subscriptionManager.getSubscription(result1.subscriptionId);
-      var sub2 = subscriptionManager.getSubscription(result2.subscriptionId);
-      (0, import_vitest.expect)(sub1.docIds).not.toContain("doc2");
-      (0, import_vitest.expect)(sub2.docIds).not.toContain("doc2");
-    });
-    (0, import_vitest.it)("should return empty array when document not in any subscription", async function () {
-      await subscriptionManager.subscribe({
-        doctype: "TestDoc",
-        fields: ["*"]
-      });
-      var affectedSubs = subscriptionManager.removeFromAllSubscriptions("TestDoc", "non-existent");
-      (0, import_vitest.expect)(affectedSubs).toEqual([]);
-    });
-    (0, import_vitest.it)("should skip subscriptions with different doctypes", async function () {
-      await subscriptionManager.subscribe({
-        doctype: "OtherDoc",
-        fields: ["*"]
-      });
-      var affectedSubs = subscriptionManager.removeFromAllSubscriptions("TestDoc", "doc1");
-      (0, import_vitest.expect)(affectedSubs).toEqual([]);
-    });
-  });
-  (0, import_vitest.describe)("utility methods", function () {
-    (0, import_vitest.beforeEach)(function () {
-      subscriptionManager = new import_subscriptionManager.SubscriptionManager(mockDb, mockNormalizedCache);
-    });
-    (0, import_vitest.it)("should get all subscriptions", async function () {
-      await subscriptionManager.subscribe({
-        doctype: "TestDoc",
-        fields: ["*"]
-      });
-      await subscriptionManager.subscribe({
-        doctype: "OtherDoc",
-        fields: ["*"]
-      });
-      var allSubs = subscriptionManager.getAllSubscriptions();
-      (0, import_vitest.expect)(allSubs.size).toBe(2);
-    });
-    (0, import_vitest.it)("should clear all subscriptions", async function () {
-      await subscriptionManager.subscribe({
-        doctype: "TestDoc",
-        fields: ["*"]
-      });
-      await subscriptionManager.subscribe({
-        doctype: "OtherDoc",
-        fields: ["*"]
-      });
-      subscriptionManager.clear();
-      (0, import_vitest.expect)(subscriptionManager.getAllSubscriptions().size).toBe(0);
-    });
-  });
-  (0, import_vitest.describe)("crypto ID generation", function () {
-    (0, import_vitest.it)("should use crypto.randomUUID when available", async function () {
-      subscriptionManager = new import_subscriptionManager.SubscriptionManager(mockDb, mockNormalizedCache);
-      var result = await subscriptionManager.subscribe({
-        doctype: "TestDoc",
-        fields: ["*"]
-      });
-      (0, import_vitest.expect)(result.subscriptionId).toBe("uuid-1");
-      (0, import_vitest.expect)(crypto.randomUUID).toHaveBeenCalled();
-    });
-    (0, import_vitest.it)("should fallback to Math.random when crypto not available", async function () {
-      global.crypto = void 0;
-      import_vitest.vi.spyOn(Math, "random").mockReturnValue(0.123456789);
-      subscriptionManager = new import_subscriptionManager.SubscriptionManager(mockDb, mockNormalizedCache);
-      var result = await subscriptionManager.subscribe({
-        doctype: "TestDoc",
-        fields: ["*"]
-      });
-      (0, import_vitest.expect)(result.subscriptionId).toBe("4fzzzxjylrx");
-      (0, import_vitest.expect)(Math.random).toHaveBeenCalled();
-    });
-  });
-  (0, import_vitest.describe)("edge cases and error handling", function () {
-    (0, import_vitest.beforeEach)(function () {
-      subscriptionManager = new import_subscriptionManager.SubscriptionManager(mockDb, mockNormalizedCache);
-    });
-    (0, import_vitest.it)("should handle backfill response without checkpoint", async function () {
-      var result = await subscriptionManager.subscribe({
-        doctype: "TestDoc",
-        fields: ["*"]
-      });
-      var subscription = subscriptionManager.getSubscription(result.subscriptionId);
-      var originalCheckpoint = subscription.checkpoint;
-      mockDb.backfill.mockResolvedValue({
-        rows: []
-      });
-      await subscriptionManager.backfillSub(subscription);
-      (0, import_vitest.expect)(subscription.checkpoint).toBe(originalCheckpoint);
-    });
-    (0, import_vitest.it)("should handle documents without modified field", async function () {
-      var docsWithoutModified = [{
-        name: "doc1",
-        doctype: "TestDoc",
-        title: "Doc 1"
-      }, {
-        name: "doc2",
-        doctype: "TestDoc",
-        title: "Doc 2"
-      }];
-      mockDb.getDocList.mockResolvedValue(docsWithoutModified);
-      var result = await subscriptionManager.subscribe({
-        doctype: "TestDoc",
-        fields: ["*"]
-      });
-      (0, import_vitest.expect)(result.checkpoint).toBeUndefined();
-    });
-    (0, import_vitest.it)("should handle missing documents during membership update", function () {
-      mockNormalizedCache.get.mockReturnValue(void 0);
-      var result = subscriptionManager.updateSubscriptionMembership({
-        name: "missing-doc",
-        doctype: "TestDoc"
-      });
-      (0, import_vitest.expect)(result).toEqual([]);
-    });
-    (0, import_vitest.it)("should handle tombstones with invalid data", async function () {
-      var _subscription_tombstones, _subscription_tombstones1;
-      var result = await subscriptionManager.subscribe({
-        doctype: "TestDoc",
-        fields: ["*"]
-      });
-      var subscription = subscriptionManager.getSubscription(result.subscriptionId);
-      var backfillResponse = {
-        rows: [],
-        deleted: [null,
-        // Invalid tombstone
-        {
-          doctype: "TestDoc"
-        },
-        // Missing name
-        {
-          name: "doc2"
-        },
-        // Missing doctype
-        {
-          doctype: "TestDoc",
-          name: "doc2"
-        }],
-        // Valid
-        checkpoint: "2024-01-02T10:00:00"
-      };
-      mockDb.backfill.mockResolvedValue(backfillResponse);
-      await subscriptionManager.backfillSub(subscription);
-      (0, import_vitest.expect)((_subscription_tombstones = subscription.tombstones) === null || _subscription_tombstones === void 0 ? void 0 : _subscription_tombstones.has("doc2")).toBe(true);
-      (0, import_vitest.expect)((_subscription_tombstones1 = subscription.tombstones) === null || _subscription_tombstones1 === void 0 ? void 0 : _subscription_tombstones1.size).toBe(1);
-    });
-    (0, import_vitest.it)("should handle backfill rows without names", async function () {
-      var result = await subscriptionManager.subscribe({
-        doctype: "TestDoc",
-        fields: ["*"]
-      });
-      var subscription = subscriptionManager.getSubscription(result.subscriptionId);
-      var backfillResponse = {
-        rows: [{
-          doctype: "TestDoc",
-          title: "No name"
-        },
-        // Missing name
-        {
-          name: "doc4",
-          doctype: "TestDoc"
-        }],
-        // Valid
-        checkpoint: "2024-01-02T10:00:00"
-      };
-      mockDb.backfill.mockResolvedValue(backfillResponse);
-      await subscriptionManager.backfillSub(subscription);
-      (0, import_vitest.expect)(subscription.docIds).toContain("doc4");
-    });
-  });
-  (0, import_vitest.describe)("subscription deduplication", function () {
-    (0, import_vitest.beforeEach)(function () {
-      subscriptionManager = new import_subscriptionManager.SubscriptionManager(mockDb, mockNormalizedCache);
-    });
-    (0, import_vitest.it)("should return the same subscriptionId for identical queries", async function () {
-      var query = {
-        doctype: "TestDoc",
-        fields: ["title"],
-        filters: {
-          status: "Active"
-        }
-      };
-      var first = await subscriptionManager.subscribe(query);
-      var second = await subscriptionManager.subscribe(query);
-      (0, import_vitest.expect)(second.subscriptionId).toBe(first.subscriptionId);
-      (0, import_vitest.expect)(mockDb.getDocList).toHaveBeenCalledTimes(1);
-    });
-    (0, import_vitest.it)("should create separate subscriptions for different queries", async function () {
-      var query1 = {
-        doctype: "TestDoc",
-        filters: {
-          status: "Active"
-        }
-      };
-      var query2 = {
-        doctype: "TestDoc",
-        filters: {
-          status: "Draft"
-        }
-      };
-      var first = await subscriptionManager.subscribe(query1);
-      var second = await subscriptionManager.subscribe(query2);
-      (0, import_vitest.expect)(second.subscriptionId).not.toBe(first.subscriptionId);
-      (0, import_vitest.expect)(mockDb.getDocList).toHaveBeenCalledTimes(2);
-    });
-    (0, import_vitest.it)("should return cached docs on dedup hit", async function () {
-      var query = {
-        doctype: "TestDoc"
-      };
-      var first = await subscriptionManager.subscribe(query);
-      var second = await subscriptionManager.subscribe(query);
-      (0, import_vitest.expect)(second.rows).toBeDefined();
-      (0, import_vitest.expect)(second.checkpoint).toBe(first.checkpoint);
-    });
-    (0, import_vitest.it)("should keep subscription alive when one consumer unsubscribes but another remains", async function () {
-      var query = {
-        doctype: "TestDoc"
-      };
-      var first = await subscriptionManager.subscribe(query);
-      await subscriptionManager.subscribe(query);
-      subscriptionManager.unsubscribe(first.subscriptionId);
-      var sub = subscriptionManager.getSubscription(first.subscriptionId);
-      (0, import_vitest.expect)(sub).toBeDefined();
-    });
-    (0, import_vitest.it)("should remove subscription when last consumer unsubscribes", async function () {
-      var query = {
-        doctype: "TestDoc"
-      };
-      var result = await subscriptionManager.subscribe(query);
-      await subscriptionManager.subscribe(query);
-      subscriptionManager.unsubscribe(result.subscriptionId);
-      subscriptionManager.unsubscribe(result.subscriptionId);
-      var sub = subscriptionManager.getSubscription(result.subscriptionId);
-      (0, import_vitest.expect)(sub).toBeUndefined();
-    });
-    (0, import_vitest.it)("should allow re-subscribing after all consumers unsubscribe", async function () {
-      var query = {
-        doctype: "TestDoc"
-      };
-      var first = await subscriptionManager.subscribe(query);
-      subscriptionManager.unsubscribe(first.subscriptionId);
-      var second = await subscriptionManager.subscribe(query);
-      (0, import_vitest.expect)(second.subscriptionId).not.toBe(first.subscriptionId);
-      (0, import_vitest.expect)(mockDb.getDocList).toHaveBeenCalledTimes(2);
-    });
-    (0, import_vitest.it)("should clear dedup maps on clear()", async function () {
-      var query = {
-        doctype: "TestDoc"
-      };
-      await subscriptionManager.subscribe(query);
-      subscriptionManager.clear();
-      var result = await subscriptionManager.subscribe(query);
-      (0, import_vitest.expect)(mockDb.getDocList).toHaveBeenCalledTimes(2);
-      (0, import_vitest.expect)(result.subscriptionId).toBeDefined();
-    });
-  });
-  (0, import_vitest.describe)("progressive VPM registration", function () {
-    (0, import_vitest.beforeEach)(function () {
-      subscriptionManager = new import_subscriptionManager.SubscriptionManager(mockDb, mockNormalizedCache);
-    });
-    (0, import_vitest.it)("should register with VPM when progressive is true", async function () {
-      var query = {
-        doctype: "TestDoc",
-        progressive: true,
-        limit: 20
-      };
-      var result = await subscriptionManager.subscribe(query);
-      var vpm = subscriptionManager.getVirtualPageManager();
-      var virtualSub = vpm.getSubscription(result.subscriptionId);
-      (0, import_vitest.expect)(virtualSub).toBeDefined();
-      (0, import_vitest.expect)(virtualSub.getProgressiveCache().docIds).toHaveLength(mockDocs.length);
-    });
-    (0, import_vitest.it)("should not register with VPM when progressive is false/undefined", async function () {
-      var query = {
-        doctype: "TestDoc"
-      };
-      var result = await subscriptionManager.subscribe(query);
-      var vpm = subscriptionManager.getVirtualPageManager();
-      var virtualSub = vpm.getSubscription(result.subscriptionId);
-      (0, import_vitest.expect)(virtualSub).toBeUndefined();
-    });
-    (0, import_vitest.it)("should prefer VPM docs when subscription is progressive", async function () {
-      var query = {
-        doctype: "TestDoc",
-        progressive: true,
-        limit: 20
-      };
-      var result = await subscriptionManager.subscribe(query);
-      var docs = subscriptionManager.getDocsForSubscription(result.subscriptionId);
-      (0, import_vitest.expect)(docs.length).toBeGreaterThan(0);
-    });
-  });
-  (0, import_vitest.describe)("tombstone cleanup", function () {
-    (0, import_vitest.beforeEach)(function () {
-      subscriptionManager = new import_subscriptionManager.SubscriptionManager(mockDb, mockNormalizedCache, {
-        tombstoneMaxAge: 1e3,
-        tombstoneMaxCount: 3
-      });
-    });
-    (0, import_vitest.it)("should remove tombstones older than maxAge", async function () {
-      var query = {
-        doctype: "TestDoc"
-      };
-      var result = await subscriptionManager.subscribe(query);
-      var sub = subscriptionManager.getSubscription(result.subscriptionId);
-      sub.tombstones.set("old-doc", Date.now() - 2e3);
-      sub.tombstones.set("recent-doc", Date.now());
-      subscriptionManager.cleanupTombstones(result.subscriptionId);
-      (0, import_vitest.expect)(sub.tombstones.has("old-doc")).toBe(false);
-      (0, import_vitest.expect)(sub.tombstones.has("recent-doc")).toBe(true);
-    });
-    (0, import_vitest.it)("should trim tombstones exceeding maxCount (oldest first)", async function () {
-      var now = Date.now();
-      var query = {
-        doctype: "TestDoc"
-      };
-      var result = await subscriptionManager.subscribe(query);
-      var sub = subscriptionManager.getSubscription(result.subscriptionId);
-      sub.tombstones.set("doc-1", now - 100);
-      sub.tombstones.set("doc-2", now - 50);
-      sub.tombstones.set("doc-3", now - 25);
-      sub.tombstones.set("doc-4", now);
-      subscriptionManager.cleanupTombstones(result.subscriptionId);
-      (0, import_vitest.expect)(sub.tombstones.size).toBe(3);
-      (0, import_vitest.expect)(sub.tombstones.has("doc-1")).toBe(false);
-      (0, import_vitest.expect)(sub.tombstones.has("doc-4")).toBe(true);
-    });
-    (0, import_vitest.it)("should handle subscriptions without tombstones", async function () {
-      var query = {
-        doctype: "TestDoc"
-      };
-      var result = await subscriptionManager.subscribe(query);
-      var sub = subscriptionManager.getSubscription(result.subscriptionId);
-      sub.tombstones = void 0;
-      (0, import_vitest.expect)(function () {
-        return subscriptionManager.cleanupTombstones(result.subscriptionId);
-      }).not.toThrow();
-    });
-  });
-});
-//# sourceMappingURL=subscriptionManager.spec.native.js.map