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

package/src/file/schema.test.ts

@@ -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";
 import type { LixPlugin } from "../plugin/lix-plugin.js";
 import type { LixFile } from "./schema.js";
@@ -32,7 +33,7 @@ test("insert, update, delete on the file view", async () => {
 		data: JSON.parse(new TextDecoder().decode(row.data)),
 	}));
 
-	expect(viewAfterInsert).toEqual([
+	expect(viewAfterInsert).toMatchObject([
 		{
 			id: "file0",
 			path: "/path/to/file.json",
@@ -66,7 +67,7 @@ test("insert, update, delete on the file view", async () => {
 		data: JSON.parse(new TextDecoder().decode(row.data)),
 	}));
 
-	expect(viewAfterUpdate).toEqual([
+	expect(viewAfterUpdate).toMatchObject([
 		{
 			id: "file0",
 			path: "/path/to/renamed_file.json",
@@ -165,7 +166,7 @@ test("file insert data materialization", async () => {
 		data: JSON.parse(new TextDecoder().decode(row.data)),
 	}));
 
-	expect(viewAfterInsert).toEqual([
+	expect(viewAfterInsert).toMatchObject([
 		{
 			id: "file0",
 			path: "/path/to/file.json",
@@ -256,6 +257,51 @@ test("invalid file paths should be rejected", async () => {
 	).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],
@@ -447,7 +493,7 @@ test("file_history provides access to historical file data", async () => {
 		.execute();
 
 	// 2. Create checkpoint
-	const checkpoint = await createCheckpoint({
+	const insertCheckpoint = await createCheckpoint({
 		lix,
 	});
 
@@ -461,6 +507,10 @@ test("file_history provides access to historical file data", async () => {
 		})
 		.execute();
 
+	const updateCheckpoint = await createCheckpoint({
+		lix,
+	});
+
 	// 4. Query file, assert that file equals update
 	const currentFile = await lix.db
 		.selectFrom("file")
@@ -474,32 +524,44 @@ test("file_history provides access to historical file data", async () => {
 	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);
+	expect(fileHistoryAtInsert).toHaveLength(1);
 
-	const historicalFile = historicalFiles[0]!;
-	const historicalFileData = JSON.parse(
-		new TextDecoder().decode(historicalFile.data)
+	const historicalFileAtInsert = fileHistoryAtInsert[0]!;
+	const historicalFileAtInsertData = JSON.parse(
+		new TextDecoder().decode(historicalFileAtInsert.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(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
@@ -522,6 +584,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
@@ -561,23 +633,19 @@ test("file and file_all views expose change_id for blame and diff functionality"
 		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 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 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 file view shows correct file info
 	expect(fileResult[0]?.id).toBe("change-id-test-file");
 	expect(fileResult[0]?.path).toBe("/test-change-id.json");
 
@@ -586,7 +654,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();
@@ -608,7 +675,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"])
@@ -988,3 +1055,592 @@ test("file data updates with untracked state", async () => {
 
 	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: Record<string, any>) => {
+		const lixcols: Record<string, any> = {};
+		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: Record<string, any>) => {
+		const filtered: Record<string, any> = {};
+		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
+});