@party-stack/foundry-ontology 0.17.0 → 0.18.1

package/lib/adapter/objectCollectionOptions.test.js

@@ -1,1289 +0,0 @@
-import { o } from "@party-stack/ontology";
-import { eq, gt, IR } from "@tanstack/db";
-import { beforeEach, describe, expect, it, vi } from "vitest";
-const mockState = vi.hoisted(() => ({
-    getEditsHistory: vi.fn(),
-    getObject: vi.fn(),
-    search: vi.fn(),
-    getObjectSetWatcherManager: vi.fn(),
-    unsubscribe: vi.fn(),
-    subscribeCallback: undefined,
-}));
-vi.mock("@osdk/foundry.ontologies", () => ({
-    OntologyObjectsV2: {
-        get: mockState.getObject,
-        search: mockState.search,
-    },
-    ObjectTypesV2: {
-        getEditsHistory: mockState.getEditsHistory,
-    },
-}));
-vi.mock("@party-stack/foundry-object-set-watcher", () => ({
-    getObjectSetWatcherManager: mockState.getObjectSetWatcherManager,
-}));
-import { createFoundryCodec } from "./foundryCodec.js";
-import { objectCollectionOptions } from "./objectCollectionOptions.js";
-function createSyncHarness(initialObjects = [], opts = {}) {
-    const syncedData = new Map(initialObjects.map((object) => [object.employeeId, object]));
-    const writes = [];
-    const collectionMetadata = opts.collectionMetadata ?? new Map();
-    const transactions = [];
-    let pendingTransaction;
-    const begin = vi.fn(() => {
-        if (pendingTransaction)
-            throw new Error("A sync transaction is already active.");
-        pendingTransaction = {
-            writes: [],
-            collectionMetadata: new Map(),
-        };
-    });
-    const commit = vi.fn(() => {
-        if (!pendingTransaction)
-            throw new Error("No sync transaction is active.");
-        for (const [key, value] of pendingTransaction.collectionMetadata) {
-            collectionMetadata.set(key, value);
-        }
-        transactions.push(pendingTransaction);
-        pendingTransaction = undefined;
-        return opts.commitReceipt?.() ?? true;
-    });
-    const truncate = vi.fn(() => {
-        if (!pendingTransaction) {
-            throw new Error("No sync transaction is active.");
-        }
-        syncedData.clear();
-    });
-    const { sync: syncConfig, utils } = objectCollectionOptions({
-        client: {
-            baseUrl: "https://example.com",
-            fetch: opts.fetch ?? vi.fn(),
-            ontologyRid: "ri.ontology.main",
-            tokenProvider: () => Promise.resolve("token"),
-        },
-        objectType: "Employee",
-        primaryKeyProperty: "employeeId",
-        selectedProperties: [
-            "employeeId",
-            "name",
-            "status",
-            "priority",
-        ],
-        live: opts.live,
-        decodeObject: opts.decodeObject,
-        decodeEditObject: opts.decodeEditObject,
-    });
-    const handle = syncConfig.sync({
-        begin,
-        collection: {
-            get: (key) => syncedData.get(key),
-            has: (key) => syncedData.has(key),
-            *keys() {
-                yield* syncedData.keys();
-            },
-            syncedData,
-        },
-        commit,
-        markError: vi.fn(),
-        markReady: vi.fn(),
-        metadata: {
-            collection: {
-                get: (key) => pendingTransaction?.collectionMetadata.get(key) ?? collectionMetadata.get(key),
-                set: (key, value) => {
-                    if (!pendingTransaction)
-                        throw new Error("No sync transaction is active.");
-                    pendingTransaction.collectionMetadata.set(key, value);
-                },
-                delete: vi.fn(),
-                list: () => [...collectionMetadata].map(([key, value]) => ({ key, value })),
-            },
-            row: {
-                get: vi.fn(),
-                set: vi.fn(),
-                delete: vi.fn(),
-            },
-        },
-        truncate,
-        write: (mutation) => {
-            if (!pendingTransaction)
-                throw new Error("No sync transaction is active.");
-            const key = mutation.type === "delete"
-                ? mutation.key
-                : mutation.value
-                    .employeeId;
-            const observedWrite = { type: mutation.type, primaryKey: key };
-            writes.push(observedWrite);
-            pendingTransaction.writes.push(observedWrite);
-            if (mutation.type === "delete") {
-                syncedData.delete(key);
-            }
-            else {
-                const value = mutation.value;
-                syncedData.set(key, value);
-            }
-        },
-    });
-    return {
-        begin,
-        cleanup: handle.cleanup,
-        collectionMetadata,
-        commit,
-        loadSubset: handle.loadSubset,
-        syncedData,
-        transactions,
-        truncate,
-        utils,
-        writes,
-    };
-}
-describe("objectCollectionOptions", () => {
-    beforeEach(() => {
-        mockState.getEditsHistory.mockReset();
-        mockState.getObject.mockReset();
-        mockState.search.mockReset();
-        mockState.getObjectSetWatcherManager.mockReset();
-        mockState.unsubscribe.mockReset();
-        mockState.subscribeCallback = undefined;
-        mockState.getObjectSetWatcherManager.mockReturnValue({
-            subscribe: (_objectSet, callback) => {
-                mockState.subscribeCallback = callback;
-                return () => {
-                    mockState.subscribeCallback = undefined;
-                    mockState.unsubscribe();
-                };
-            },
-        });
-    });
-    it("constructs and cleans up the object-set watcher by default", () => {
-        const harness = createSyncHarness();
-        expect(mockState.getObjectSetWatcherManager).toHaveBeenCalledTimes(1);
-        harness.cleanup();
-        expect(mockState.unsubscribe).toHaveBeenCalledTimes(1);
-    });
-    it("loads subsets without constructing an object-set watcher when live is false", async () => {
-        mockState.search.mockResolvedValue({
-            data: [{ employeeId: 1, name: "Ada" }],
-            nextPageToken: undefined,
-        });
-        const harness = createSyncHarness([], { live: false });
-        expect(mockState.getObjectSetWatcherManager).not.toHaveBeenCalled();
-        await harness.loadSubset({});
-        expect(harness.syncedData.get(1)).toEqual({
-            employeeId: 1,
-            name: "Ada",
-        });
-        harness.cleanup();
-        expect(mockState.unsubscribe).not.toHaveBeenCalled();
-    });
-    it("supports bounded edit-history observation without a watcher when live is false", async () => {
-        mockState.getEditsHistory.mockResolvedValue({
-            data: [
-                {
-                    objectPrimaryKey: { employeeId: 2 },
-                    operationId: "op-non-live",
-                    actionTypeRid: "action-1",
-                    userId: "user-1",
-                    timestamp: "2099-03-12T12:00:00.000Z",
-                    edit: {
-                        type: "createEdit",
-                        properties: {
-                            employeeId: 2,
-                            name: "Grace",
-                        },
-                    },
-                },
-            ],
-            nextPageToken: undefined,
-        });
-        const harness = createSyncHarness([], { live: false });
-        await expect(harness.utils.awaitOperationId("op-non-live")).resolves.toBeUndefined();
-        expect(mockState.getObjectSetWatcherManager).not.toHaveBeenCalled();
-        expect(harness.syncedData.get(2)).toEqual({
-            employeeId: 2,
-            name: "Grace",
-        });
-        harness.cleanup();
-    });
-    it("keeps identical abortable subset loads independent", async () => {
-        const requests = [];
-        const fetchImpl = vi.fn((_input, init) => {
-            return new Promise((resolve, reject) => {
-                const request = { resolve, reject };
-                requests.push(request);
-                const signal = init?.signal;
-                signal?.addEventListener("abort", () => reject(signal.reason instanceof Error
-                    ? signal.reason
-                    : new DOMException("Request aborted.", "AbortError")), { once: true });
-            });
-        });
-        mockState.search.mockImplementation((client) => client.fetch("https://example.com/search"));
-        const harness = createSyncHarness([], { fetch: fetchImpl });
-        const controllerA = new AbortController();
-        const controllerB = new AbortController();
-        const requestA = harness.loadSubset({
-            limit: 1,
-            signal: controllerA.signal,
-        });
-        const requestB = harness.loadSubset({
-            limit: 1,
-            signal: controllerB.signal,
-        });
-        expect(requestA).not.toBe(requestB);
-        expect(mockState.search).toHaveBeenCalledTimes(2);
-        controllerA.abort(new DOMException("Request A canceled.", "AbortError"));
-        requests[1].resolve({
-            data: [{ employeeId: "employee-b", name: "Request B" }],
-            nextPageToken: undefined,
-        });
-        await expect(requestA).rejects.toMatchObject({ name: "AbortError" });
-        await expect(requestB).resolves.toBeUndefined();
-        expect(harness.syncedData.get("employee-b")).toMatchObject({
-            name: "Request B",
-        });
-        harness.cleanup();
-    });
-    it("reconciles modify edits from history on watcher open", async () => {
-        mockState.getEditsHistory.mockResolvedValue({
-            data: [
-                {
-                    objectPrimaryKey: { employeeId: 1 },
-                    operationId: "op-1",
-                    actionTypeRid: "action-1",
-                    userId: "user-1",
-                    timestamp: "2099-03-12T12:00:00.000Z",
-                    edit: {
-                        type: "modifyEdit",
-                        previousProperties: {},
-                        properties: {
-                            employeeId: 1,
-                            name: "Updated Employee",
-                        },
-                    },
-                },
-            ],
-            nextPageToken: undefined,
-        });
-        const harness = createSyncHarness([
-            {
-                employeeId: 1,
-                name: "Before",
-                department: "Engineering",
-            },
-        ]);
-        mockState.subscribeCallback?.({ type: "state", status: "open" });
-        await vi.waitFor(() => {
-            expect(mockState.getEditsHistory).toHaveBeenCalledTimes(1);
-            expect(harness.syncedData.get(1)).toEqual({
-                employeeId: 1,
-                name: "Updated Employee",
-                department: "Engineering",
-            });
-        });
-        expect(mockState.getObject).not.toHaveBeenCalled();
-        expect(harness.begin.mock.calls).toEqual([
-            [],
-            [],
-        ]);
-        harness.cleanup();
-    });
-    it("applies delete edits from history", async () => {
-        mockState.getEditsHistory.mockResolvedValue({
-            data: [
-                {
-                    objectPrimaryKey: { employeeId: 2 },
-                    operationId: "op-2",
-                    actionTypeRid: "action-1",
-                    userId: "user-1",
-                    timestamp: "2099-03-12T12:01:00.000Z",
-                    edit: {
-                        type: "deleteEdit",
-                        previousProperties: {},
-                    },
-                },
-            ],
-            nextPageToken: undefined,
-        });
-        const harness = createSyncHarness([{ employeeId: 2, name: "Should Stay" }]);
-        mockState.subscribeCallback?.({ type: "state", status: "open" });
-        await vi.waitFor(() => {
-            expect(mockState.getEditsHistory).toHaveBeenCalledTimes(1);
-            expect(harness.syncedData.has(2)).toBe(false);
-        });
-        expect(mockState.getObject).not.toHaveBeenCalled();
-        harness.cleanup();
-    });
-    it("deletes objects hydrated after source sync starts", async () => {
-        mockState.getEditsHistory.mockResolvedValue({
-            data: [
-                {
-                    objectPrimaryKey: {
-                        employeeId: 2,
-                    },
-                    operationId: "op-hydrated-delete",
-                    actionTypeRid: "action-1",
-                    userId: "user-1",
-                    timestamp: "2099-03-12T12:01:00.000Z",
-                    edit: {
-                        type: "deleteEdit",
-                        previousProperties: {},
-                    },
-                },
-            ],
-            nextPageToken: undefined,
-        });
-        const harness = createSyncHarness();
-        // Persisted on-demand hydration happens after the source sync closure
-        // captures its initial state.
-        harness.syncedData.set(2, {
-            employeeId: 2,
-            name: "Persisted stale object",
-        });
-        mockState.subscribeCallback?.({
-            type: "state",
-            status: "open",
-        });
-        await vi.waitFor(() => {
-            expect(harness.syncedData.has(2)).toBe(false);
-        });
-        expect(harness.writes).toContainEqual({
-            type: "delete",
-            primaryKey: 2,
-        });
-        harness.cleanup();
-    });
-    it("treats watcher REMOVED events as a history catch-up signal", async () => {
-        mockState.getEditsHistory.mockResolvedValue({
-            data: [
-                {
-                    objectPrimaryKey: { employeeId: 5 },
-                    operationId: "op-5",
-                    actionTypeRid: "action-1",
-                    userId: "user-1",
-                    timestamp: "2099-03-12T12:00:00.000Z",
-                    edit: {
-                        type: "createEdit",
-                        properties: {
-                            employeeId: 5,
-                            name: "Employee Five",
-                        },
-                    },
-                },
-            ],
-            nextPageToken: undefined,
-        });
-        mockState.getEditsHistory.mockResolvedValueOnce({
-            data: [
-                {
-                    objectPrimaryKey: { employeeId: 5 },
-                    operationId: "op-5",
-                    actionTypeRid: "action-1",
-                    userId: "user-1",
-                    timestamp: "2099-03-12T12:00:00.000Z",
-                    edit: {
-                        type: "createEdit",
-                        properties: {
-                            employeeId: 5,
-                            name: "Employee Five",
-                        },
-                    },
-                },
-            ],
-            nextPageToken: undefined,
-        });
-        mockState.getEditsHistory.mockResolvedValueOnce({
-            data: [
-                {
-                    objectPrimaryKey: { employeeId: 5 },
-                    operationId: "op-6",
-                    actionTypeRid: "action-1",
-                    userId: "user-1",
-                    timestamp: "2099-03-12T12:01:00.000Z",
-                    edit: {
-                        type: "deleteEdit",
-                        previousProperties: {},
-                    },
-                },
-            ],
-            nextPageToken: undefined,
-        });
-        const harness = createSyncHarness();
-        mockState.subscribeCallback?.({ type: "state", status: "open" });
-        await vi.waitFor(() => {
-            expect(harness.syncedData.has(5)).toBe(true);
-        });
-        mockState.subscribeCallback?.({
-            type: "change",
-            updates: [
-                {
-                    type: "object",
-                    state: "REMOVED",
-                    object: { employeeId: 5 },
-                },
-            ],
-        });
-        await vi.waitFor(() => {
-            expect(mockState.getEditsHistory).toHaveBeenCalledTimes(2);
-            expect(harness.syncedData.has(5)).toBe(false);
-            expect(harness.writes).toContainEqual({ type: "delete", primaryKey: 5 });
-        });
-        harness.cleanup();
-    });
-    it("dedupes inclusive timestamp results across catch-up runs", async () => {
-        mockState.getEditsHistory
-            .mockResolvedValueOnce({
-            data: [
-                {
-                    objectPrimaryKey: { employeeId: 1 },
-                    operationId: "op-1",
-                    actionTypeRid: "action-1",
-                    userId: "user-1",
-                    timestamp: "2099-03-12T12:00:00.000Z",
-                    edit: {
-                        type: "modifyEdit",
-                        previousProperties: {},
-                        properties: {
-                            employeeId: 1,
-                            name: "Employee One",
-                        },
-                    },
-                },
-            ],
-            nextPageToken: undefined,
-        })
-            .mockResolvedValueOnce({
-            data: [
-                {
-                    objectPrimaryKey: { employeeId: 1 },
-                    operationId: "op-1",
-                    actionTypeRid: "action-1",
-                    userId: "user-1",
-                    timestamp: "2099-03-12T12:00:00.000Z",
-                    edit: {
-                        type: "modifyEdit",
-                        previousProperties: {},
-                        properties: {
-                            employeeId: 1,
-                            name: "Employee One",
-                        },
-                    },
-                },
-                {
-                    objectPrimaryKey: { employeeId: 2 },
-                    operationId: "op-2",
-                    actionTypeRid: "action-1",
-                    userId: "user-1",
-                    timestamp: "2099-03-12T12:00:00.000Z",
-                    edit: {
-                        type: "modifyEdit",
-                        previousProperties: {},
-                        properties: {
-                            employeeId: 2,
-                            name: "Employee Two",
-                        },
-                    },
-                },
-            ],
-            nextPageToken: undefined,
-        });
-        const harness = createSyncHarness();
-        mockState.subscribeCallback?.({ type: "state", status: "open" });
-        mockState.subscribeCallback?.({
-            type: "change",
-            updates: [
-                {
-                    type: "object",
-                    state: "ADDED_OR_UPDATED",
-                    object: { employeeId: 2, name: "Employee Two" },
-                },
-            ],
-        });
-        await vi.waitFor(() => {
-            expect(mockState.getEditsHistory).toHaveBeenCalledTimes(2);
-            expect(harness.syncedData.get(1)).toEqual({
-                employeeId: 1,
-                name: "Employee One",
-            });
-            expect(harness.syncedData.get(2)).toEqual({
-                employeeId: 2,
-                name: "Employee Two",
-            });
-        });
-        expect(mockState.getObject).not.toHaveBeenCalled();
-        harness.cleanup();
-    });
-    it("restores a durable same-timestamp cursor and catches downtime edits once", async () => {
-        const timestamp = "2099-03-12T12:00:00.000Z";
-        const firstEntry = {
-            objectPrimaryKey: { employeeId: 1 },
-            operationId: "op-1",
-            actionTypeRid: "action-1",
-            userId: "user-1",
-            timestamp,
-            edit: {
-                type: "modifyEdit",
-                previousProperties: {},
-                properties: {
-                    employeeId: 1,
-                    name: "Employee One",
-                },
-            },
-        };
-        const downtimeEntry = {
-            objectPrimaryKey: { employeeId: 2 },
-            operationId: "op-2",
-            actionTypeRid: "action-1",
-            userId: "user-1",
-            timestamp,
-            edit: {
-                type: "modifyEdit",
-                previousProperties: {},
-                properties: {
-                    employeeId: 2,
-                    name: "Employee Two",
-                },
-            },
-        };
-        const collectionMetadata = new Map();
-        mockState.getEditsHistory.mockResolvedValue({
-            data: [firstEntry],
-            nextPageToken: undefined,
-        });
-        const first = createSyncHarness([], { collectionMetadata });
-        mockState.subscribeCallback?.({ type: "state", status: "open" });
-        await vi.waitFor(() => {
-            expect(first.syncedData.get(1)).toMatchObject({ name: "Employee One" });
-        });
-        const persistedCursor = [...collectionMetadata.values()][0];
-        expect(persistedCursor).toMatchObject({
-            version: 1,
-            timestamp,
-        });
-        expect(persistedCursor.seenEntryKeysAtTimestamp).toHaveLength(1);
-        expect(first.transactions.at(-1)).toMatchObject({
-            writes: [{ type: "insert", primaryKey: 1 }],
-        });
-        expect(first.transactions.at(-1)?.collectionMetadata.size).toBe(1);
-        const reloadedObjects = [...first.syncedData.values()];
-        first.cleanup();
-        mockState.getEditsHistory.mockReset();
-        mockState.getEditsHistory.mockResolvedValue({
-            data: [firstEntry, downtimeEntry],
-            nextPageToken: undefined,
-        });
-        const second = createSyncHarness(reloadedObjects, { collectionMetadata });
-        mockState.subscribeCallback?.({ type: "state", status: "open" });
-        await vi.waitFor(() => {
-            expect(second.syncedData.get(2)).toMatchObject({ name: "Employee Two" });
-        });
-        expect(second.writes).toEqual([{ type: "insert", primaryKey: 2 }]);
-        expect(mockState.getEditsHistory.mock.calls[0]?.[3]).toMatchObject({
-            filters: {
-                type: "timestampFilter",
-                startTime: timestamp,
-            },
-        });
-        expect([...collectionMetadata.values()][0].seenEntryKeysAtTimestamp).toHaveLength(2);
-        second.cleanup();
-    });
-    it("persists delete and cursor progress for unloaded rows", async () => {
-        const timestamp = "2099-03-12T12:02:00.000Z";
-        mockState.getEditsHistory.mockResolvedValue({
-            data: [
-                {
-                    objectPrimaryKey: { employeeId: 404 },
-                    operationId: "op-delete-missing",
-                    actionTypeRid: "action-1",
-                    userId: "user-1",
-                    timestamp,
-                    edit: {
-                        type: "deleteEdit",
-                        previousProperties: {},
-                    },
-                },
-            ],
-            nextPageToken: undefined,
-        });
-        const harness = createSyncHarness();
-        mockState.subscribeCallback?.({ type: "state", status: "open" });
-        await vi.waitFor(() => {
-            expect(harness.transactions).toHaveLength(2);
-        });
-        expect(harness.writes).toEqual([
-            {
-                type: "delete",
-                primaryKey: 404,
-            },
-        ]);
-        expect(harness.transactions.at(-1)?.writes).toEqual([
-            {
-                type: "delete",
-                primaryKey: 404,
-            },
-        ]);
-        expect(harness.transactions.at(-1)?.collectionMetadata.size).toBe(1);
-        expect([...harness.collectionMetadata.values()][0]).toMatchObject({
-            version: 1,
-            timestamp,
-        });
-        harness.cleanup();
-    });
-    it("decodes create edits with null property sentinels from edit history", async () => {
-        mockState.getEditsHistory.mockResolvedValue({
-            data: [
-                {
-                    objectPrimaryKey: { employeeId: 3 },
-                    operationId: "op-1",
-                    actionTypeRid: "action-1",
-                    userId: "user-1",
-                    timestamp: "2099-03-12T12:00:00.000Z",
-                    edit: {
-                        type: "createEdit",
-                        properties: {
-                            employeeId: 3,
-                            nickname: "NullPropertyValue{}",
-                            name: "Employee Three",
-                            createdAt: "2099-03-12T12:00:00.000Z",
-                        },
-                    },
-                },
-            ],
-            nextPageToken: undefined,
-        });
-        const codec = createFoundryCodec({
-            types: [],
-            objectTypes: [
-                {
-                    name: "Employee",
-                    displayName: "Employee",
-                    pluralDisplayName: "Employees",
-                    primaryKey: "employeeId",
-                    properties: [
-                        { name: "employeeId", displayName: "Employee ID", type: o.integer({}) },
-                        { name: "name", displayName: "Name", type: o.string({}) },
-                        {
-                            name: "nickname",
-                            displayName: "Nickname",
-                            type: o.optional({ type: o.string({}) }),
-                        },
-                    ],
-                },
-            ],
-            linkTypes: [],
-            actionTypes: [],
-            queryFunctionTypes: [],
-        });
-        const harness = createSyncHarness([], {
-            decodeEditObject: (object) => codec.decodeEditObject("Employee", object),
-        });
-        mockState.subscribeCallback?.({ type: "state", status: "open" });
-        await vi.waitFor(() => {
-            expect(harness.syncedData.get(3)).toEqual({
-                employeeId: 3,
-                name: "Employee Three",
-                nickname: undefined,
-                createdAt: "2099-03-12T12:00:00.000Z",
-            });
-        });
-        expect(mockState.getObject).not.toHaveBeenCalled();
-        harness.cleanup();
-    });
-    it("decodes attachment property wrappers from edit history", async () => {
-        mockState.getEditsHistory.mockResolvedValue({
-            data: [
-                {
-                    objectPrimaryKey: { employeeId: 7 },
-                    operationId: "op-7",
-                    actionTypeRid: "action-1",
-                    userId: "user-1",
-                    timestamp: "2099-03-12T12:00:00.000Z",
-                    edit: {
-                        type: "createEdit",
-                        properties: {
-                            employeeId: 7,
-                            attachments: [
-                                {
-                                    type: "attachment",
-                                    attachment: "ri.attachments.main.attachment.7",
-                                },
-                            ],
-                            name: "Employee Seven",
-                        },
-                    },
-                },
-            ],
-            nextPageToken: undefined,
-        });
-        const codec = createFoundryCodec({
-            types: [],
-            objectTypes: [
-                {
-                    name: "Employee",
-                    displayName: "Employee",
-                    pluralDisplayName: "Employees",
-                    primaryKey: "employeeId",
-                    properties: [
-                        { name: "employeeId", displayName: "Employee ID", type: o.integer({}) },
-                        { name: "name", displayName: "Name", type: o.string({}) },
-                        {
-                            name: "attachments",
-                            displayName: "Attachments",
-                            type: o.list({
-                                elementType: o.attachment({
-                                    meta: {
-                                        foundry: {
-                                            kind: "attachment",
-                                        },
-                                    },
-                                }),
-                            }),
-                        },
-                    ],
-                },
-            ],
-            linkTypes: [],
-            actionTypes: [],
-            queryFunctionTypes: [],
-        });
-        const harness = createSyncHarness([], {
-            decodeObject: (object) => codec.decodeObject("Employee", object),
-            decodeEditObject: (object) => codec.decodeEditObject("Employee", object),
-        });
-        mockState.subscribeCallback?.({ type: "state", status: "open" });
-        await vi.waitFor(() => {
-            expect(harness.syncedData.get(7)).toEqual({
-                employeeId: 7,
-                name: "Employee Seven",
-                attachments: [{ id: "ri.attachments.main.attachment.7" }],
-            });
-        });
-        harness.cleanup();
-    });
-    it("decodes media-reference wrappers from edit history using the property schema", async () => {
-        const mediaReference = {
-            mimeType: "image/png",
-            reference: {
-                type: "mediaSetViewItem",
-                mediaSetViewItem: {
-                    mediaSetRid: "ri.mio.main.media-set.1",
-                    mediaSetViewRid: "ri.mio.main.view.1",
-                    mediaItemRid: "ri.mio.main.media-item.1",
-                },
-            },
-        };
-        mockState.getEditsHistory.mockResolvedValue({
-            data: [
-                {
-                    objectPrimaryKey: { employeeId: 8 },
-                    operationId: "op-8",
-                    actionTypeRid: "action-1",
-                    userId: "user-1",
-                    timestamp: "2099-03-12T12:00:00.000Z",
-                    edit: {
-                        type: "createEdit",
-                        properties: {
-                            employeeId: 8,
-                            logoMedia: {
-                                type: "mediaReference",
-                                mediaReference,
-                            },
-                        },
-                    },
-                },
-            ],
-            nextPageToken: undefined,
-        });
-        const codec = createFoundryCodec({
-            types: [],
-            objectTypes: [
-                {
-                    name: "Employee",
-                    displayName: "Employee",
-                    pluralDisplayName: "Employees",
-                    primaryKey: "employeeId",
-                    properties: [
-                        { name: "employeeId", displayName: "Employee ID", type: o.integer({}) },
-                        {
-                            name: "logoMedia",
-                            displayName: "Logo media",
-                            type: o.optional({
-                                type: o.attachment({
-                                    meta: {
-                                        foundry: {
-                                            kind: "media",
-                                        },
-                                    },
-                                }),
-                            }),
-                        },
-                    ],
-                },
-            ],
-            linkTypes: [],
-            actionTypes: [],
-            queryFunctionTypes: [],
-        });
-        const harness = createSyncHarness([], {
-            decodeEditObject: (object) => codec.decodeEditObject("Employee", object),
-        });
-        mockState.subscribeCallback?.({ type: "state", status: "open" });
-        await vi.waitFor(() => {
-            expect(harness.syncedData.get(8)).toEqual({
-                employeeId: 8,
-                logoMedia: {
-                    id: [
-                        "ri.mio.main.media-set.1",
-                        "ri.mio.main.view.1",
-                        "ri.mio.main.media-item.1",
-                    ].join(":"),
-                    type: "image/png",
-                },
-            });
-        });
-        harness.cleanup();
-    });
-    it("decodes GeoPointPropertyValue strings from edit history", async () => {
-        mockState.getEditsHistory.mockResolvedValue({
-            data: [
-                {
-                    objectPrimaryKey: { employeeId: 5 },
-                    operationId: "op-1",
-                    actionTypeRid: "action-1",
-                    userId: "user-1",
-                    timestamp: "2099-03-12T12:00:00.000Z",
-                    edit: {
-                        type: "createEdit",
-                        properties: {
-                            employeeId: 5,
-                            name: "Employee Five",
-                            location: "GeoPointPropertyValue{latitude: 40.375786, longitude: -74.11144}",
-                        },
-                    },
-                },
-            ],
-            nextPageToken: undefined,
-        });
-        const codec = createFoundryCodec({
-            types: [],
-            objectTypes: [
-                {
-                    name: "Employee",
-                    displayName: "Employee",
-                    pluralDisplayName: "Employees",
-                    primaryKey: "employeeId",
-                    properties: [
-                        { name: "employeeId", displayName: "Employee ID", type: o.integer({}) },
-                        { name: "name", displayName: "Name", type: o.string({}) },
-                        { name: "location", displayName: "Location", type: o.geopoint({}) },
-                    ],
-                },
-            ],
-            linkTypes: [],
-            actionTypes: [],
-            queryFunctionTypes: [],
-        });
-        const harness = createSyncHarness([], {
-            decodeEditObject: (object) => codec.decodeEditObject("Employee", object),
-        });
-        mockState.subscribeCallback?.({ type: "state", status: "open" });
-        await vi.waitFor(() => {
-            expect(harness.syncedData.get(5)).toEqual({
-                employeeId: 5,
-                name: "Employee Five",
-                location: { lat: 40.375786, lon: -74.11144 },
-            });
-        });
-        expect(mockState.getObject).not.toHaveBeenCalled();
-        harness.cleanup();
-    });
-    it("unwraps tagged primary key values from edit history", async () => {
-        mockState.getEditsHistory.mockResolvedValue({
-            data: [
-                {
-                    objectPrimaryKey: {
-                        employeeId: {
-                            type: "stringValue",
-                            value: "employee-4",
-                        },
-                    },
-                    operationId: "op-1",
-                    actionTypeRid: "action-1",
-                    userId: "user-1",
-                    timestamp: "2099-03-12T12:00:00.000Z",
-                    edit: {
-                        type: "createEdit",
-                        properties: {
-                            employeeId: {
-                                type: "stringValue",
-                                value: "employee-4",
-                            },
-                            name: "Employee Four",
-                        },
-                    },
-                },
-            ],
-            nextPageToken: undefined,
-        });
-        const codec = createFoundryCodec({
-            types: [],
-            objectTypes: [
-                {
-                    name: "Employee",
-                    displayName: "Employee",
-                    pluralDisplayName: "Employees",
-                    primaryKey: "employeeId",
-                    properties: [
-                        { name: "employeeId", displayName: "Employee ID", type: o.string({}) },
-                        { name: "name", displayName: "Name", type: o.string({}) },
-                    ],
-                },
-            ],
-            linkTypes: [],
-            actionTypes: [],
-            queryFunctionTypes: [],
-        });
-        const harness = createSyncHarness([], {
-            decodeEditObject: (object) => codec.decodeEditObject("Employee", object),
-        });
-        mockState.subscribeCallback?.({ type: "state", status: "open" });
-        await vi.waitFor(() => {
-            expect(harness.syncedData.get("employee-4")).toEqual({
-                employeeId: "employee-4",
-                name: "Employee Four",
-            });
-        });
-        expect(mockState.getObject).not.toHaveBeenCalled();
-        harness.cleanup();
-    });
-    it("triggers history catch-up on ADDED_OR_UPDATED watcher events", async () => {
-        mockState.getEditsHistory
-            .mockResolvedValueOnce({
-            data: [],
-            nextPageToken: undefined,
-        })
-            .mockResolvedValueOnce({
-            data: [
-                {
-                    objectPrimaryKey: { employeeId: 10 },
-                    operationId: "op-10",
-                    actionTypeRid: "action-1",
-                    userId: "user-1",
-                    timestamp: "2099-03-12T12:05:00.000Z",
-                    edit: {
-                        type: "createEdit",
-                        properties: {
-                            employeeId: 10,
-                            name: "New Employee",
-                        },
-                    },
-                },
-            ],
-            nextPageToken: undefined,
-        });
-        const harness = createSyncHarness();
-        mockState.subscribeCallback?.({ type: "state", status: "open" });
-        await vi.waitFor(() => {
-            expect(mockState.getEditsHistory).toHaveBeenCalledTimes(1);
-        });
-        mockState.subscribeCallback?.({
-            type: "change",
-            updates: [
-                {
-                    type: "object",
-                    state: "ADDED_OR_UPDATED",
-                    object: { employeeId: 10, name: "New Employee" },
-                },
-            ],
-        });
-        await vi.waitFor(() => {
-            expect(mockState.getEditsHistory).toHaveBeenCalledTimes(2);
-            expect(harness.syncedData.get(10)).toEqual({
-                employeeId: 10,
-                name: "New Employee",
-            });
-        });
-        harness.cleanup();
-    });
-    it("falls back to direct websocket updates when edit history is unavailable", async () => {
-        const warnSpy = vi.spyOn(console, "warn").mockImplementation(() => { });
-        mockState.getEditsHistory.mockRejectedValue(new Error("Edit history is not enabled"));
-        const harness = createSyncHarness();
-        const baselineCheckpoint = JSON.parse(JSON.stringify([...harness.collectionMetadata.values()][0]));
-        mockState.subscribeCallback?.({
-            type: "change",
-            updates: [
-                {
-                    type: "object",
-                    state: "ADDED_OR_UPDATED",
-                    object: { employeeId: 12, name: "Direct Employee" },
-                },
-            ],
-        });
-        await vi.waitFor(() => {
-            expect(mockState.getEditsHistory).toHaveBeenCalledTimes(1);
-            expect(harness.syncedData.get(12)).toEqual({
-                employeeId: 12,
-                name: "Direct Employee",
-            });
-        });
-        mockState.subscribeCallback?.({
-            type: "change",
-            updates: [
-                {
-                    type: "object",
-                    state: "REMOVED",
-                    object: { employeeId: 12 },
-                },
-            ],
-        });
-        await vi.waitFor(() => {
-            expect(harness.syncedData.has(12)).toBe(false);
-            expect(harness.writes).toContainEqual({ type: "delete", primaryKey: 12 });
-        });
-        expect(mockState.getEditsHistory).toHaveBeenCalledTimes(1);
-        expect([...harness.collectionMetadata.values()][0]).toEqual(baselineCheckpoint);
-        expect(harness.transactions.at(-1)?.collectionMetadata.size).toBe(0);
-        harness.cleanup();
-        warnSpy.mockRestore();
-    });
-    it("fully reconciles after websocket reconnect when edit history is unavailable", async () => {
-        const warnSpy = vi.spyOn(console, "warn").mockImplementation(() => { });
-        mockState.getEditsHistory.mockRejectedValue(new Error("Edit history is not enabled"));
-        mockState.search.mockResolvedValue({
-            data: [],
-            nextPageToken: undefined,
-        });
-        const harness = createSyncHarness();
-        mockState.subscribeCallback?.({
-            type: "state",
-            status: "open",
-        });
-        await vi.waitFor(() => {
-            expect(mockState.search).toHaveBeenCalledOnce();
-        });
-        // Simulate stale persisted state becoming visible while the watcher is
-        // disconnected and therefore unable to report its deletion.
-        harness.syncedData.set(30, {
-            employeeId: 30,
-            name: "Stale Employee",
-        });
-        mockState.subscribeCallback?.({
-            type: "state",
-            status: "open",
-        });
-        await vi.waitFor(() => {
-            expect(mockState.search).toHaveBeenCalledTimes(2);
-            expect(harness.syncedData.has(30)).toBe(false);
-        });
-        expect(harness.truncate).toHaveBeenCalled();
-        harness.cleanup();
-        warnSpy.mockRestore();
-    });
-    it("does not checkpoint partially fetched history when falling back", async () => {
-        const warnSpy = vi.spyOn(console, "warn").mockImplementation(() => { });
-        mockState.getEditsHistory
-            .mockResolvedValueOnce({
-            data: [
-                {
-                    objectPrimaryKey: { employeeId: 20 },
-                    operationId: "op-history-20",
-                    actionTypeRid: "action-1",
-                    userId: "user-1",
-                    timestamp: "2099-03-12T12:10:00.000Z",
-                    edit: {
-                        type: "createEdit",
-                        properties: {
-                            employeeId: 20,
-                            name: "Uncommitted History Employee",
-                        },
-                    },
-                },
-            ],
-            nextPageToken: "next",
-        })
-            .mockRejectedValueOnce(new Error("Edit history pagination failed"));
-        const harness = createSyncHarness();
-        const baselineCheckpoint = JSON.parse(JSON.stringify([...harness.collectionMetadata.values()][0]));
-        mockState.subscribeCallback?.({
-            type: "change",
-            updates: [
-                {
-                    type: "object",
-                    state: "ADDED_OR_UPDATED",
-                    object: { employeeId: 21, name: "Direct Employee" },
-                },
-            ],
-        });
-        await vi.waitFor(() => {
-            expect(mockState.getEditsHistory).toHaveBeenCalledTimes(2);
-            expect(harness.syncedData.get(21)).toMatchObject({ name: "Direct Employee" });
-        });
-        expect(harness.syncedData.has(20)).toBe(false);
-        expect(harness.writes).toEqual([{ type: "insert", primaryKey: 21 }]);
-        expect([...harness.collectionMetadata.values()][0]).toEqual(baselineCheckpoint);
-        harness.cleanup();
-        warnSpy.mockRestore();
-    });
-    it("returns immediately when awaiting an operation before sync has started", async () => {
-        const { utils } = objectCollectionOptions({
-            client: {
-                baseUrl: "https://example.com",
-                fetch: vi.fn(),
-                ontologyRid: "ri.ontology.main",
-                tokenProvider: () => Promise.resolve("token"),
-            },
-            objectType: "Employee",
-            primaryKeyProperty: "employeeId",
-            selectedProperties: ["employeeId", "name"],
-        });
-        await expect(utils.awaitOperationId("op-before-sync")).resolves.toBeUndefined();
-        expect(mockState.getEditsHistory).not.toHaveBeenCalled();
-    });
-    it("resolves awaitOperationId after direct websocket sync observes an update", async () => {
-        const warnSpy = vi.spyOn(console, "warn").mockImplementation(() => { });
-        mockState.getEditsHistory.mockRejectedValue(new Error("Edit history is not enabled"));
-        let resolveCommit;
-        const commitApplied = new Promise((resolve) => {
-            resolveCommit = resolve;
-        });
-        const harness = createSyncHarness([], {
-            commitReceipt: () => commitApplied,
-        });
-        const operationPromise = harness.utils.awaitOperationId("op-12");
-        await vi.waitFor(() => {
-            expect(mockState.getEditsHistory).toHaveBeenCalledTimes(1);
-        });
-        mockState.subscribeCallback?.({
-            type: "change",
-            updates: [
-                {
-                    type: "object",
-                    state: "ADDED_OR_UPDATED",
-                    object: { employeeId: 13, name: "Direct Operation Employee" },
-                },
-            ],
-        });
-        await expect(operationPromise).resolves.toBeUndefined();
-        expect(harness.syncedData.get(13)).toEqual({
-            employeeId: 13,
-            name: "Direct Operation Employee",
-        });
-        expect(mockState.getEditsHistory).toHaveBeenCalledTimes(1);
-        resolveCommit();
-        await commitApplied;
-        harness.cleanup();
-        warnSpy.mockRestore();
-    });
-    it("awaitOperationId resolves after the matching edit is observed", async () => {
-        mockState.getEditsHistory.mockResolvedValue({
-            data: [
-                {
-                    objectPrimaryKey: { employeeId: 11 },
-                    operationId: "op-11",
-                    actionTypeRid: "action-1",
-                    userId: "user-1",
-                    timestamp: "2099-03-12T12:06:00.000Z",
-                    edit: {
-                        type: "createEdit",
-                        properties: {
-                            employeeId: 11,
-                            name: "Operation Eleven",
-                        },
-                    },
-                },
-            ],
-            nextPageToken: undefined,
-        });
-        let resolveCommit;
-        const commitApplied = new Promise((resolve) => {
-            resolveCommit = resolve;
-        });
-        const harness = createSyncHarness([], {
-            commitReceipt: () => commitApplied,
-        });
-        await expect(harness.utils.awaitOperationId("op-11")).resolves.toBeUndefined();
-        expect(mockState.getEditsHistory).toHaveBeenCalledTimes(1);
-        expect(harness.syncedData.get(11)).toEqual({
-            employeeId: 11,
-            name: "Operation Eleven",
-        });
-        resolveCommit();
-        await commitApplied;
-        harness.cleanup();
-    });
-    it("combines the subset where clause with cursor.whereFrom", async () => {
-        mockState.search.mockResolvedValue({
-            data: [{ employeeId: 2, status: "open", priority: 6 }],
-            nextPageToken: undefined,
-        });
-        const harness = createSyncHarness();
-        await harness.loadSubset({
-            where: eq(new IR.PropRef(["status"]), "open"),
-            cursor: {
-                whereFrom: gt(new IR.PropRef(["priority"]), 5),
-                whereCurrent: eq(new IR.PropRef(["priority"]), 5),
-            },
-        });
-        const searchOptions = mockState.search.mock.calls[0]?.[3];
-        expect(searchOptions).toMatchObject({
-            where: {
-                type: "and",
-                value: [
-                    {
-                        type: "eq",
-                        propertyIdentifier: { type: "property", apiName: "status" },
-                        value: "open",
-                    },
-                    {
-                        type: "gt",
-                        propertyIdentifier: { type: "property", apiName: "priority" },
-                        value: 5,
-                    },
-                ],
-            },
-        });
-        expect(searchOptions).toMatchObject({
-            select: [
-                "employeeId",
-                "name",
-                "status",
-                "priority",
-            ],
-        });
-        expect(searchOptions?.selectV2).toEqual([]);
-        expect(harness.syncedData.has(2)).toBe(true);
-        harness.cleanup();
-    });
-    it("over-fetches ordered subsets before applying an offset", async () => {
-        mockState.search.mockResolvedValue({
-            data: [
-                { employeeId: 1, priority: 1 },
-                { employeeId: 2, priority: 2 },
-                { employeeId: 3, priority: 3 },
-                { employeeId: 4, priority: 4 },
-            ],
-            nextPageToken: undefined,
-        });
-        const harness = createSyncHarness();
-        await harness.loadSubset({
-            orderBy: [
-                {
-                    expression: new IR.PropRef(["priority"]),
-                    compareOptions: {
-                        direction: "asc",
-                        nulls: "last",
-                    },
-                },
-            ],
-            offset: 2,
-            limit: 2,
-        });
-        expect(mockState.search.mock.calls[0]?.[3]).toMatchObject({
-            pageSize: 4,
-            orderBy: {
-                fields: [{ field: "priority", direction: "asc" }],
-            },
-        });
-        expect([...harness.syncedData.keys()]).toEqual([3, 4]);
-        harness.cleanup();
-    });
-});
-//# sourceMappingURL=objectCollectionOptions.test.js.map