@peers-app/peers-sdk 0.27.2 → 0.27.4

package/dist/package-loader/isolated-table-gateway.test.js

@@ -1,633 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const SQLiteDB = require("better-sqlite3");
-const event_registry_1 = require("../data/orm/event-registry");
-const sql_data_source_1 = require("../data/orm/sql.data-source");
-const table_1 = require("../data/orm/table");
-const table_container_1 = require("../data/orm/table-container");
-const package_table_identity_1 = require("../data/package-table-identity");
-const table_definitions_table_1 = require("../data/table-definitions-table");
-const field_type_1 = require("../types/field-type");
-const utils_1 = require("../utils");
-const isolated_table_gateway_1 = require("./isolated-table-gateway");
-function makeDeclaration(overrides = {}) {
-    const packageId = overrides.packageId ?? (0, utils_1.newid)();
-    return {
-        packageId,
-        tableName: "State",
-        description: "Owned state",
-        primaryKeyName: "stateId",
-        fields: [
-            { name: "stateId", type: field_type_1.FieldType.id },
-            { name: "count", type: field_type_1.FieldType.number },
-        ],
-        ...overrides,
-    };
-}
-describe("isolated package table gateway", () => {
-    test("memory gateway binds a table and persists get/save across re-register", async () => {
-        const gateway = (0, isolated_table_gateway_1.createMemoryIsolatedPackageTableGateway)();
-        const declaration = makeDeclaration();
-        const recordId = (0, utils_1.newid)();
-        await gateway.register(declaration);
-        expect(await gateway.get(declaration, recordId)).toBeUndefined();
-        await expect(gateway.save(declaration, { stateId: recordId, count: 1 })).resolves.toEqual({
-            stateId: recordId,
-            count: 1,
-        });
-        await expect(gateway.get(declaration, recordId)).resolves.toEqual({
-            stateId: recordId,
-            count: 1,
-        });
-        await expect(gateway.call(declaration, "count", [{}])).resolves.toBe(1);
-        await expect(gateway.call(declaration, "list", [{ count: 1 }])).resolves.toEqual([
-            { stateId: recordId, count: 1 },
-        ]);
-        await expect(gateway.call(declaration, "findOne", [{ count: 1 }])).resolves.toEqual({
-            stateId: recordId,
-            count: 1,
-        });
-        await expect(gateway.call(declaration, "count", [{ count: { $in: [1, 3] } }])).resolves.toBe(1);
-        await expect(gateway.call(declaration, "count", [{ count: { $in: [2] } }])).resolves.toBe(0);
-        await expect(gateway.call(declaration, "list", [{ count: { $gt: 0 } }])).rejects.toThrow("equality and $in filters only");
-        await gateway.register(declaration);
-        await expect(gateway.get(declaration, recordId)).resolves.toEqual({
-            stateId: recordId,
-            count: 1,
-        });
-        await expect(gateway.call(declaration, "update", [{ stateId: recordId, count: 2 }])).resolves.toEqual({ stateId: recordId, count: 2 });
-        await expect(gateway.call(declaration, "delete", [recordId])).resolves.toBeUndefined();
-        await expect(gateway.call(declaration, "get", [recordId])).resolves.toBeUndefined();
-    });
-    test("memory gateway denies undeclared tables and separates package-local names", async () => {
-        const gateway = (0, isolated_table_gateway_1.createMemoryIsolatedPackageTableGateway)();
-        const owner = makeDeclaration();
-        const other = makeDeclaration({ tableName: owner.tableName });
-        const recordId = (0, utils_1.newid)();
-        await gateway.register(owner);
-        await gateway.register(other);
-        await gateway.save(owner, { stateId: recordId, count: 1 });
-        await gateway.save(other, { stateId: recordId, count: 2 });
-        await expect(gateway.get(owner, recordId)).resolves.toEqual({
-            stateId: recordId,
-            count: 1,
-        });
-        await expect(gateway.get(other, recordId)).resolves.toEqual({
-            stateId: recordId,
-            count: 2,
-        });
-        await expect(gateway.get({ ...owner, packageId: (0, utils_1.newid)() }, (0, utils_1.newid)())).rejects.toThrow(/Undeclared isolated table/);
-    });
-    test("unsupported filters fail even on empty tables or after a nonmatching condition", async () => {
-        const gateway = (0, isolated_table_gateway_1.createMemoryIsolatedPackageTableGateway)();
-        const declaration = makeDeclaration();
-        await gateway.register(declaration);
-        for (const operation of ["list", "count", "findOne"]) {
-            await expect(gateway.call(declaration, operation, [{ count: { $gt: 0 } }])).rejects.toThrow("equality and $in filters only");
-        }
-        await gateway.save(declaration, { stateId: (0, utils_1.newid)(), count: 1 });
-        await expect(gateway.call(declaration, "list", [{ count: 2, stateId: { $ne: "missing" } }])).rejects.toThrow("equality and $in filters only");
-    });
-    test("memory table pages use the ORM's one-based page numbers", async () => {
-        const gateway = (0, isolated_table_gateway_1.createMemoryIsolatedPackageTableGateway)();
-        const declaration = makeDeclaration();
-        await gateway.register(declaration);
-        const rows = [1, 2, 3].map((count) => ({ stateId: (0, utils_1.newid)(), count }));
-        for (const row of rows)
-            await gateway.save(declaration, row);
-        for (const page of [undefined, 0, 1]) {
-            await expect(gateway.call(declaration, "list", [{}, { page, pageSize: 2 }])).resolves.toEqual(rows.slice(0, 2));
-        }
-        await expect(gateway.call(declaration, "list", [{}, { page: 2, pageSize: 2 }])).resolves.toEqual(rows.slice(2));
-    });
-    test("memory gateway preserves Date and binary fields without retaining references", async () => {
-        const gateway = (0, isolated_table_gateway_1.createMemoryIsolatedPackageTableGateway)();
-        const declaration = makeDeclaration({
-            fields: [
-                { name: "stateId", type: field_type_1.FieldType.id },
-                { name: "count", type: field_type_1.FieldType.number },
-                { name: "savedAt", type: field_type_1.FieldType.Date },
-                { name: "payload", type: field_type_1.FieldType.blob },
-            ],
-        });
-        const recordId = (0, utils_1.newid)();
-        const input = {
-            stateId: recordId,
-            count: 1,
-            savedAt: new Date("2026-08-24T12:00:00.000Z"),
-            payload: new Uint8Array([4, 5, 6]),
-        };
-        await gateway.register(declaration);
-        await gateway.save(declaration, input);
-        input.savedAt.setUTCFullYear(2030);
-        input.payload[0] = 9;
-        await expect(gateway.get(declaration, recordId)).resolves.toEqual({
-            stateId: recordId,
-            count: 1,
-            savedAt: new Date("2026-08-24T12:00:00.000Z"),
-            payload: new Uint8Array([4, 5, 6]),
-        });
-    });
-    test("memory gateway preserves rows across upgrades and rejects unsafe schema changes", async () => {
-        const gateway = (0, isolated_table_gateway_1.createMemoryIsolatedPackageTableGateway)();
-        const v1 = makeDeclaration({ versionNumber: 1 });
-        const rowId = (0, utils_1.newid)();
-        await gateway.register(v1);
-        await gateway.save(v1, { stateId: rowId, count: 1 });
-        const conflictingV1 = {
-            ...v1,
-            fields: [...v1.fields, { name: "other", type: field_type_1.FieldType.string, optional: true }],
-        };
-        await expect(gateway.register(conflictingV1)).rejects.toThrow(/different schemas at version 1/);
-        const v2 = { ...conflictingV1, versionNumber: 2 };
-        await gateway.register(v2);
-        await expect(gateway.get(v2, rowId)).resolves.toEqual({ stateId: rowId, count: 1 });
-        await expect(gateway.register(v1)).rejects.toThrow(/schema downgrade/);
-        await expect(gateway.register(makeDeclaration({ tableName: 'Unsafe"; DROP TABLE State; --' }))).rejects.toThrow(/only letters, numbers, and underscores/);
-    });
-    test("a rebuild that adds descriptive IR keys, or keys a newer SDK knows, keeps the table version", async () => {
-        const declaration = makeDeclaration({
-            versionNumber: 1,
-            fields: [
-                { name: "stateId", type: field_type_1.FieldType.id },
-                { name: "mode", type: field_type_1.FieldType.string },
-                { name: "where", type: field_type_1.FieldType.object },
-            ],
-        });
-        const tableId = (0, package_table_identity_1.packageScopedTableId)(declaration.packageId, declaration.tableName);
-        const stored = {
-            tableId,
-            name: `${declaration.tableName}_${declaration.packageId}`,
-            metaData: {
-                tableId,
-                packageId: declaration.packageId,
-                name: declaration.tableName,
-                description: declaration.description,
-                primaryKeyName: declaration.primaryKeyName,
-                fields: declaration.fields,
-                versionNumber: 1,
-            },
-            versionNumber: 1,
-        };
-        const table = {
-            get: jest.fn(async (id) => (id === tableId ? stored : undefined)),
-            save: jest.fn(async (record) => record),
-        };
-        const registerTableDefinition = jest.fn();
-        const dataContext = {
-            tableContainer: { registerTableDefinition, getTable: jest.fn(() => table) },
-        };
-        const enriched = {
-            ...declaration,
-            fields: [
-                { name: "stateId", type: field_type_1.FieldType.id },
-                { name: "mode", type: field_type_1.FieldType.string, enumValues: ["on", "off"] },
-                {
-                    name: "where",
-                    type: field_type_1.FieldType.object,
-                    fields: [{ name: "city", type: field_type_1.FieldType.string }],
-                    future: true,
-                },
-            ],
-        };
-        await (0, isolated_table_gateway_1.createIsolatedPackageTableGateway)(dataContext).register(enriched);
-        // The stored definition stays until the table's version changes.
-        expect(table.save).not.toHaveBeenCalled();
-        expect(registerTableDefinition.mock.calls[0][0].metaData.fields).toEqual(declaration.fields);
-        // Every other change at the same version still needs a version bump.
-        await expect((0, isolated_table_gateway_1.createIsolatedPackageTableGateway)(dataContext).register({
-            ...declaration,
-            fields: [
-                declaration.fields[0],
-                { name: "mode", type: field_type_1.FieldType.number },
-                declaration.fields[2],
-            ],
-        })).rejects.toThrow(/different schemas at version 1/);
-    });
-    test("switches a table between synced and local-only at a higher version, keeping its rows", async () => {
-        const gateway = (0, isolated_table_gateway_1.createMemoryIsolatedPackageTableGateway)();
-        const synced = makeDeclaration({ versionNumber: 1 });
-        const rowId = (0, utils_1.newid)();
-        await gateway.register(synced);
-        await gateway.save(synced, { stateId: rowId, count: 1 });
-        // Like any schema change, the flag needs a version bump.
-        await expect(gateway.register({ ...synced, localOnly: true })).rejects.toThrow(/different schemas at version 1/);
-        const local = { ...synced, versionNumber: 2, localOnly: true };
-        await gateway.register(local);
-        await expect(gateway.get(local, rowId)).resolves.toEqual({ stateId: rowId, count: 1 });
-        const syncedAgain = { ...synced, versionNumber: 3 };
-        await gateway.register(syncedAgain);
-        await expect(gateway.get(syncedAgain, rowId)).resolves.toEqual({ stateId: rowId, count: 1 });
-    });
-    test.each([
-        { localOnly: false },
-        { localOnly: true },
-    ])("switches a stored localOnly=$localOnly table only at a higher version, preflighting the batch", async ({ localOnly, }) => {
-        const declaration = makeDeclaration({ versionNumber: 1, localOnly });
-        const tableId = (0, package_table_identity_1.packageScopedTableId)(declaration.packageId, declaration.tableName);
-        const stored = {
-            tableId,
-            name: `${declaration.tableName}_${declaration.packageId}`,
-            metaData: {
-                tableId,
-                packageId: declaration.packageId,
-                name: declaration.tableName,
-                description: declaration.description,
-                primaryKeyName: declaration.primaryKeyName,
-                fields: declaration.fields,
-                versionNumber: 1,
-                ...(localOnly ? { localOnly: true } : {}),
-            },
-            versionNumber: 1,
-        };
-        const table = {
-            get: jest.fn(async (id) => (id === tableId ? stored : undefined)),
-            save: jest.fn(async (record) => record),
-        };
-        const registerTableDefinition = jest.fn();
-        const dataContext = {
-            tableContainer: { registerTableDefinition, getTable: jest.fn(() => table) },
-        };
-        const gateway = (0, isolated_table_gateway_1.createIsolatedPackageTableGateway)(dataContext);
-        // Synced stored definitions omit the flag, even when the incoming declaration says false.
-        await gateway.register(declaration);
-        const registered = registerTableDefinition.mock.calls[0][0].metaData;
-        if (localOnly)
-            expect(registered.localOnly).toBe(true);
-        else
-            expect(registered).not.toHaveProperty("localOnly");
-        // The first gateway rejects from the declaration it holds; a new one, as after a restart,
-        // has only the stored definition to go on.
-        for (const candidate of [gateway, (0, isolated_table_gateway_1.createIsolatedPackageTableGateway)(dataContext)]) {
-            registerTableDefinition.mockClear();
-            table.save.mockClear();
-            const activate = jest.fn();
-            await expect(candidate.registerBatch([
-                makeDeclaration({ packageId: declaration.packageId, tableName: "NewState" }),
-                { ...declaration, localOnly: !localOnly },
-            ], activate)).rejects.toThrow(/different schemas at version 1/);
-            expect(table.save).not.toHaveBeenCalled();
-            expect(registerTableDefinition).not.toHaveBeenCalled();
-            expect(activate).not.toHaveBeenCalled();
-            await expect(candidate.get({ packageId: declaration.packageId, tableName: "NewState" }, (0, utils_1.newid)())).rejects.toThrow(/Undeclared isolated table/);
-        }
-        registerTableDefinition.mockClear();
-        await (0, isolated_table_gateway_1.createIsolatedPackageTableGateway)(dataContext).registerBatch([
-            { ...declaration, versionNumber: 2, localOnly: !localOnly },
-        ]);
-        const savedMetaData = table.save.mock.calls[0][0].metaData;
-        const switched = registerTableDefinition.mock.calls[0][0].metaData;
-        for (const metaData of [savedMetaData, switched]) {
-            expect(metaData.versionNumber).toBe(2);
-            if (localOnly)
-                expect(metaData).not.toHaveProperty("localOnly");
-            else
-                expect(metaData.localOnly).toBe(true);
-        }
-    });
-    test("rejects a table batch without publishing declarations that came before the conflict", async () => {
-        const gateway = (0, isolated_table_gateway_1.createMemoryIsolatedPackageTableGateway)();
-        const first = makeDeclaration({ versionNumber: 1 });
-        const conflicting = {
-            ...first,
-            fields: [...first.fields, { name: "other", type: field_type_1.FieldType.string, optional: true }],
-        };
-        await expect(gateway.registerBatch([first, conflicting])).rejects.toThrow(/different schemas at version 1/);
-        await expect(gateway.get(first, (0, utils_1.newid)())).rejects.toThrow(/Undeclared isolated table/);
-    });
-    test("preflights every stored schema before applying a data-context table batch", async () => {
-        const first = makeDeclaration({ versionNumber: 1 });
-        const second = makeDeclaration({
-            packageId: first.packageId,
-            tableName: "OtherState",
-            versionNumber: 1,
-        });
-        const secondTableId = (0, package_table_identity_1.packageScopedTableId)(second.packageId, second.tableName);
-        const storedDefinitions = new Map([
-            [
-                secondTableId,
-                {
-                    tableId: secondTableId,
-                    name: `${second.tableName}_${second.packageId}`,
-                    metaData: {
-                        tableId: secondTableId,
-                        packageId: second.packageId,
-                        name: second.tableName,
-                        description: second.description,
-                        primaryKeyName: second.primaryKeyName,
-                        fields: second.fields,
-                        versionNumber: 2,
-                    },
-                    versionNumber: 2,
-                },
-            ],
-        ]);
-        const table = {
-            get: jest.fn(async (id) => storedDefinitions.get(id)),
-            save: jest.fn(async (record) => record),
-        };
-        const registerTableDefinition = jest.fn();
-        const gateway = (0, isolated_table_gateway_1.createIsolatedPackageTableGateway)({
-            tableContainer: { registerTableDefinition, getTable: jest.fn(() => table) },
-        });
-        await expect(gateway.registerBatch([first, second])).rejects.toThrow(/schema downgrade/);
-        expect(table.save).not.toHaveBeenCalled();
-        expect(registerTableDefinition).not.toHaveBeenCalled();
-    });
-    test("data-context gateway registers the host table and copies rows", async () => {
-        const declaration = makeDeclaration();
-        const recordId = (0, utils_1.newid)();
-        const rows = new Map();
-        const table = {
-            get: jest.fn(async (id) => rows.get(id)),
-            save: jest.fn(async (record) => {
-                rows.set(String(record.stateId), record);
-                return record;
-            }),
-        };
-        const registerTableDefinition = jest.fn();
-        const getTable = jest.fn(() => table);
-        const gateway = (0, isolated_table_gateway_1.createIsolatedPackageTableGateway)({
-            tableContainer: { registerTableDefinition, getTable },
-        });
-        await gateway.register(declaration);
-        expect(registerTableDefinition).toHaveBeenCalled();
-        await gateway.save(declaration, { stateId: recordId, count: 4 });
-        expect(registerTableDefinition).toHaveBeenCalledWith(expect.objectContaining({
-            metaData: expect.objectContaining({
-                tableId: (0, package_table_identity_1.packageScopedTableId)(declaration.packageId, declaration.tableName),
-                packageId: declaration.packageId,
-                name: "State",
-                primaryKeyName: "stateId",
-            }),
-        }), { overwrite: true });
-        const registeredMetaData = registerTableDefinition.mock.calls[0][0].metaData;
-        expect(registeredMetaData.tableId).toBe((0, package_table_identity_1.packageScopedTableId)(declaration.packageId, declaration.tableName));
-        expect((0, utils_1.getFullTableName)(registeredMetaData)).toBe(`${declaration.tableName}_${declaration.packageId}`);
-        expect(getTable).toHaveBeenCalled();
-        await expect(gateway.get(declaration, recordId)).resolves.toEqual({
-            stateId: recordId,
-            count: 4,
-        });
-        await expect(gateway.call(declaration, "get", [recordId])).resolves.toEqual({
-            stateId: recordId,
-            count: 4,
-        });
-    });
-    test("memory gateway delivers copied dataChanged events for save/call and detaches", async () => {
-        const gateway = (0, isolated_table_gateway_1.createMemoryIsolatedPackageTableGateway)();
-        const declaration = makeDeclaration();
-        const other = makeDeclaration();
-        const recordId = (0, utils_1.newid)();
-        await gateway.registerBatch([declaration, other]);
-        const received = [];
-        const unsubscribe = await gateway.subscribe(declaration, "dataChanged", (event) => {
-            received.push(event);
-        });
-        await gateway.save(declaration, { stateId: recordId, count: 1 });
-        await gateway.call(declaration, "update", [{ stateId: recordId, count: 2 }]);
-        await gateway.save(other, { stateId: (0, utils_1.newid)(), count: 9 });
-        await gateway.call(declaration, "delete", [recordId]);
-        await new Promise((resolve) => setImmediate(resolve));
-        expect(received).toEqual([
-            { dataObject: { stateId: recordId, count: 1 }, op: "save", source: "local" },
-            { dataObject: { stateId: recordId, count: 2 }, op: "update", source: "local" },
-            { dataObject: { stateId: recordId, count: 2 }, op: "delete", source: "local" },
-        ]);
-        const first = received[0];
-        first.dataObject.count = 99;
-        await expect(gateway.get(declaration, recordId)).resolves.toBeUndefined();
-        unsubscribe();
-        await gateway.save(declaration, { stateId: recordId, count: 3 });
-        await new Promise((resolve) => setImmediate(resolve));
-        expect(received).toHaveLength(3);
-        await expect(gateway.subscribe(declaration, "somethingElse", () => undefined)).rejects.toThrow(/Unsupported isolated table event/);
-        await expect(gateway.subscribe(makeDeclaration(), "dataChanged", () => undefined)).rejects.toThrow(/Undeclared isolated table/);
-    });
-    test("data-context gateway subscribes to the host table dataChanged event", async () => {
-        const declaration = makeDeclaration();
-        const handlers = new Set();
-        const table = {
-            get: jest.fn(),
-            save: jest.fn(),
-            dataChanged: {
-                subscribe: jest.fn((handler) => {
-                    handlers.add(handler);
-                    return { unsubscribe: () => handlers.delete(handler) };
-                }),
-            },
-        };
-        const gateway = (0, isolated_table_gateway_1.createIsolatedPackageTableGateway)({
-            tableContainer: { registerTableDefinition: jest.fn(), getTable: jest.fn(() => table) },
-        });
-        await gateway.register(declaration);
-        const received = [];
-        const unsubscribe = await gateway.subscribe(declaration, "dataChanged", (event) => {
-            received.push(event);
-        });
-        expect(table.dataChanged.subscribe).toHaveBeenCalledTimes(1);
-        const row = { stateId: (0, utils_1.newid)(), count: 1 };
-        for (const handler of handlers) {
-            handler({ dataObject: row, op: "save", source: "local" });
-        }
-        expect(received).toEqual([{ dataObject: row, op: "save", source: "local" }]);
-        expect(received[0].dataObject).not.toBe(row);
-        unsubscribe();
-        expect(handlers.size).toBe(0);
-    });
-});
-describe("local-only isolated tables", () => {
-    test("reach the data source factory as local-only, here and on a device with only the synced schema", async () => {
-        const db = new SQLiteDB(":memory:");
-        const sql = {
-            async close() {
-                db.close();
-            },
-            async get(query, params = []) {
-                return db.prepare(query).get(params);
-            },
-            async all(query, params = []) {
-                return db.prepare(query).all(params);
-            },
-            async exec(query, params = []) {
-                return { changes: db.prepare(query).run(params).changes };
-            },
-        };
-        // Real tables also try to persist their definition through the user-context singleton,
-        // which this test doesn't set up; the gateway already saved it.
-        const warn = jest.spyOn(console, "warn").mockImplementation(() => { });
-        const declaration = makeDeclaration({ localOnly: true });
-        const fullName = `${declaration.tableName}_${declaration.packageId}`;
-        const factoryCalls = [];
-        // Two containers over one database: the second stands in for another device that has the
-        // synced TableDefinitions row but hasn't loaded the package.
-        // Builds tables the way DataContext does: the data source factory sees the metadata, which is
-        // where peers-device leaves local-only tables untracked.
-        const context = () => {
-            const dataContext = { dataContextId: (0, utils_1.newid)() };
-            const eventRegistry = new event_registry_1.EventRegistry(dataContext.dataContextId);
-            dataContext.tableContainer = new table_container_1.TableContainer((metaData, schema, TableClass) => {
-                factoryCalls.push({ name: (0, utils_1.getFullTableName)(metaData), localOnly: metaData.localOnly });
-                const dataSource = new sql_data_source_1.SQLDataSource(sql, metaData, schema);
-                return new (TableClass ?? table_1.Table)(metaData, { dataSource, eventRegistry, schema });
-            });
-            return dataContext;
-        };
-        try {
-            const writer = context();
-            const gateway = (0, isolated_table_gateway_1.createIsolatedPackageTableGateway)(writer);
-            await gateway.register(declaration);
-            const received = [];
-            const unsubscribe = await gateway.subscribe(declaration, "dataChanged", (event) => {
-                received.push(event);
-            });
-            const stateId = (0, utils_1.newid)();
-            await gateway.save(declaration, { stateId, count: 1 });
-            await gateway.call(declaration, "update", [{ stateId, count: 2 }]);
-            await gateway.call(declaration, "delete", [stateId]);
-            await new Promise((resolve) => setImmediate(resolve));
-            expect(received).toEqual([
-                { dataObject: { stateId, count: 1 }, op: "insert", source: "local" },
-                { dataObject: { stateId, count: 2 }, op: "update", source: "local" },
-                { dataObject: { stateId, count: 2 }, op: "delete", source: "local" },
-            ]);
-            unsubscribe();
-            await gateway.save(declaration, { stateId, count: 3 });
-            await new Promise((resolve) => setImmediate(resolve));
-            expect(received).toHaveLength(3);
-            expect(factoryCalls).toContainEqual({ name: fullName, localOnly: true });
-            expect(writer.tableContainer.getLocalOnlyTableNames()).toContain(fullName);
-            const stored = await (0, table_definitions_table_1.TableDefinitions)(writer).get((0, package_table_identity_1.packageScopedTableId)(declaration.packageId, declaration.tableName));
-            expect(stored?.metaData).toMatchObject({ localOnly: true });
-            const peer = context();
-            (0, table_definitions_table_1.TableDefinitions)(peer);
-            factoryCalls.length = 0;
-            expect(await peer.tableContainer.getFallbackTable(fullName)).toBeTruthy();
-            expect(factoryCalls).toContainEqual({ name: fullName, localOnly: true });
-            expect(peer.tableContainer.getLocalOnlyTableNames()).toContain(fullName);
-        }
-        finally {
-            warn.mockRestore();
-            db.close();
-        }
-    });
-});
-describe("guarded isolated schema activation", () => {
-    test("memory bindings remain unchanged when activation rejects", async () => {
-        const gateway = (0, isolated_table_gateway_1.createMemoryIsolatedPackageTableGateway)();
-        const old = makeDeclaration({ versionNumber: 1 });
-        const next = {
-            ...old,
-            versionNumber: 2,
-            primaryKeyName: "newId",
-            fields: [{ name: "newId", type: field_type_1.FieldType.id }],
-        };
-        await gateway.register(old);
-        await expect(gateway.registerBatch([next], () => {
-            throw new Error("load invalidated");
-        })).rejects.toThrow("load invalidated");
-        const record = { stateId: (0, utils_1.newid)(), count: 1 };
-        await expect(gateway.save(old, record)).resolves.toEqual(record);
-        await expect(gateway.register(old)).resolves.toBeUndefined();
-    });
-    test.each([
-        "invalidation",
-        "storage",
-    ])("restores SQLite definitions after %s during registration, including fresh tables and restart", async (failure) => {
-        const db = new SQLiteDB(":memory:");
-        const sql = {
-            async close() {
-                db.close();
-            },
-            async get(query, params = []) {
-                return db.prepare(query).get(params);
-            },
-            async all(query, params = []) {
-                return db.prepare(query).all(params);
-            },
-            async exec(query, params = []) {
-                return { changes: db.prepare(query).run(params).changes };
-            },
-        };
-        const context = () => ({
-            dataContextId: (0, utils_1.newid)(),
-            tableContainer: new table_container_1.TableContainer((metaData, schema) => new sql_data_source_1.SQLDataSource(sql, metaData, schema)),
-        });
-        const dataContext = context();
-        const gateway = (0, isolated_table_gateway_1.createIsolatedPackageTableGateway)(dataContext);
-        const old = makeDeclaration({ versionNumber: 1 });
-        const next = {
-            ...old,
-            versionNumber: 2,
-            primaryKeyName: "newId",
-            fields: [{ name: "newId", type: field_type_1.FieldType.id }],
-        };
-        const added = makeDeclaration({
-            packageId: old.packageId,
-            tableName: "Added",
-            versionNumber: 1,
-        });
-        const definitions = (0, table_definitions_table_1.TableDefinitions)(dataContext);
-        const oldId = (0, package_table_identity_1.packageScopedTableId)(old.packageId, old.tableName);
-        const addedId = (0, package_table_identity_1.packageScopedTableId)(added.packageId, added.tableName);
-        const warn = jest.spyOn(console, "warn").mockImplementation(() => { });
-        let release;
-        let arrived;
-        const gate = new Promise((resolve) => {
-            release = resolve;
-        });
-        const saving = new Promise((resolve) => {
-            arrived = resolve;
-        });
-        let saveSpy;
-        try {
-            await gateway.register(old);
-            const record = { stateId: (0, utils_1.newid)(), count: 1 };
-            await gateway.save(old, record);
-            const original = await definitions.get(oldId);
-            const oldTable = dataContext.tableContainer.getTableByName(`${old.tableName}_${old.packageId}`);
-            const save = definitions.save.bind(definitions);
-            let current = true;
-            saveSpy = jest.spyOn(definitions, "save").mockImplementation(async (row, opts) => {
-                const result = await save(row, opts);
-                if (row.tableId === addedId) {
-                    arrived();
-                    await gate;
-                    if (failure === "storage")
-                        throw new Error("storage failed after write");
-                }
-                return result;
-            });
-            const activated = jest.fn(() => {
-                if (!current)
-                    throw new Error("load invalidated");
-            });
-            const registering = gateway.registerBatch([next, added], activated);
-            const rejected = expect(registering).rejects.toThrow(failure === "storage" ? "storage failed after write" : "load invalidated");
-            await saving;
-            expect(dataContext.tableContainer.getTableByName(`${old.tableName}_${old.packageId}`)).toBe(oldTable);
-            current = false;
-            release();
-            await rejected;
-            expect(activated).toHaveBeenCalledTimes(failure === "storage" ? 0 : 1);
-            expect(await definitions.get(oldId)).toEqual(original);
-            expect(await definitions.get(addedId)).toBeUndefined();
-            expect(dataContext.tableContainer.getTableByName(`${old.tableName}_${old.packageId}`)).toBe(oldTable);
-            await expect(gateway.save(old, record)).resolves.toEqual(record);
-            await expect(gateway.get(added, (0, utils_1.newid)())).rejects.toThrow(/Undeclared/);
-            // A cold gateway reads the restored durable version, so v1 can reinstall.
-            const restarted = (0, isolated_table_gateway_1.createIsolatedPackageTableGateway)(context());
-            await expect(restarted.register(old)).resolves.toBeUndefined();
-            await expect(restarted.get(old, record.stateId)).resolves.toEqual(record);
-            saveSpy.mockRestore();
-            await expect(gateway.registerBatch([next, added])).resolves.toBeUndefined();
-            expect((await definitions.get(oldId))?.versionNumber).toBe(2);
-        }
-        finally {
-            release();
-            saveSpy?.mockRestore();
-            warn.mockRestore();
-            db.close();
-        }
-    });
-});

package/dist/package-loader/package-loader.test.d.ts

@@ -1 +0,0 @@
-export {};