@lix-js/sdk 0.5.0-preview.0 → 0.5.0-preview.1

package/dist/file/schema.test.js

@@ -1,7 +1,8 @@
 import { test, expect, expectTypeOf } from "vitest";
 import { openLix } from "../lix/open-lix.js";
 import { createVersion } from "../version/create-version.js";
-import { createCheckpoint } from "../change-set/create-checkpoint.js";
+import { createCheckpoint } from "../commit/create-checkpoint.js";
+import { switchVersion } from "../version/switch-version.js";
 import { mockJsonPlugin } from "../plugin/mock-json-plugin.js";
 test("insert, update, delete on the file view", async () => {
     const lix = await openLix({
@@ -24,7 +25,7 @@ test("insert, update, delete on the file view", async () => {
         ...row,
         data: JSON.parse(new TextDecoder().decode(row.data)),
     }));
-    expect(viewAfterInsert).toEqual([
+    expect(viewAfterInsert).toMatchObject([
         {
             id: "file0",
             path: "/path/to/file.json",
@@ -54,7 +55,7 @@ test("insert, update, delete on the file view", async () => {
         ...row,
         data: JSON.parse(new TextDecoder().decode(row.data)),
     }));
-    expect(viewAfterUpdate).toEqual([
+    expect(viewAfterUpdate).toMatchObject([
         {
             id: "file0",
             path: "/path/to/renamed_file.json",
@@ -140,7 +141,7 @@ test("file insert data materialization", async () => {
         ...row,
         data: JSON.parse(new TextDecoder().decode(row.data)),
     }));
-    expect(viewAfterInsert).toEqual([
+    expect(viewAfterInsert).toMatchObject([
         {
             id: "file0",
             path: "/path/to/file.json",
@@ -216,6 +217,43 @@ test("invalid file paths should be rejected", async () => {
     })
         .execute()).rejects.toThrowError("path must match pattern");
 });
+test("files should have hidden property defaulting to false", async () => {
+    const lix = await openLix({
+        providePlugins: [mockJsonPlugin],
+    });
+    await lix.db
+        .insertInto("file")
+        .values({
+        path: "/hidden-default.json",
+        data: new Uint8Array(),
+    })
+        .execute();
+    const file = await lix.db
+        .selectFrom("file")
+        .where("path", "=", "/hidden-default.json")
+        .selectAll()
+        .executeTakeFirstOrThrow();
+    expect(file.hidden).toBe(0);
+});
+test("can explicitly set hidden to true", async () => {
+    const lix = await openLix({
+        providePlugins: [mockJsonPlugin],
+    });
+    await lix.db
+        .insertInto("file")
+        .values({
+        path: "/hidden.json",
+        data: new Uint8Array(),
+        hidden: true,
+    })
+        .execute();
+    const file = await lix.db
+        .selectFrom("file")
+        .where("path", "=", "/hidden.json")
+        .selectAll()
+        .executeTakeFirstOrThrow();
+    expect(file.hidden).toBe(1);
+});
 test("file_all operations are version specific and isolated", async () => {
     const lix = await openLix({
         providePlugins: [mockJsonPlugin],
@@ -368,7 +406,7 @@ test("file_history provides access to historical file data", async () => {
     })
         .execute();
     // 2. Create checkpoint
-    const checkpoint = await createCheckpoint({
+    const insertCheckpoint = await createCheckpoint({
         lix,
     });
     // 3. Update file
@@ -380,6 +418,9 @@ test("file_history provides access to historical file data", async () => {
         data: new TextEncoder().encode(JSON.stringify(updatedData)),
     })
         .execute();
+    const updateCheckpoint = await createCheckpoint({
+        lix,
+    });
     // 4. Query file, assert that file equals update
     const currentFile = await lix.db
         .selectFrom("file")
@@ -389,26 +430,35 @@ test("file_history provides access to historical file data", async () => {
     const currentFileData = JSON.parse(new TextDecoder().decode(currentFile.data));
     expect(currentFileData).toEqual(updatedData);
     // 5. Query history at checkpoint and assert is initial
-    const historicalFiles = await lix.db
+    const fileHistoryAtInsert = await lix.db
         .selectFrom("file_history")
         .where("id", "=", "test-file")
-        .where("lixcol_change_set_id", "=", checkpoint.id)
+        .where("lixcol_root_commit_id", "=", insertCheckpoint.id)
         .where("lixcol_depth", "=", 0)
         .selectAll()
         .execute();
-    expect(historicalFiles).toHaveLength(1);
-    const historicalFile = historicalFiles[0];
-    const historicalFileData = JSON.parse(new TextDecoder().decode(historicalFile.data));
-    expect(historicalFileData).toEqual(initialData);
-    expect(historicalFile.id).toBe("test-file");
-    expect(historicalFile.path).toBe("/test.json");
-    // Verify historical file has the expected history columns
-    expect(historicalFile.lixcol_change_set_id).toBe(checkpoint.id);
-    expect(historicalFile.lixcol_depth).toBe(0);
-    expect(historicalFile.lixcol_change_id).toBeDefined();
-    expect(historicalFile.lixcol_file_id).toBeDefined();
-    expect(historicalFile.lixcol_plugin_key).toBeDefined();
-    expect(historicalFile.lixcol_schema_version).toBeDefined();
+    expect(fileHistoryAtInsert).toHaveLength(1);
+    const historicalFileAtInsert = fileHistoryAtInsert[0];
+    const historicalFileAtInsertData = JSON.parse(new TextDecoder().decode(historicalFileAtInsert.data));
+    expect(historicalFileAtInsertData).toEqual(initialData);
+    expect(historicalFileAtInsert.id).toBe("test-file");
+    expect(historicalFileAtInsert.path).toBe("/test.json");
+    expect(historicalFileAtInsert.lixcol_commit_id).toBe(insertCheckpoint.id);
+    // 6. Query history at update checkpoint and assert is updated
+    const fileHistoryAtUpdate = await lix.db
+        .selectFrom("file_history")
+        .where("id", "=", "test-file")
+        .where("lixcol_root_commit_id", "=", updateCheckpoint.id)
+        .where("lixcol_depth", "=", 0)
+        .selectAll()
+        .execute();
+    expect(fileHistoryAtUpdate).toHaveLength(1);
+    const historicalFileAtUpdate = fileHistoryAtUpdate[0];
+    const historicalFileAtUpdateData = JSON.parse(new TextDecoder().decode(historicalFileAtUpdate.data));
+    expect(historicalFileAtUpdateData).toEqual(updatedData);
+    expect(historicalFileAtUpdate.id).toBe("test-file");
+    expect(historicalFileAtUpdate.path).toBe("/test.json");
+    expect(historicalFileAtUpdate.lixcol_commit_id).toBe(updateCheckpoint.id);
 });
 // its super annoying to work with metadata otherwise
 test("file metadata is Record<string, any>", async () => {
@@ -426,6 +476,16 @@ test("file metadata is Record<string, any>", async () => {
 test("file and file_all views expose change_id for blame and diff functionality", async () => {
     const lix = await openLix({
         providePlugins: [mockJsonPlugin],
+        keyValues: [
+            {
+                key: "lix_deterministic_mode",
+                value: {
+                    enabled: true,
+                    bootstrap: true,
+                },
+                lixcol_version_id: "global",
+            },
+        ],
     });
     // Insert initial file using file view to ensure triggers are executed
     await lix.db
@@ -456,21 +516,17 @@ test("file and file_all views expose change_id for blame and diff functionality"
     expect(typeof fileResult[0]?.lixcol_change_id).toBe("string");
     // Verify that change_id matches between file and file_all views
     expect(fileResult[0]?.lixcol_change_id).toBe(fileAllResult[0]?.lixcol_change_id);
-    // Get the actual file entity change record to verify the change_id is correct
-    const fileChangeRecord = await lix.db
+    // Get the latest change for this file (could be descriptor or content)
+    const latestChange = await lix.db
         .selectFrom("change")
-        .where("entity_id", "=", "change-id-test-file")
-        .where("schema_key", "=", "lix_file_descriptor")
-        .select(["id", "snapshot_content"])
+        .where("file_id", "=", "change-id-test-file")
+        .orderBy("created_at", "desc")
+        .select(["id", "schema_key", "snapshot_content"])
         .executeTakeFirstOrThrow();
-    // Verify that the change_id in the views matches the actual file change.id
-    expect(fileResult[0]?.lixcol_change_id).toBe(fileChangeRecord.id);
-    expect(fileAllResult[0]?.lixcol_change_id).toBe(fileChangeRecord.id);
-    // Verify that the snapshot content in the change matches the file view
-    expect(fileChangeRecord.snapshot_content).toMatchObject({
-        id: "change-id-test-file",
-        path: "/test-change-id.json",
-    });
+    // Verify that the change_id in the views matches the latest change
+    expect(fileResult[0]?.lixcol_change_id).toBe(latestChange.id);
+    expect(fileAllResult[0]?.lixcol_change_id).toBe(latestChange.id);
+    // Verify that the file view shows correct file info
     expect(fileResult[0]?.id).toBe("change-id-test-file");
     expect(fileResult[0]?.path).toBe("/test-change-id.json");
     // Update the file to create a new change
@@ -478,7 +534,6 @@ test("file and file_all views expose change_id for blame and diff functionality"
         .updateTable("file")
         .set({
         path: "/test-change-id-updated.json",
-        data: new TextEncoder().encode(JSON.stringify({ prop: "updated value" })),
     })
         .where("id", "=", "change-id-test-file")
         .execute();
@@ -495,7 +550,7 @@ test("file and file_all views expose change_id for blame and diff functionality"
     // Get the new file entity change record
     const newFileChangeRecord = await lix.db
         .selectFrom("change")
-        .where("entity_id", "=", "change-id-test-file")
+        .where("file_id", "=", "change-id-test-file")
         .where("schema_key", "=", "lix_file_descriptor")
         .orderBy("created_at", "desc")
         .select(["id", "snapshot_content"])
@@ -802,4 +857,457 @@ test("file data updates with untracked state", async () => {
         .execute();
     expect(deletedFile).toHaveLength(0);
 });
+test("file history", async () => {
+    const lix = await openLix({
+        providePlugins: [mockJsonPlugin],
+    });
+    // Insert a JSON file
+    const data = {
+        name: "My Project",
+        version: "1.0.0",
+    };
+    await lix.db
+        .insertInto("file")
+        .values({
+        path: "/config.json",
+        data: new TextEncoder().encode(JSON.stringify(data)),
+    })
+        .execute();
+    // Make a change
+    data.name = "My Cool Project";
+    data.version = "1.1.0";
+    await lix.db
+        .updateTable("file")
+        .where("path", "=", "/config.json")
+        .set({
+        data: new TextEncoder().encode(JSON.stringify(data)),
+    })
+        .execute();
+    // 1. Get the last two versions of the JSON file from history
+    const fileHistory = await lix.db
+        .selectFrom("file_history")
+        .where("file_history.path", "=", "/config.json")
+        .where("lixcol_root_commit_id", "=", lix.db
+        .selectFrom("version")
+        .select("commit_id")
+        .where("version.name", "=", "main"))
+        .orderBy("lixcol_depth", "asc")
+        .selectAll()
+        .execute();
+    expect(fileHistory).toHaveLength(2);
+    const afterState = JSON.parse(new TextDecoder().decode(fileHistory[0].data));
+    const beforeState = JSON.parse(new TextDecoder().decode(fileHistory[1].data));
+    expect(afterState).toEqual({
+        name: "My Cool Project",
+        version: "1.1.0",
+    });
+    expect(beforeState).toEqual({
+        name: "My Project",
+        version: "1.0.0",
+    });
+});
+// This test verifies that file_history correctly reconstructs files when only some properties change.
+// The bug occurred when querying file_history at depth=0 after a partial update:
+// - Changed entities appeared at depth=0
+// - Unchanged entities remained at depth=1+
+// The old implementation only returned entities at the exact depth, missing unchanged properties.
+test("file_history handles partial updates correctly", async () => {
+    const lix = await openLix({
+        providePlugins: [mockJsonPlugin],
+    });
+    await lix.db
+        .insertInto("file")
+        .values({
+        id: "abcdefg",
+        path: "/test.json",
+        data: new TextEncoder().encode(JSON.stringify({
+            name: "test-item",
+            value: 100,
+        })),
+    })
+        .execute();
+    const checkpoint0 = await createCheckpoint({ lix });
+    await lix.db
+        .updateTable("file")
+        .where("path", "=", "/test.json")
+        .set({
+        data: new TextEncoder().encode(JSON.stringify({
+            name: "test-item",
+            value: 105,
+        })),
+    })
+        .execute();
+    const checkpoint1 = await createCheckpoint({ lix });
+    const beforeFile = await lix.db
+        .selectFrom("file_history")
+        .where("path", "=", "/test.json")
+        .where("lixcol_root_commit_id", "=", checkpoint0.id)
+        .where("lixcol_depth", "=", 0)
+        .select("data")
+        .executeTakeFirstOrThrow();
+    const afterFile = await lix.db
+        .selectFrom("file_history")
+        .where("path", "=", "/test.json")
+        .where("lixcol_root_commit_id", "=", checkpoint1.id)
+        .where("lixcol_depth", "=", 0)
+        .select("data")
+        .executeTakeFirstOrThrow();
+    const beforeData = new TextDecoder().decode(beforeFile.data);
+    const afterData = new TextDecoder().decode(afterFile.data);
+    const beforeDoc = JSON.parse(beforeData);
+    const afterDoc = JSON.parse(afterData);
+    expect(beforeDoc).toEqual({
+        name: "test-item",
+        value: 100,
+    });
+    expect(afterDoc).toEqual({
+        name: "test-item",
+        value: 105,
+    });
+});
+test("file views should expose same relevant lixcol_* columns as key_value view", async () => {
+    const lix = await openLix({
+        providePlugins: [mockJsonPlugin],
+    });
+    // Create a file that will be available in all file views
+    await lix.db
+        .insertInto("file")
+        .values({
+        id: "lixcol-test-file",
+        path: "/lixcol-test.json",
+        data: new TextEncoder().encode(JSON.stringify({ test: "data" })),
+    })
+        .execute();
+    // Create a key_value entry for comparison baseline
+    await lix.db
+        .insertInto("key_value")
+        .values({ key: "lixcol-test-kv", value: "test_value" })
+        .execute();
+    // Create a checkpoint for view queries
+    const checkpoint = await createCheckpoint({ lix });
+    // Extract lixcol_* columns helper function
+    const extractLixcols = (obj) => {
+        const lixcols = {};
+        for (const [key, value] of Object.entries(obj)) {
+            if (key.startsWith("lixcol_")) {
+                lixcols[key] = value;
+            }
+        }
+        return lixcols;
+    };
+    // Filter out columns that don't make sense for file views (files are themselves entities)
+    const blacklist = ["lixcol_file_id", "lixcol_plugin_key", "lixcol_entity_id"];
+    const filterColumns = (lixcols) => {
+        const filtered = {};
+        for (const [key, value] of Object.entries(lixcols)) {
+            if (!blacklist.includes(key)) {
+                filtered[key] = value;
+            }
+        }
+        return filtered;
+    };
+    // Test each file view type against corresponding key_value view
+    const views = [
+        {
+            name: "file",
+            fileQuery: () => lix.db
+                .selectFrom("file")
+                .selectAll()
+                .where("id", "=", "lixcol-test-file"),
+            keyValueQuery: () => lix.db
+                .selectFrom("key_value")
+                .selectAll()
+                .where("key", "=", "lixcol-test-kv"),
+        },
+        {
+            name: "file_all",
+            fileQuery: () => lix.db
+                .selectFrom("file_all")
+                .selectAll()
+                .where("id", "=", "lixcol-test-file"),
+            keyValueQuery: () => lix.db
+                .selectFrom("key_value_all")
+                .selectAll()
+                .where("key", "=", "lixcol-test-kv"),
+        },
+        {
+            name: "file_history",
+            fileQuery: () => lix.db
+                .selectFrom("file_history")
+                .selectAll()
+                .where("id", "=", "lixcol-test-file")
+                .where("lixcol_root_commit_id", "=", checkpoint.id)
+                .where("lixcol_depth", "=", 0),
+            keyValueQuery: () => lix.db
+                .selectFrom("key_value_history")
+                .selectAll()
+                .where("key", "=", "lixcol-test-kv")
+                .where("lixcol_root_commit_id", "=", checkpoint.id)
+                .where("lixcol_depth", "=", 0),
+        },
+    ];
+    for (const view of views) {
+        // Query both the file view and corresponding key_value view
+        const fileResult = await view.fileQuery().executeTakeFirstOrThrow();
+        const keyValueResult = await view.keyValueQuery().executeTakeFirstOrThrow();
+        // Extract and filter lixcol_* columns from both
+        const fileLixcols = extractLixcols(fileResult);
+        const keyValueLixcols = extractLixcols(keyValueResult);
+        const fileFilteredLixcols = filterColumns(fileLixcols);
+        const keyValueFilteredLixcols = filterColumns(keyValueLixcols);
+        const fileFilteredKeys = Object.keys(fileFilteredLixcols).sort();
+        const keyValueFilteredKeys = Object.keys(keyValueFilteredLixcols).sort();
+        // File view should expose the same relevant lixcol_* columns as corresponding key_value view (excluding blacklisted ones)
+        expect(fileFilteredKeys).toEqual(keyValueFilteredKeys);
+        // Both should have the same number of relevant lixcol_* columns
+        expect(fileFilteredKeys.length).toBe(keyValueFilteredKeys.length);
+        // All lixcol_* values should be defined (can be null, but not undefined)
+        const fileLixcolKeys = Object.keys(fileLixcols).sort();
+        for (const key of fileLixcolKeys) {
+            expect(fileLixcols[key]).toBeDefined();
+        }
+        // Verify that file views expose lix_file_descriptor as schema key
+        expect(fileResult.lixcol_schema_key).toBe("lix_file_descriptor");
+    }
+});
+test("file should expose lixcol columns based on file data AND the descriptor", async () => {
+    const lix = await openLix({
+        providePlugins: [mockJsonPlugin],
+        keyValues: [
+            {
+                key: "lix_deterministic_mode",
+                value: {
+                    enabled: true,
+                },
+                lixcol_version_id: "global",
+            },
+        ],
+    });
+    // Create a file with JSON content
+    await lix.db
+        .insertInto("file")
+        .values({
+        id: "aggregate-info-test",
+        path: "/document.json",
+        data: new TextEncoder().encode(JSON.stringify({
+            title: "Original Title",
+            content: "Original content",
+        })),
+    })
+        .execute();
+    // Get initial file info
+    const fileAfterCreate = await lix.db
+        .selectFrom("file")
+        .where("id", "=", "aggregate-info-test")
+        .selectAll()
+        .executeTakeFirstOrThrow();
+    const initialChangeId = fileAfterCreate.lixcol_change_id;
+    const initialUpdatedAt = fileAfterCreate.lixcol_updated_at;
+    // Verify that file view exposes lix_file_descriptor as schema key
+    expect(fileAfterCreate.lixcol_schema_key).toBe("lix_file_descriptor");
+    // Verify the initial change is either for the file descriptor or a content entity
+    const initialChange = await lix.db
+        .selectFrom("change")
+        .where("id", "=", initialChangeId)
+        .selectAll()
+        .executeTakeFirstOrThrow();
+    // When creating a file with content, the latest change could be either:
+    // - The file descriptor change
+    // - A content entity change (e.g., mock_json_property)
+    expect(["lix_file_descriptor", "mock_json_property"]).toContain(initialChange.schema_key);
+    // If it's a content change, verify it belongs to this file
+    if (initialChange.schema_key !== "lix_file_descriptor") {
+        expect(initialChange.file_id).toBe("aggregate-info-test");
+    }
+    // Update only the JSON content (not path or metadata)
+    await lix.db
+        .updateTable("file")
+        .where("id", "=", "aggregate-info-test")
+        .set({
+        data: new TextEncoder().encode(JSON.stringify({
+            title: "Updated Title", // Changed
+            content: "Updated content", // Changed
+        })),
+    })
+        .execute();
+    // Get file info after content update
+    const fileAfterContentUpdate = await lix.db
+        .selectFrom("file")
+        .where("id", "=", "aggregate-info-test")
+        .selectAll()
+        .executeTakeFirstOrThrow();
+    // Get all changes related to this file (descriptor + content)
+    const allFileChanges = await lix.db
+        .selectFrom("change")
+        .where((eb) => eb.or([
+        // File descriptor changes
+        eb("entity_id", "=", "aggregate-info-test").and("schema_key", "=", "lix_file_descriptor"),
+        // Content changes (any entity within this file)
+        eb("file_id", "=", "aggregate-info-test"),
+    ]))
+        .orderBy("created_at", "desc")
+        .selectAll()
+        .execute();
+    // There should be multiple changes (descriptor + content properties)
+    expect(allFileChanges.length).toBeGreaterThan(1);
+    const latestContentChange = allFileChanges[0];
+    // The actual latest change is a content change, not the descriptor
+    expect(latestContentChange.schema_key).not.toBe("lix_file_descriptor");
+    // The file view should show the latest change across ALL entities in the file
+    expect(fileAfterContentUpdate.lixcol_change_id).toBe(latestContentChange.id);
+    // The updated_at should reflect when the file was last modified (including content)
+    expect(fileAfterContentUpdate.lixcol_updated_at).toBe(latestContentChange.created_at);
+    // The file's change_set_id should contain the latest content change
+    // Get all changes in the file's current change_set
+    const changesInFileChangeSet = await lix.db
+        .selectFrom("change_set_element")
+        .where("change_set_id", "=", fileAfterContentUpdate.lixcol_commit_id)
+        .selectAll()
+        .execute();
+    const changeIdsInSet = changesInFileChangeSet.map((el) => el.change_id);
+    // The file's change_set_id should contain the latest content change
+    expect(changeIdsInSet).toContain(latestContentChange.id);
+    // Test file_all view shows the same aggregated behavior AT THIS POINT (before path update)
+    // Re-query file_all after content update to verify it shows latest change
+    const fileAllAfterContentUpdate = await lix.db
+        .selectFrom("file_all")
+        .where("id", "=", "aggregate-info-test")
+        .selectAll()
+        .executeTakeFirstOrThrow();
+    // file_all should show the same change_id as the file view at this point
+    expect(fileAllAfterContentUpdate.lixcol_change_id).toBe(fileAfterContentUpdate.lixcol_change_id);
+    expect(fileAllAfterContentUpdate.lixcol_updated_at).toBe(fileAfterContentUpdate.lixcol_updated_at);
+    // Verify that file_all view also exposes lix_file_descriptor as schema key
+    expect(fileAllAfterContentUpdate.lixcol_schema_key).toBe("lix_file_descriptor");
+    // Additional verification that descriptor changes DO work
+    await lix.db
+        .updateTable("file")
+        .where("id", "=", "aggregate-info-test")
+        .set({
+        path: "/renamed-document.json", // This updates the descriptor
+    })
+        .execute();
+    const fileAfterPathUpdate = await lix.db
+        .selectFrom("file")
+        .where("id", "=", "aggregate-info-test")
+        .selectAll()
+        .executeTakeFirstOrThrow();
+    // Descriptor changes ARE reflected (this part works correctly)
+    expect(fileAfterPathUpdate.lixcol_change_id).not.toBe(initialChangeId);
+    // For string timestamps, use string comparison
+    expect(fileAfterPathUpdate.lixcol_updated_at > initialUpdatedAt).toBe(true);
+    // After path update, file_all should show the descriptor change
+    const fileAllAfterPathUpdate = await lix.db
+        .selectFrom("file_all")
+        .where("id", "=", "aggregate-info-test")
+        .selectAll()
+        .executeTakeFirstOrThrow();
+    expect(fileAllAfterPathUpdate.lixcol_change_id).toBe(fileAfterPathUpdate.lixcol_change_id);
+    expect(fileAllAfterPathUpdate.path).toBe("/renamed-document.json");
+    // Create a checkpoint to test file_history
+    const checkpoint = await createCheckpoint({ lix });
+    // Test file_history view also aggregates changes correctly
+    const fileHistoryAtCheckpoint = await lix.db
+        .selectFrom("file_history")
+        .where("id", "=", "aggregate-info-test")
+        .where("lixcol_root_commit_id", "=", checkpoint.id)
+        .where("lixcol_depth", "=", 0)
+        .selectAll()
+        .executeTakeFirstOrThrow();
+    // file_history should show the latest state including the path update
+    expect(fileHistoryAtCheckpoint.path).toBe("/renamed-document.json");
+    expect(fileHistoryAtCheckpoint.lixcol_change_id).toBe(fileAfterPathUpdate.lixcol_change_id);
+    // Verify that file_history view also exposes lix_file_descriptor as schema key
+    expect(fileHistoryAtCheckpoint.lixcol_schema_key).toBe("lix_file_descriptor");
+    // The materialized data should reflect the content updates
+    const historicalData = JSON.parse(new TextDecoder().decode(fileHistoryAtCheckpoint.data));
+    expect(historicalData).toEqual({
+        title: "Updated Title",
+        content: "Updated content",
+    });
+});
+test("files should be identical across versions when versions have the same commit", async () => {
+    const lix = await openLix({
+        providePlugins: [mockJsonPlugin],
+    });
+    const initialFile = new TextEncoder().encode(JSON.stringify({
+        items: [{ id: 1, name: "T-Shirt", price: 29.99, stock: 100 }],
+    }));
+    // Create a file in the main version
+    await lix.db
+        .insertInto("file")
+        .values({
+        path: "/products.json",
+        data: initialFile,
+    })
+        .execute();
+    // Verify the file exists in main version
+    const fileInMain = await lix.db
+        .selectFrom("file")
+        .where("path", "=", "/products.json")
+        .selectAll()
+        .executeTakeFirst();
+    expect(fileInMain?.data).toEqual(initialFile);
+    // Create a new version (should inherit from active version)
+    const newVersion = await createVersion({
+        lix,
+        name: "price-update",
+    });
+    // Switch to the new version
+    await switchVersion({ lix, to: newVersion });
+    // Check if the file is inherited in the new version
+    const fileInNewVersion = await lix.db
+        .selectFrom("file")
+        .where("path", "=", "/products.json")
+        .selectAll()
+        .executeTakeFirst();
+    expect(fileInNewVersion?.data).toEqual(initialFile);
+    // Update the file in the new version
+    await lix.db
+        .updateTable("file")
+        .set({
+        data: new TextEncoder().encode(JSON.stringify({
+            items: [
+                { id: 1, name: "T-Shirt", price: 34.99, stock: 100 }, // Price changed
+            ],
+        })),
+    })
+        .where("path", "=", "/products.json")
+        .execute();
+    // Verify the update worked
+    const updatedFile = await lix.db
+        .selectFrom("file")
+        .where("path", "=", "/products.json")
+        .selectAll()
+        .executeTakeFirstOrThrow();
+    const updatedData = JSON.parse(new TextDecoder().decode(updatedFile.data));
+    expect(updatedData.items[0].price).toBe(34.99);
+    // Query file_all to see both versions
+    const filesAcrossVersions = await lix.db
+        .selectFrom("file_all")
+        .where("path", "=", "/products.json")
+        .select(["lixcol_version_id", "data"])
+        .execute();
+    expect(filesAcrossVersions).toHaveLength(2);
+    // Get version info for verification
+    const versions = await lix.db
+        .selectFrom("version")
+        .select(["id", "name"])
+        .execute();
+    const mainVersionData = filesAcrossVersions.find((f) => {
+        const version = versions.find((v) => v.id === f.lixcol_version_id);
+        return version?.name === "main";
+    });
+    const newVersionData = filesAcrossVersions.find((f) => {
+        const version = versions.find((v) => v.id === f.lixcol_version_id);
+        return version?.name === "price-update";
+    });
+    expect(mainVersionData).toBeDefined();
+    expect(newVersionData).toBeDefined();
+    // Verify the prices are different
+    const mainData = JSON.parse(new TextDecoder().decode(mainVersionData.data));
+    const updatedVersionData = JSON.parse(new TextDecoder().decode(newVersionData.data));
+    expect(mainData.items[0].price).toBe(29.99); // Original price
+    expect(updatedVersionData.items[0].price).toBe(34.99); // Updated price
+});
 //# sourceMappingURL=schema.test.js.map