@peers-app/peers-sdk 0.27.3 → 0.27.5

package/dist/data/orm/sql.data-source.test.js

@@ -1,731 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-require("../../index");
-const SQLiteDB = require("better-sqlite3");
-const lodash_1 = require("lodash");
-const zod_1 = require("zod");
-const registry_1 = require("../../contracts/registry");
-const tool_catalog_1 = require("../../contracts/tool-catalog");
-const field_type_1 = require("../../types/field-type");
-const zod_types_1 = require("../../types/zod-types");
-const utils_1 = require("../../utils");
-const tool_catalog_fields_1 = require("../tool-catalog-fields");
-const sql_data_source_1 = require("./sql.data-source");
-const subscribable_data_source_1 = require("./subscribable.data-source");
-const types_1 = require("./types");
-class DBHarness {
-    _db = null;
-    get db() {
-        if (!this._db) {
-            this._db = new SQLiteDB(":memory:");
-            this._db.pragma("journal_mode = WAL");
-        }
-        return this._db;
-    }
-    async get(sql, params = []) {
-        return this.db.prepare(sql).get(params);
-    }
-    async all(sql, params = []) {
-        return this.db.prepare(sql).all(params);
-    }
-    async exec(sql, params = []) {
-        const result = await this.db.prepare(sql).run(params);
-        return { changes: result.changes };
-    }
-    execSync(sql, params = []) {
-        return this.db.prepare(sql).run(params);
-    }
-    getSync(sql, params = []) {
-        return this.db.prepare(sql).get(params);
-    }
-    async close() {
-        this._db?.close();
-        this._db = null;
-    }
-}
-const db = new DBHarness();
-describe("table", () => {
-    const fiveMinutesMs = 5 * 60 * 1000; // 5 minutes in milliseconds
-    jest.setTimeout(fiveMinutesMs);
-    afterAll(async () => {
-        db.db?.close();
-    });
-    describe("when type is defined in code", () => {
-        const taskSchema = zod_1.z.object({
-            taskId: zod_types_1.zodPeerId.default(() => (0, utils_1.newid)()),
-            title: zod_1.z.string(),
-            body: zod_1.z.string().default(""),
-            dueDate: zod_1.z.date().optional(),
-            completeDT: zod_1.z.date().optional(),
-            parentTaskId: zod_types_1.zodPeerId.optional(),
-        });
-        const taskFields = (0, types_1.schemaToFields)(taskSchema);
-        const tasksTableType = {
-            name: "test_tasks_code_driven",
-            description: "Task",
-            primaryKeyName: "taskId",
-            fields: taskFields,
-            indexes: [
-                { fields: ["title"] },
-                { unique: true, fields: ["taskId", { name: "parentTaskId", order: "DESC" }] },
-            ],
-        };
-        const TasksTable = new sql_data_source_1.SQLDataSource(db, tasksTableType);
-        beforeAll(async () => {
-            await TasksTable.dropTableIfExists();
-        });
-        it("should do compile time checks and runtime typechecks", async () => {
-            const badSavePromise = TasksTable.save({
-                id: "test",
-                title: 1,
-                body: "This is a test task",
-                dueDate: new Date(),
-            });
-            // await expect(badSavePromise).rejects.toThrow(`SQLITE_ERROR: table ${tableName} has no column named id`);
-            await expect(badSavePromise).rejects.toThrow(/validation.*failed.*title.*expected string, received number/ims);
-        });
-        it("should do all CRUD operations", async () => {
-            const task1 = {
-                taskId: (0, utils_1.newid)(),
-                title: "Test Task",
-                body: "This is a test task",
-                dueDate: new Date(),
-            };
-            // CREATE
-            await TasksTable.save(task1);
-            // READ
-            let task1Db = await TasksTable.get(task1.taskId);
-            expect(task1Db).toEqual(task1);
-            // UPDATE
-            task1.title = "Updated Task";
-            await TasksTable.save(task1);
-            task1Db = await TasksTable.get(task1.taskId);
-            expect(task1Db).toEqual(task1);
-            // DELETE
-            await TasksTable.delete(task1.taskId);
-            task1Db = await TasksTable.get(task1.taskId);
-            expect(task1Db).toBeUndefined();
-        });
-        it("should enable type-checked queries", async () => {
-            const task1 = {
-                taskId: (0, utils_1.newid)(),
-                title: "Test Task",
-                body: "This is a test task",
-                dueDate: new Date(),
-            };
-            // CREATE
-            await TasksTable.save(task1);
-            // query
-            const results = await TasksTable.list({ title: "Test Task" });
-            expect(results[0]).toEqual(task1);
-            // // @ts-expect-error - making sure type checking is working
-            // const badQueryResults = await TasksTable.list({ id: 'test' });
-            // // note that sqlite does not check that columns exist, so this query succeeds with no matches
-            // expect(badQueryResults).toEqual([]);
-            // @ts-expect-error - making sure type checking is working
-            const badQueryPromise = TasksTable.list({ id: "test" });
-            // SQLite error messages vary by version - some throw "no such column", others succeed with empty results
-            // The important thing is that TypeScript catches this at compile time with @ts-expect-error
-            // await expect(badQueryPromise).rejects.toThrow(`SQLITE_ERROR: table ${tableName} has no column named id`);
-            // await expect(badQueryPromise).rejects.toThrow(`no such column: "id" - should this be a string literal in single-quotes?`);
-            // Instead of checking for a specific error, we check that either:
-            // 1. It throws an error (newer SQLite versions), OR
-            // 2. It returns empty results (older SQLite versions that don't validate column names)
-            try {
-                const results = await badQueryPromise;
-                // If no error is thrown, expect empty results (SQLite doesn't always validate column existence)
-                expect(results).toEqual([]);
-            }
-            catch (error) {
-                // If an error is thrown, it should mention the column
-                expect(error.message).toMatch(/id|column/i);
-            }
-        });
-        it("should validate the data before saving", async () => {
-            // test validates a bad date
-            {
-                const badTask = {
-                    taskId: (0, utils_1.newid)(),
-                    title: "Test Task",
-                    body: "This is a test task",
-                    dueDate: "not a date",
-                };
-                const badSavePromise = TasksTable.save(badTask);
-                await expect(badSavePromise).rejects.toThrow("Expected date, received string");
-            }
-            // test validates a bad id
-            {
-                const badTask = {
-                    taskId: "not an id",
-                    title: "Test Task",
-                    body: "This is a test task",
-                    dueDate: new Date(),
-                };
-                const badSavePromise = TasksTable.save(badTask);
-                await expect(badSavePromise).rejects.toThrow("Invalid id");
-            }
-            // add task to database
-            const existingTaskId = (0, utils_1.newid)();
-            const task1 = {
-                taskId: existingTaskId,
-                title: "Test Task",
-                body: "This is a test task",
-                dueDate: new Date(),
-            };
-            await TasksTable.save(task1);
-            // test validates a duplicate id
-            {
-                // First verify the record actually exists
-                const existingRecord = await TasksTable.get(existingTaskId);
-                expect(existingRecord).toBeDefined();
-                expect(existingRecord?.taskId).toBe(existingTaskId);
-                const badTask = {
-                    taskId: existingTaskId,
-                    title: "Test Task",
-                    body: "This is a test task",
-                    dueDate: new Date(),
-                };
-                // Try-catch approach to handle environments where UNIQUE constraint might not throw
-                // or might throw with different error messages
-                try {
-                    await TasksTable.insert(badTask);
-                    // If we get here without throwing, the test should fail
-                    // This can happen in some SQLite configurations that don't enforce UNIQUE constraints properly
-                    fail("Expected insert to throw UNIQUE constraint error, but it succeeded");
-                }
-                catch (error) {
-                    // Verify the error is related to UNIQUE constraint or primary key
-                    expect(error.message).toMatch(/UNIQUE|constraint|PRIMARY KEY|taskId/i);
-                }
-            }
-            // test validates a bad date on update
-            {
-                const badTask = {
-                    taskId: existingTaskId,
-                    title: "Test Task",
-                    body: "This is a test task",
-                    dueDate: "not a date",
-                };
-                const badSavePromise = TasksTable.update(badTask);
-                await expect(badSavePromise).rejects.toThrow("Expected date, received string");
-            }
-        });
-        it("should allow initializing a record with only part of the data", async () => {
-            const newTask = TasksTable.initRecord();
-            expect(() => TasksTable.schema.parse(newTask)).toThrow();
-            newTask.title = "Test Task";
-            expect(() => TasksTable.schema.parse(newTask)).not.toThrow();
-        });
-        it("applies schema defaults on insert and preserves required fields on partial update", async () => {
-            const inserted = await TasksTable.insert({ title: "Defaulted body" });
-            expect(inserted.body).toBe("");
-            const stored = await TasksTable.get(inserted.taskId);
-            expect(stored?.body).toBe("");
-            await TasksTable.update({
-                taskId: inserted.taskId,
-                title: "Renamed",
-            });
-            const afterUpdate = await TasksTable.get(inserted.taskId);
-            expect(afterUpdate?.title).toBe("Renamed");
-            expect(afterUpdate?.body).toBe("");
-        });
-        afterAll(async () => {
-            await TasksTable.dropTableIfExists();
-            await TasksTable.db.close();
-        });
-    });
-    describe("when type is loaded from database", () => {
-        const tasksTableType = {
-            name: "test_tasks_data_driven",
-            description: "Task",
-            primaryKeyName: "taskId",
-            fields: [
-                { name: "taskId", description: "Task ID", type: field_type_1.FieldType.id },
-                { name: "title", description: "Title", type: field_type_1.FieldType.string },
-                { name: "body", description: "Body", type: field_type_1.FieldType.string },
-                { name: "dueDate", description: "Due Date", type: field_type_1.FieldType.Date, optional: true },
-                { name: "completeDT", description: "Complete Date", type: field_type_1.FieldType.Date, optional: true },
-                { name: "parentTaskId", description: "Parent Task ID", type: field_type_1.FieldType.id, optional: true },
-            ],
-        };
-        const TasksTable = new sql_data_source_1.SQLDataSource(db, tasksTableType);
-        beforeAll(async () => {
-            await TasksTable.dropTableIfExists();
-        });
-        it("should do runtime typechecks", async () => {
-            const badSavePromise = TasksTable.save({
-                id: "test",
-                title: 1,
-                body: "This is a test task",
-                dueDate: new Date(),
-            });
-            // await expect(badSavePromise).rejects.toThrow(`SQLITE_ERROR: table ${tableName} has no column named id`);
-            await expect(badSavePromise).rejects.toThrow(/validation.*failed.*title.*expected string, received number/ims);
-        });
-        it("should do all CRUD operations", async () => {
-            const task1 = {
-                taskId: (0, utils_1.newid)(),
-                title: "Test Task",
-                body: "This is a test task",
-                dueDate: new Date(),
-            };
-            // CREATE
-            await TasksTable.save(task1);
-            // READ
-            let task1Db = await TasksTable.get(task1.taskId);
-            expect(task1Db).toEqual(task1);
-            // UPDATE
-            task1.title = "Updated Task";
-            await TasksTable.save(task1);
-            task1Db = await TasksTable.get(task1.taskId);
-            expect(task1Db).toEqual(task1);
-            // DELETE
-            await TasksTable.delete(task1.taskId);
-            task1Db = await TasksTable.get(task1.taskId);
-            expect(task1Db).toBeUndefined();
-        });
-        afterAll(async () => {
-            await TasksTable.dropTableIfExists();
-            await TasksTable.db.close();
-        });
-    });
-    describe("when the schema has changed", () => {
-        const notesTableTypeV1 = {
-            name: "test_table_notes",
-            description: "Notes",
-            primaryKeyName: "entryId",
-            fields: [
-                { name: "entryId", description: "Entry ID", type: field_type_1.FieldType.id },
-                { name: "title", description: "Title", type: field_type_1.FieldType.string },
-                { name: "body", description: "Body", type: field_type_1.FieldType.string, defaultValue: "" },
-            ],
-            indexes: [{ fields: ["title"] }],
-        };
-        const NotesTableV1 = new sql_data_source_1.SQLDataSource(db, notesTableTypeV1);
-        beforeAll(async () => {
-            await NotesTableV1.dropTableIfExists();
-            await NotesTableV1.list();
-        });
-        it("should not update table if already up to date", async () => {
-            const updated = await NotesTableV1.initTable(true);
-            expect(updated).toBe(false);
-        });
-        it("should detect column changes and modify tables to match", async () => {
-            const v1Note = await NotesTableV1.insert({ title: "Test Note", body: "This is a test note" });
-            // add optional number column
-            const notesTableTypeV2 = (0, lodash_1.cloneDeep)(notesTableTypeV1);
-            notesTableTypeV2.fields.push({
-                name: "priority",
-                description: "Priority of note",
-                type: field_type_1.FieldType.number,
-                optional: true,
-            });
-            const NotesTableV2 = new sql_data_source_1.SQLDataSource(db, notesTableTypeV2);
-            const updatedToV2 = await NotesTableV2.initTable(true);
-            expect(updatedToV2).toBe(true);
-            const v2Note = await NotesTableV2.get(v1Note.entryId);
-            expect(v2Note).toEqual({ ...v1Note });
-            // add required date column
-            const notesTableTypeV3 = (0, lodash_1.cloneDeep)(notesTableTypeV2);
-            notesTableTypeV3.fields.push({
-                name: "modified",
-                description: "Last time this was modified",
-                type: field_type_1.FieldType.Date,
-                defaultValue: () => new Date(),
-            });
-            const NotesTableV3 = new sql_data_source_1.SQLDataSource(db, notesTableTypeV3);
-            const updatedToV3 = await NotesTableV3.initTable(true);
-            expect(updatedToV3).toBe(true);
-            const v3Note = await NotesTableV3.get(v1Note.entryId);
-            expect(v3Note).toEqual({ ...v1Note, modified: v3Note?.modified });
-            // remove column
-            const notesTableTypeV4 = (0, lodash_1.cloneDeep)(notesTableTypeV3);
-            notesTableTypeV4.fields.pop();
-            const NotesTableV4 = new sql_data_source_1.SQLDataSource(db, notesTableTypeV4);
-            const updatedToV4 = await NotesTableV4.initTable(true);
-            expect(updatedToV4).toBe(true);
-            const v4Note = await NotesTableV4.get(v1Note.entryId);
-            expect(v4Note).toEqual({ ...v1Note });
-            // change column type and make required
-            const notesTableTypeV5 = (0, lodash_1.cloneDeep)(notesTableTypeV4);
-            notesTableTypeV5.fields[3].type = field_type_1.FieldType.boolean;
-            notesTableTypeV5.fields[3].optional = false;
-            const NotesTableV5 = new sql_data_source_1.SQLDataSource(db, notesTableTypeV5);
-            const updatedToV5 = await NotesTableV5.initTable(true);
-            expect(updatedToV5).toBe(true);
-            const v5Note = await NotesTableV5.get(v1Note.entryId);
-            expect(v5Note).toEqual({ ...v1Note, priority: false });
-            const updatedToV5Again = await NotesTableV5.initTable(true);
-            expect(updatedToV5Again).toBe(false);
-        });
-        it("should detect and change column indexes", async () => {
-            const notesTableTypeV1Indexes = (0, lodash_1.cloneDeep)(notesTableTypeV1);
-            notesTableTypeV1Indexes.name += "_indexes";
-            const NotesTableV1 = new sql_data_source_1.SQLDataSource(db, notesTableTypeV1Indexes);
-            await NotesTableV1.dropTableIfExists();
-            await NotesTableV1.initTable(true);
-            const indexesV1 = await NotesTableV1.db.all(`PRAGMA index_list("${NotesTableV1.tableName}")`, []);
-            expect(indexesV1).toHaveLength(2);
-            // remove indexes
-            const notesTableTypeV2Indexes = (0, lodash_1.cloneDeep)(notesTableTypeV1Indexes);
-            notesTableTypeV2Indexes.indexes = [];
-            const NotesTableV2 = new sql_data_source_1.SQLDataSource(db, notesTableTypeV2Indexes);
-            const updatedToV2 = await NotesTableV2.initTable(true);
-            // indexes are updated separately from tables
-            expect(updatedToV2).toBe(false);
-            const indexesV2 = await NotesTableV1.db.all(`PRAGMA index_list("${NotesTableV1.tableName}")`, []);
-            expect(indexesV2).toHaveLength(1);
-        });
-    });
-    describe("when the field type is `object`", () => {
-        const tableType = {
-            name: "test_table_objects",
-            description: "Objects",
-            primaryKeyName: "objectId",
-            fields: [
-                { name: "objectId", description: "Object ID", type: field_type_1.FieldType.id },
-                { name: "name", description: "Name", type: field_type_1.FieldType.string },
-                { name: "data", description: "Data", type: field_type_1.FieldType.object },
-            ],
-        };
-        const ObjectsTable = new sql_data_source_1.SQLDataSource(db, tableType);
-        beforeAll(async () => {
-            await ObjectsTable.dropTableIfExists();
-        });
-        it("should store objects as JSON strings", async () => {
-            const obj = {
-                objectId: (0, utils_1.newid)(),
-                name: "Test Object",
-                data: { test: "data" },
-            };
-            await ObjectsTable.save(obj);
-            const objDb = await ObjectsTable.get(obj.objectId);
-            expect(objDb).toEqual(obj);
-        });
-        afterAll(async () => {
-            await ObjectsTable.dropTableIfExists();
-            await ObjectsTable.db.close();
-        });
-    });
-    describe("when the field type is an array of primitives", () => {
-        const tableType = {
-            name: "test_table_arrays",
-            description: "Arrays",
-            primaryKeyName: "arrayId",
-            fields: [
-                { name: "arrayId", description: "Array ID", type: field_type_1.FieldType.id },
-                { name: "name", description: "Name", type: field_type_1.FieldType.string },
-                { name: "data", description: "Data", type: field_type_1.FieldType.string, isArray: true },
-            ],
-        };
-        const ArraysTable = new sql_data_source_1.SQLDataSource(db, tableType);
-        beforeAll(async () => {
-            await ArraysTable.dropTableIfExists();
-        });
-        it("should store arrays as JSON strings and automatically rehydrate them", async () => {
-            const obj = {
-                arrayId: (0, utils_1.newid)(),
-                name: "Test Array",
-                data: ["test", "data"],
-            };
-            await ArraysTable.save(obj);
-            const objDb = await ArraysTable.get(obj.arrayId);
-            expect(objDb).toEqual(obj);
-        });
-        afterAll(async () => {
-            await ArraysTable.dropTableIfExists();
-            await ArraysTable.db.close();
-        });
-    });
-    describe("when a field is empty", () => {
-        const tableType = {
-            name: "test_table_empty_values",
-            description: "Empty values",
-            primaryKeyName: "rowId",
-            fields: [
-                { name: "rowId", type: field_type_1.FieldType.id },
-                { name: "title", type: field_type_1.FieldType.string },
-                { name: "note", type: field_type_1.FieldType.string, optional: true },
-                { name: "count", type: field_type_1.FieldType.number, optional: true },
-                { name: "when", type: field_type_1.FieldType.Date, optional: true },
-                {
-                    name: "detail",
-                    type: field_type_1.FieldType.object,
-                    optional: true,
-                    fields: [
-                        { name: "city", type: field_type_1.FieldType.string },
-                        { name: "zip", type: field_type_1.FieldType.string, optional: true },
-                    ],
-                },
-                { name: "tags", type: field_type_1.FieldType.string, isArray: true, optional: true },
-                { name: "rank", type: field_type_1.FieldType.number, defaultValue: 5 },
-                { name: "priority", type: field_type_1.FieldType.number, optional: true, defaultValue: 2 },
-            ],
-        };
-        const EmptyTable = new sql_data_source_1.SQLDataSource(db, tableType);
-        const empty = { note: null, count: undefined, when: null, tags: null };
-        beforeAll(async () => {
-            await EmptyTable.dropTableIfExists();
-        });
-        it("leaves out null and undefined optional fields and reads them back unset", async () => {
-            const detail = { city: "Austin", zip: null };
-            const row = { rowId: (0, utils_1.newid)(), title: "a", ...empty, detail };
-            const expected = {
-                rowId: row.rowId,
-                title: "a",
-                detail: { city: "Austin" },
-                rank: 5,
-                priority: 2,
-            };
-            expect(await EmptyTable.save(row)).toEqual(expected);
-            expect(row).not.toHaveProperty("count");
-            expect(await EmptyTable.get(row.rowId)).toEqual(expected);
-            const stored = await db.get(`SELECT * FROM "${EmptyTable.tableName}" WHERE rowId = ?`, [
-                row.rowId,
-            ]);
-            expect(stored.note).toBeNull();
-            // The caller's nested object is left as it was.
-            expect(detail).toEqual({ city: "Austin", zip: null });
-        });
-        it("clears a field saved empty, and gives an empty field with a default its default", async () => {
-            const row = { rowId: (0, utils_1.newid)(), title: "a", note: "set", rank: 7 };
-            await EmptyTable.save(row);
-            expect(await EmptyTable.get(row.rowId)).toEqual(row);
-            expect(await EmptyTable.save({ ...row, note: null, rank: null })).toEqual({
-                rowId: row.rowId,
-                title: "a",
-                rank: 5,
-                priority: 2,
-            });
-            expect(await EmptyTable.get(row.rowId)).toEqual({
-                rowId: row.rowId,
-                title: "a",
-                rank: 5,
-                priority: 2,
-            });
-        });
-        it("does the same in synchronous inserts and updates", async () => {
-            await EmptyTable.initTable();
-            const row = { rowId: (0, utils_1.newid)(), title: "a", note: "set", rank: 7 };
-            db.db.transaction(() => EmptyTable.saveSync({ ...row, note: null }))();
-            expect(await EmptyTable.get(row.rowId)).toEqual({
-                rowId: row.rowId,
-                title: "a",
-                rank: 7,
-                priority: 2,
-            });
-            db.db.transaction(() => EmptyTable.saveSync({ ...row, rank: null }))();
-            expect(await EmptyTable.get(row.rowId)).toEqual({ ...row, rank: 5, priority: 2 });
-        });
-        it.each([
-            null,
-            undefined,
-            "missing",
-        ])("resets an optional default for %s in either update path", async (emptyValue) => {
-            const row = { rowId: (0, utils_1.newid)(), title: "a", rank: 7, priority: 9 };
-            await EmptyTable.save(row);
-            const cleared = {
-                rowId: row.rowId,
-                title: "a",
-                rank: 7,
-                ...(emptyValue === "missing" ? {} : { priority: emptyValue }),
-            };
-            const expected = { rowId: row.rowId, title: "a", rank: 7, priority: 2 };
-            expect(await EmptyTable.update({ ...cleared })).toStrictEqual(expected);
-            expect(await EmptyTable.get(row.rowId)).toEqual(expected);
-            await EmptyTable.update(row);
-            expect(EmptyTable.updateSync({ ...cleared })).toStrictEqual(expected);
-            expect(await EmptyTable.get(row.rowId)).toEqual(expected);
-        });
-        it("still refuses an empty required field", async () => {
-            const row = { rowId: (0, utils_1.newid)(), title: null };
-            await expect(EmptyTable.save(row)).rejects.toThrow(/Expected string/);
-            expect(() => EmptyTable.saveSync(row)).toThrow(/Expected string/);
-            expect(await EmptyTable.get(row.rowId)).toBeUndefined();
-        });
-        afterAll(async () => {
-            await EmptyTable.dropTableIfExists();
-            await EmptyTable.db.close();
-        });
-    });
-    it("keeps legacy nullable enum defaults working without changing their field IR", async () => {
-        // FrameMembers.role uses this schema; legacy schemaToFields must remain unchanged.
-        const schema = zod_1.z.object({
-            rowId: zod_types_1.zodPeerId,
-            role: zod_1.z.enum(["observation", "value"]).nullable().default(null),
-        });
-        const fields = (0, types_1.schemaToFields)(schema);
-        expect(fields[1]).toEqual({
-            name: "role",
-            type: field_type_1.FieldType.any,
-            defaultValue: expect.any(Function),
-        });
-        const source = new sql_data_source_1.SQLDataSource(db, {
-            name: "legacy_empty_default",
-            description: "Legacy nullable enum default.",
-            primaryKeyName: "rowId",
-            fields,
-        });
-        const row = { rowId: (0, utils_1.newid)(), role: null };
-        expect(await source.insert(row)).toEqual(row);
-        await source.update({ rowId: row.rowId, role: "value" });
-        expect(await source.update({ rowId: row.rowId, role: null })).toEqual(row);
-        expect(source.updateSync({ rowId: row.rowId, role: null })).toEqual(row);
-        await source.dropTableIfExists();
-    });
-});
-describe("Tools additive catalog migration", () => {
-    test("catalog readiness retries failed SQLite schema initialization on the same source", async () => {
-        const { toolSchema } = await Promise.resolve().then(() => require("../tools"));
-        const harness = new DBHarness();
-        const source = new sql_data_source_1.SQLDataSource(harness, {
-            name: "Tools",
-            description: "",
-            primaryKeyName: "toolId",
-            fields: (0, types_1.schemaToFields)(toolSchema),
-            indexes: [{ fields: ["contractId", "contractVersion", "toolName"] }],
-            versionNumber: 2,
-        }, toolSchema);
-        const table = new subscribable_data_source_1.SubscribableDataSource(source);
-        const catalog = new tool_catalog_1.ToolCatalog({
-            dataContextId: (0, utils_1.newid)(),
-            tableContainer: { getTable: () => table },
-        }, new registry_1.ContractRegistry());
-        const exec = jest
-            .spyOn(harness, "exec")
-            .mockRejectedValueOnce(new Error("schema temporarily unavailable"));
-        try {
-            const first = catalog.ready();
-            expect(catalog.ready()).toBe(first);
-            await expect(first).rejects.toThrow("schema temporarily unavailable");
-            expect(exec).toHaveBeenCalledTimes(1);
-            await catalog.ready();
-            const rows = await table.list();
-            expect(rows.length).toBeGreaterThan(0);
-            expect(rows.every((row) => row.catalogState === "resolved")).toBe(true);
-            expect(await harness.all('PRAGMA index_list("Tools")')).toEqual(expect.arrayContaining([
-                expect.objectContaining({
-                    name: expect.stringContaining("_contractId_contractVersion_toolName_"),
-                }),
-            ]));
-            expect(catalog.registry.getProviderPackageId(rows[0].contractId, rows[0].contractVersion)).toBeDefined();
-        }
-        finally {
-            await catalog.dispose();
-            await harness.close();
-        }
-    });
-    test("an older failed initialization cannot evict a newer forced initialization", async () => {
-        const { toolSchema } = await Promise.resolve().then(() => require("../tools"));
-        const harness = new DBHarness();
-        const source = new sql_data_source_1.SQLDataSource(harness, {
-            name: "Tools",
-            description: "",
-            primaryKeyName: "toolId",
-            fields: (0, types_1.schemaToFields)(toolSchema),
-        }, toolSchema);
-        let reject;
-        const exec = jest.spyOn(harness, "exec").mockImplementationOnce(() => new Promise((_, fail) => {
-            reject = fail;
-        }));
-        try {
-            const first = source.initTable();
-            const failed = expect(first).rejects.toThrow("older failure");
-            await source.initTable(true);
-            const attempts = exec.mock.calls.length;
-            reject(new Error("older failure"));
-            await failed;
-            await source.initTable();
-            expect(exec).toHaveBeenCalledTimes(attempts);
-        }
-        finally {
-            await harness.close();
-        }
-    });
-    test("preserves legacy values and recreates all indexes after table-copy migration", async () => {
-        const { toolSchema } = await Promise.resolve().then(() => require("../tools"));
-        const harness = new DBHarness();
-        const oldSchema = toolSchema.omit({
-            contractId: true,
-            contractVersion: true,
-            toolName: true,
-            catalogIdentity: true,
-            catalogState: true,
-            catalogReason: true,
-        });
-        const metadata = {
-            name: "Tools",
-            description: "",
-            primaryKeyName: "toolId",
-            fields: (0, types_1.schemaToFields)(oldSchema),
-            indexes: [{ fields: ["name"] }, { fields: ["isAssistantRunner"] }],
-            versionNumber: 1,
-        };
-        const old = new sql_data_source_1.SQLDataSource(harness, metadata, oldSchema);
-        const row = oldSchema.parse({
-            toolId: (0, utils_1.newid)(),
-            name: "preserve me",
-            usageDescription: "legacy",
-            code: "executable",
-            inputSchema: { type: "none" },
-            outputSchema: { type: "none" },
-            accessLevel: 70,
-        });
-        try {
-            await old.save(row);
-            const upgraded = new sql_data_source_1.SQLDataSource(harness, {
-                ...metadata,
-                fields: (0, types_1.schemaToFields)(toolSchema),
-                versionNumber: 2,
-                indexes: [...metadata.indexes, { fields: ["contractId", "contractVersion", "toolName"] }],
-            }, toolSchema);
-            await upgraded.initTable();
-            expect(await upgraded.get(row.toolId)).toMatchObject(row);
-            // Runtime backfill owns only the new columns. Updating them must work
-            // without resending (and potentially overwriting) legacy provider metadata.
-            await upgraded.update((0, tool_catalog_fields_1.toolCatalogPatch)({ toolId: row.toolId, catalogState: "unresolved" }));
-            expect(await upgraded.get(row.toolId)).toMatchObject({ ...row, catalogState: "unresolved" });
-            // A descriptive refresh patch keeps policy; an unmarked full row still replaces it.
-            await upgraded.update((0, tool_catalog_fields_1.toolCatalogPatch)({
-                toolId: row.toolId,
-                usageDescription: "refreshed",
-                detailedDescription: "new",
-            }));
-            expect(await upgraded.get(row.toolId)).toMatchObject({
-                ...row,
-                usageDescription: "refreshed",
-                detailedDescription: "new",
-                accessLevel: 70,
-            });
-            const { accessLevel: _policy, ...withoutPolicy } = row;
-            await upgraded.update({ ...withoutPolicy, catalogState: "unresolved" });
-            expect((await upgraded.get(row.toolId))?.accessLevel).toBeUndefined();
-            await upgraded.update({ ...row, catalogState: "unresolved" });
-            expect(() => (0, tool_catalog_fields_1.toolCatalogPatch)({ toolId: row.toolId, accessLevel: 0 })).toThrow(/accessLevel/);
-            for (const field of ["code", "codeRepository", "packageId"])
-                expect(() => (0, tool_catalog_fields_1.toolCatalogPatch)({ toolId: row.toolId, [field]: "historical" })).toThrow(field);
-            const indexes = await harness.all('PRAGMA index_list("Tools")');
-            expect(indexes
-                .filter((index) => !index.name.startsWith("sqlite_autoindex_"))
-                .map((index) => index.name)).toEqual(expect.arrayContaining([
-                expect.stringContaining("_name_"),
-                expect.stringContaining("_isAssistantRunner_"),
-                expect.stringContaining("_contractId_contractVersion_toolName_"),
-            ]));
-            expect(indexes
-                .filter((index) => index.name.includes("contractId"))
-                .every((index) => index.unique === 0)).toBe(true);
-            const target = {
-                contractId: "00muxgugn6xvs8f2r80ru205t",
-                contractVersion: 1,
-                toolName: "invoke",
-            };
-            await upgraded.save({ ...row, ...target, toolId: "00muxoa8xeet2lpi8bdq55q03" });
-            await upgraded.save({ ...row, ...target, toolId: "00muxob3hbo3f6g49mipy1hyt" });
-            expect(await upgraded.count()).toBe(3);
-        }
-        finally {
-            await harness.close();
-        }
-    });
-});