@lix-js/sdk 0.5.1 → 0.6.0-preview.0

package/src/state/cache/update-state-cache.test.ts

@@ -1,1110 +0,0 @@
-import { expect, test, vi } from "vitest";
-import { openLix } from "../../lix/open-lix.js";
-import { updateStateCache } from "./update-state-cache.js";
-import * as cacheTableModule from "./create-schema-cache-table.js";
-import { getTimestamp } from "../../engine/functions/timestamp.js";
-import { sql, type Kysely } from "kysely";
-import type { LixInternalDatabaseSchema } from "../../database/schema.js";
-import type { MaterializedState } from "../vtable/generate-commit.js";
-import { getStateCacheTables, type InternalStateCacheRow } from "./schema.js";
-import type { LixSchemaDefinition } from "../../schema-definition/definition.js";
-
-const { schemaKeyToCacheTableName } = cacheTableModule;
-
-function simpleCacheSchema(key: string): LixSchemaDefinition {
-	return {
-		"x-lix-key": key,
-		"x-lix-version": "1.0",
-		type: "object",
-		additionalProperties: false,
-		properties: {
-			id: { type: "string" },
-		},
-		required: ["id"],
-	};
-}
-
-/**
- * Seeds the stored_schema table with cache definitions used during tests.
- */
-async function ensureCacheSchemas(
-	lix: { db: Kysely<LixInternalDatabaseSchema> } | { db: any },
-	schemaKeys: string[]
-): Promise<void> {
-	for (const key of schemaKeys) {
-		await lix.db
-			.insertInto("stored_schema")
-			.values({ value: simpleCacheSchema(key) })
-			.execute();
-	}
-}
-
-test("inserts into cache based on change", async () => {
-	const lix = await openLix({
-		keyValues: [
-			{
-				key: "lix_deterministic_mode",
-				value: { enabled: true },
-			},
-		],
-	});
-
-	await ensureCacheSchemas(lix, ["lix_test"]);
-
-	const currentTimestamp = await getTimestamp({ lix });
-
-	// Create a test change (materialized with inline version/commit)
-	const commitId = "test-commit-456";
-	const versionId = "global";
-	const testChange: MaterializedState = {
-		id: "test-change-123",
-		entity_id: "test-entity",
-		schema_key: "lix_test",
-		schema_version: "1.0",
-		file_id: "lix",
-		plugin_key: "test_plugin",
-		snapshot_content: JSON.stringify({ id: "test-entity", value: "test-data" }),
-		created_at: currentTimestamp,
-		lixcol_version_id: versionId,
-		lixcol_commit_id: commitId,
-	};
-
-	// Call updateStateCacheV2
-	updateStateCache({
-		engine: lix.engine!,
-		changes: [testChange],
-	});
-
-	// Verify cache entry was created/updated
-	const cacheEntries = await (
-		lix.db as unknown as Kysely<LixInternalDatabaseSchema>
-	)
-		.selectFrom("lix_internal_state_vtable")
-		.where("_pk", "like", "C%")
-		.selectAll()
-		.select(sql`json(snapshot_content)`.as("snapshot_content"))
-		.where("entity_id", "=", testChange.entity_id)
-		.where("schema_key", "=", testChange.schema_key)
-		.where("file_id", "=", testChange.file_id)
-		.where("version_id", "=", versionId)
-		.execute();
-
-	expect(cacheEntries).toHaveLength(1);
-
-	const cacheEntry = cacheEntries[0]!;
-	expect(cacheEntry).toMatchObject({
-		entity_id: testChange.entity_id,
-		schema_key: testChange.schema_key,
-		file_id: testChange.file_id,
-		version_id: versionId,
-		plugin_key: testChange.plugin_key,
-		snapshot_content: JSON.parse(testChange.snapshot_content as any),
-		schema_version: testChange.schema_version,
-		created_at: currentTimestamp,
-		updated_at: currentTimestamp,
-		inherited_from_version_id: null,
-		change_id: testChange.id,
-		commit_id: commitId,
-	});
-});
-
-test("upserts cache entry on conflict", async () => {
-	const lix = await openLix({
-		keyValues: [
-			{
-				key: "lix_deterministic_mode",
-				value: { enabled: true },
-				lixcol_version_id: "global",
-			},
-		],
-	});
-
-	await ensureCacheSchemas(lix, ["lix_test"]);
-
-	const initialTimestamp = await getTimestamp({ lix });
-
-	// Create initial test change (materialized)
-	const versionId = "global";
-	const initialCommitId = "initial-commit-123";
-	const initialChange: MaterializedState = {
-		id: "test-change-initial",
-		entity_id: "test-entity-upsert",
-		schema_key: "lix_test",
-		schema_version: "1.0",
-		file_id: "lix",
-		plugin_key: "test_plugin",
-		snapshot_content: JSON.stringify({
-			id: "test-entity-upsert",
-			value: "initial-data",
-		}),
-		created_at: initialTimestamp,
-		lixcol_version_id: versionId,
-		lixcol_commit_id: initialCommitId,
-	};
-
-	// First insert
-	updateStateCache({
-		engine: lix.engine!,
-		changes: [initialChange],
-	});
-
-	// Verify initial entry exists
-	const intDb = lix.db as unknown as Kysely<LixInternalDatabaseSchema>;
-	const initialEntries = await intDb
-		.selectFrom("lix_internal_state_vtable")
-		.where("_pk", "like", "C%")
-		.selectAll()
-		.select(sql`json(snapshot_content)`.as("snapshot_content"))
-		.where("entity_id", "=", initialChange.entity_id)
-		.where("schema_key", "=", initialChange.schema_key)
-		.where("file_id", "=", initialChange.file_id)
-		.where("version_id", "=", versionId)
-		.execute();
-
-	expect(initialEntries).toHaveLength(1);
-	expect(initialEntries[0]!.commit_id).toBe(initialCommitId);
-	expect(initialEntries[0]!.snapshot_content).toEqual(
-		JSON.parse(initialChange.snapshot_content as any)
-	);
-
-	// Now update with new data (same entity, schema, file, version - should trigger upsert)
-	const updateTimestamp = await getTimestamp({ lix });
-	const updatedCommitId = "updated-commit-456";
-	const updatedChange: MaterializedState = {
-		id: "test-change-updated",
-		entity_id: "test-entity-upsert", // Same entity
-		schema_key: "lix_test", // Same schema
-		schema_version: "1.1", // Different version
-		file_id: "lix", // Same file
-		plugin_key: "updated_plugin", // Different plugin
-		snapshot_content: JSON.stringify({
-			id: "test-entity-upsert",
-			value: "updated-data",
-		}), // Different content
-		created_at: updateTimestamp,
-		lixcol_version_id: versionId,
-		lixcol_commit_id: updatedCommitId,
-	};
-
-	// Second call should trigger onConflict upsert
-	updateStateCache({
-		engine: lix.engine!,
-		changes: [updatedChange],
-	});
-
-	// Verify only one entry exists (upserted, not inserted as new)
-	const finalEntries = await intDb
-		.selectFrom("lix_internal_state_vtable")
-		.where("_pk", "like", "C%")
-		.selectAll()
-		.select(sql`json(snapshot_content)`.as("snapshot_content"))
-		.where("entity_id", "=", updatedChange.entity_id)
-		.where("schema_key", "=", updatedChange.schema_key)
-		.where("file_id", "=", updatedChange.file_id)
-		.where("version_id", "=", versionId)
-		.execute();
-
-	expect(finalEntries).toHaveLength(1);
-
-	const upsertedEntry = finalEntries[0]!;
-	expect(upsertedEntry).toMatchObject({
-		entity_id: updatedChange.entity_id,
-		schema_key: updatedChange.schema_key,
-		file_id: updatedChange.file_id,
-		version_id: versionId,
-		plugin_key: updatedChange.plugin_key, // Should be updated
-		snapshot_content: JSON.parse(updatedChange.snapshot_content as any), // Should be updated
-		schema_version: updatedChange.schema_version, // Should be updated
-		created_at: initialTimestamp, // Should remain from initial insert (v2 now matches v1 behavior)
-		updated_at: updateTimestamp, // Should be updated
-		inherited_from_version_id: null,
-		change_id: updatedChange.id, // Should be updated
-		commit_id: updatedCommitId, // Should be updated
-	} satisfies Partial<InternalStateCacheRow>);
-});
-
-test("handles inheritance chain deletions with tombstones", async () => {
-	const lix = await openLix({
-		keyValues: [
-			{
-				key: "lix_deterministic_mode",
-				value: { enabled: true },
-			},
-		],
-	});
-
-	await ensureCacheSchemas(lix, ["lix_test"]);
-
-	// Define test version ids (no actual version rows needed for cache tests)
-	const parentVersion = "parent-version";
-	const childVersion = "child-version";
-	const subchildVersion = "subchild-version";
-
-	const baseTimestamp = await getTimestamp({ lix });
-	const testEntity = "inherited-entity";
-
-	// 1. Create entity in parent version
-	const createChange: MaterializedState = {
-		id: "create-change-123",
-		entity_id: testEntity,
-		schema_key: "lix_test",
-		schema_version: "1.0",
-		file_id: "lix",
-		plugin_key: "test_plugin",
-		snapshot_content: JSON.stringify({
-			id: testEntity,
-			value: "parent-data",
-		}),
-		created_at: baseTimestamp,
-		lixcol_version_id: parentVersion,
-		lixcol_commit_id: "parent-commit-123",
-	};
-
-	updateStateCache({
-		engine: lix.engine!,
-		changes: [createChange],
-	});
-
-	const intDb = lix.db as unknown as Kysely<LixInternalDatabaseSchema>;
-
-	// 2. Verify entity exists in parent cache
-	const parentCache = await intDb
-		.selectFrom("lix_internal_state_vtable")
-		.where("_pk", "like", "C%")
-		.selectAll()
-		.select(sql`json(snapshot_content)`.as("snapshot_content"))
-		.where("entity_id", "=", testEntity)
-		.where("version_id", "=", parentVersion)
-		.execute();
-
-	expect(parentCache).toHaveLength(1);
-	expect(parentCache[0]?.snapshot_content).toEqual({
-		id: testEntity,
-		value: "parent-data",
-	});
-
-	// 3. Create tombstone in child version (deleting inherited entity)
-	const deleteTimestamp = await getTimestamp({ lix });
-	const deleteChange: MaterializedState = {
-		id: "delete-change-456",
-		entity_id: testEntity,
-		schema_key: "lix_test",
-		schema_version: "1.0",
-		file_id: "lix",
-		plugin_key: "test_plugin",
-		snapshot_content: null, // Tombstone
-		created_at: deleteTimestamp,
-		lixcol_version_id: childVersion,
-		lixcol_commit_id: "child-commit-456",
-	};
-
-	updateStateCache({
-		engine: lix.engine!,
-		changes: [deleteChange],
-	});
-
-	// 4. Verify parent still has the entity in cache
-	const parentCacheAfterDelete = await intDb
-		.selectFrom("lix_internal_state_vtable")
-		.where("_pk", "like", "C%")
-		.selectAll()
-		.select(sql`json(snapshot_content)`.as("snapshot_content"))
-		.where("entity_id", "=", testEntity)
-		.where("version_id", "=", parentVersion)
-		.execute();
-
-	expect(parentCacheAfterDelete).toHaveLength(1);
-	expect(parentCacheAfterDelete[0]?.snapshot_content).toEqual({
-		id: testEntity,
-		value: "parent-data",
-	});
-
-	// 5. Verify child version HAS a tombstone cache entry
-	const childCacheAfterDelete = await intDb
-		.selectFrom("lix_internal_state_vtable")
-		.where("_pk", "like", "C%")
-		.selectAll()
-		.select(sql`json(snapshot_content)`.as("snapshot_content"))
-		.where("entity_id", "=", testEntity)
-		.where("version_id", "=", childVersion)
-		.execute();
-
-	expect(childCacheAfterDelete).toHaveLength(1);
-	expect(childCacheAfterDelete[0]?.snapshot_content).toBeNull();
-	expect(childCacheAfterDelete[0]?.change_id).toBe("delete-change-456");
-
-	// 6. Verify subchild version has NO direct cache entry (inherits deletion from child)
-	const subchildCacheAfterDelete = await intDb
-		.selectFrom("lix_internal_state_vtable")
-		.where("_pk", "like", "C%")
-		.selectAll()
-		.select(sql`json(snapshot_content)`.as("snapshot_content"))
-		.where("entity_id", "=", testEntity)
-		.where("version_id", "=", subchildVersion)
-		.execute();
-
-	expect(subchildCacheAfterDelete).toHaveLength(0);
-
-	// 7. Verify cache entries are correct (tombstones filtered out)
-	const parentStateAll = await intDb
-		.selectFrom("lix_internal_state_vtable")
-		.where("_pk", "like", "C%")
-		.selectAll()
-		.select(sql`json(snapshot_content)`.as("snapshot_content"))
-		.where("entity_id", "=", testEntity)
-		.where("version_id", "=", parentVersion)
-		.where("snapshot_content", "is not", null)
-		.execute();
-
-	const childStateAll = await intDb
-		.selectFrom("lix_internal_state_vtable")
-		.where("_pk", "like", "C%")
-		.selectAll()
-		.select(sql`json(snapshot_content)`.as("snapshot_content"))
-		.where("entity_id", "=", testEntity)
-		.where("version_id", "=", childVersion)
-		.where("snapshot_content", "is not", null)
-		.execute();
-
-	const subchildStateAll = await intDb
-		.selectFrom("lix_internal_state_vtable")
-		.where("_pk", "like", "C%")
-		.selectAll()
-		.select(sql`json(snapshot_content)`.as("snapshot_content"))
-		.where("entity_id", "=", testEntity)
-		.where("version_id", "=", subchildVersion)
-		.where("snapshot_content", "is not", null)
-		.execute();
-
-	// Parent should show the entity
-	expect(parentStateAll).toHaveLength(1);
-	expect(parentStateAll[0]?.snapshot_content).toEqual({
-		id: testEntity,
-		value: "parent-data",
-	});
-
-	// Child should show NO entity (tombstone filtered out)
-	expect(childStateAll).toHaveLength(0);
-
-	// Subchild should show NO entity (inherits deletion from child)
-	expect(subchildStateAll).toHaveLength(0);
-});
-
-test("deleting a parent cache row removes inherited copies", async () => {
-	const lix = await openLix({
-		keyValues: [
-			{
-				key: "lix_deterministic_mode",
-				value: { enabled: true },
-			},
-		],
-	});
-
-	await ensureCacheSchemas(lix, ["lix_test"]);
-
-	const parentVersion = "parent-version";
-	const childVersion = "child-version";
-	const baseTimestamp = await getTimestamp({ lix });
-	const parentCommitId = "parent-commit";
-	const deleteCommitId = "delete-commit";
-	const testEntity = "parent-entity";
-
-	const parentChange: MaterializedState = {
-		id: "change-parent",
-		entity_id: testEntity,
-		schema_key: "lix_test",
-		schema_version: "1.0",
-		file_id: "lix",
-		plugin_key: "test_plugin",
-		snapshot_content: JSON.stringify({
-			id: testEntity,
-			value: "parent-data",
-		}),
-		created_at: baseTimestamp,
-		lixcol_version_id: parentVersion,
-		lixcol_commit_id: parentCommitId,
-	};
-
-	updateStateCache({
-		engine: lix.engine!,
-		changes: [parentChange],
-	});
-
-	const tableName = schemaKeyToCacheTableName("lix_test");
-
-	// Manually insert a cached inherited copy for the child version to mirror version copy logic.
-	lix.engine!.executeSync({
-		sql: `INSERT INTO ${tableName} (
-			entity_id,
-			schema_key,
-			file_id,
-			version_id,
-			plugin_key,
-			snapshot_content,
-			schema_version,
-			created_at,
-			updated_at,
-			inherited_from_version_id,
-			is_tombstone,
-			change_id,
-			commit_id
-		) VALUES (?, ?, ?, ?, ?, jsonb(?), ?, ?, ?, ?, 0, ?, ?);`,
-		parameters: [
-			testEntity,
-			"lix_test",
-			"lix",
-			childVersion,
-			"test_plugin",
-			parentChange.snapshot_content,
-			"1.0",
-			baseTimestamp,
-			baseTimestamp,
-			parentVersion,
-			"child-inherit-change",
-			parentCommitId,
-		],
-	});
-
-	// Ensure parent row exists and child row points at parent.
-	const readCacheRows = () => {
-		const result = lix.engine!.executeSync({
-			sql: `SELECT entity_id, version_id, inherited_from_version_id, is_tombstone, change_id, commit_id, json(snapshot_content) AS snapshot_content
-				FROM ${tableName}
-				WHERE entity_id = ?
-				ORDER BY version_id`,
-			parameters: [testEntity],
-		}).rows as Array<{
-			entity_id: string;
-			version_id: string;
-			inherited_from_version_id: string | null;
-			is_tombstone: number;
-			change_id: string | null;
-			commit_id: string | null;
-			snapshot_content: string | null;
-		}>;
-
-		return result.map((row) => ({
-			...row,
-			snapshot_content: row.snapshot_content
-				? (JSON.parse(row.snapshot_content) as Record<string, unknown>)
-				: null,
-		}));
-	};
-
-	const initialRows = readCacheRows();
-	expect(initialRows).toHaveLength(2);
-	const parentRowBeforeDelete = initialRows.find(
-		(row) => row.version_id === parentVersion
-	);
-	const childRowBeforeDelete = initialRows.find(
-		(row) => row.version_id === childVersion
-	);
-
-	expect(parentRowBeforeDelete).toMatchObject({
-		inherited_from_version_id: null,
-		is_tombstone: 0,
-		snapshot_content: { id: testEntity, value: "parent-data" },
-	});
-	expect(childRowBeforeDelete).toMatchObject({
-		inherited_from_version_id: parentVersion,
-		is_tombstone: 0,
-		snapshot_content: { id: testEntity, value: "parent-data" },
-	});
-
-	// Delete the parent version entity via cache update.
-	const deleteChange: MaterializedState = {
-		id: "change-delete",
-		entity_id: testEntity,
-		schema_key: "lix_test",
-		schema_version: "1.0",
-		file_id: "lix",
-		plugin_key: "test_plugin",
-		snapshot_content: null,
-		created_at: baseTimestamp,
-		lixcol_version_id: parentVersion,
-		lixcol_commit_id: deleteCommitId,
-	};
-
-	updateStateCache({
-		engine: lix.engine!,
-		changes: [deleteChange],
-	});
-
-	const rowsAfterDelete = readCacheRows();
-
-	expect(rowsAfterDelete).toHaveLength(1);
-	const parentRowAfterDelete = rowsAfterDelete[0]!;
-	expect(parentRowAfterDelete).toMatchObject({
-		version_id: parentVersion,
-		inherited_from_version_id: null,
-		is_tombstone: 1,
-		snapshot_content: null,
-		change_id: "change-delete",
-		commit_id: deleteCommitId,
-	});
-});
-
-test("reuses known cache tables without recreating them", async () => {
-	const lix = await openLix({
-		keyValues: [
-			{
-				key: "lix_deterministic_mode",
-				value: { enabled: true },
-			},
-		],
-	});
-
-	await ensureCacheSchemas(lix, ["lix_test"]);
-
-	const createSpy = vi.spyOn(cacheTableModule, "createSchemaCacheTable");
-
-	try {
-		const firstTimestamp = await getTimestamp({ lix });
-		const firstChange: MaterializedState = {
-			id: "cache-table-create",
-			entity_id: "cache-table-entity",
-			schema_key: "lix_test",
-			schema_version: "1.0",
-			file_id: "lix",
-			plugin_key: "test_plugin",
-			snapshot_content: JSON.stringify({
-				id: "cache-table-entity",
-			}),
-			created_at: firstTimestamp,
-			lixcol_version_id: "global",
-			lixcol_commit_id: "commit-initial",
-		};
-
-		updateStateCache({
-			engine: lix.engine!,
-			changes: [firstChange],
-		});
-
-		expect(createSpy).toHaveBeenCalledTimes(1);
-		createSpy.mockClear();
-
-		const secondTimestamp = await getTimestamp({ lix });
-		const secondChange: MaterializedState = {
-			id: "cache-table-upsert",
-			entity_id: "cache-table-entity",
-			schema_key: "lix_test",
-			schema_version: "1.0",
-			file_id: "lix",
-			plugin_key: "test_plugin",
-			snapshot_content: JSON.stringify({
-				id: "cache-table-entity",
-				value: "updated",
-			}),
-			created_at: secondTimestamp,
-			lixcol_version_id: "global",
-			lixcol_commit_id: "commit-updated",
-		};
-
-		updateStateCache({
-			engine: lix.engine!,
-			changes: [secondChange],
-		});
-
-		expect(createSpy).not.toHaveBeenCalled();
-	} finally {
-		createSpy.mockRestore();
-	}
-});
-
-test("reuses cached tables for schema keys with special characters", async () => {
-	const schemaKey = "lix-test-cache";
-	const lix = await openLix({
-		keyValues: [
-			{
-				key: "lix_deterministic_mode",
-				value: { enabled: true },
-			},
-		],
-	});
-
-	await ensureCacheSchemas(lix, [schemaKey]);
-
-	const tableCache = getStateCacheTables({ engine: lix.engine! });
-	const originalSanitize = cacheTableModule.schemaKeyToCacheTableName;
-	const createSpy = vi.spyOn(cacheTableModule, "createSchemaCacheTable");
-
-	const existingTableName = cacheTableModule.createSchemaCacheTable({
-		engine: lix.engine!,
-		schema: simpleCacheSchema(schemaKey),
-	});
-	tableCache.add(existingTableName);
-
-	createSpy.mockClear();
-
-	const sanitizeSpy = vi
-		.spyOn(cacheTableModule, "schemaKeyToCacheTableName")
-		.mockImplementation((key: string) => `${originalSanitize(key)}__shadow`);
-
-	try {
-		const timestamp = await getTimestamp({ lix });
-		const change: MaterializedState = {
-			id: "cache-reuse-hyphen",
-			entity_id: "cache-entity",
-			schema_key: schemaKey,
-			schema_version: "1.0",
-			file_id: "lix",
-			plugin_key: "test_plugin",
-			snapshot_content: JSON.stringify({
-				id: "cache-entity",
-			}),
-			created_at: timestamp,
-			lixcol_version_id: "global",
-			lixcol_commit_id: "commit-cache-reuse",
-		};
-
-		updateStateCache({
-			engine: lix.engine!,
-			changes: [change],
-		});
-
-		const schemaSpecificCalls = createSpy.mock.calls.filter(
-			([callArgs]) =>
-				callArgs?.schema && callArgs.schema["x-lix-key"] === schemaKey
-		);
-		expect(schemaSpecificCalls).toHaveLength(0);
-	} finally {
-		sanitizeSpy.mockRestore();
-		createSpy.mockRestore();
-	}
-});
-
-test("handles duplicate entity updates - last change wins", async () => {
-	const lix = await openLix({
-		keyValues: [
-			{
-				key: "lix_deterministic_mode",
-				value: { enabled: true },
-			},
-		],
-	});
-
-	await ensureCacheSchemas(lix, ["test_schema"]);
-
-	// Create test changes for the same entity
-	const change1: MaterializedState = {
-		id: "change-1",
-		entity_id: "test-entity",
-		schema_key: "test_schema",
-		file_id: "test-file",
-		plugin_key: "test-plugin",
-		snapshot_content: JSON.stringify({ value: "first" }),
-		schema_version: "1.0",
-		created_at: "2024-01-01T00:00:00Z",
-		lixcol_version_id: "version-1",
-		lixcol_commit_id: "commit-1",
-	};
-
-	const change2: MaterializedState = {
-		id: "change-2",
-		entity_id: "test-entity", // Same entity
-		schema_key: "test_schema",
-		file_id: "test-file",
-		plugin_key: "test-plugin",
-		snapshot_content: JSON.stringify({ value: "second" }),
-		schema_version: "1.0",
-		created_at: "2024-01-01T00:01:00Z", // Later timestamp
-		lixcol_version_id: "version-1",
-		lixcol_commit_id: "commit-2",
-	};
-
-	// Apply first change
-	updateStateCache({
-		engine: lix.engine!,
-		changes: [change1],
-	});
-
-	// Apply second change (should overwrite first)
-	updateStateCache({
-		engine: lix.engine!,
-		changes: [change2],
-	});
-
-	// Query the cache to verify only the latest change is present
-	const result = await (lix.db as unknown as Kysely<LixInternalDatabaseSchema>)
-		.selectFrom("lix_internal_state_vtable")
-		.where("_pk", "like", "C%")
-		.selectAll()
-		.select(sql`json(snapshot_content)`.as("snapshot_content"))
-		.where("entity_id", "=", "test-entity")
-		.where("file_id", "=", "test-file")
-		.where("version_id", "=", "version-1")
-		.execute();
-
-	// Should have exactly one row (latest change wins)
-	expect(result).toHaveLength(1);
-
-	// Should be the second change
-	expect(result[0]!.change_id).toBe("change-2");
-	expect(result[0]!.snapshot_content).toEqual({ value: "second" });
-	expect(result[0]!.created_at).toBe("2024-01-01T00:00:00Z"); // Should preserve original created_at
-	expect(result[0]!.updated_at).toBe("2024-01-01T00:01:00Z"); // Should update updated_at
-});
-
-test("handles batch updates with duplicates - last in batch wins", async () => {
-	const lix = await openLix({
-		keyValues: [
-			{
-				key: "lix_deterministic_mode",
-				value: { enabled: true },
-			},
-		],
-	});
-
-	await ensureCacheSchemas(lix, ["test_schema"]);
-
-	// Create multiple changes for the same entity in a single batch
-	const changes: MaterializedState[] = [
-		{
-			id: "change-1",
-			entity_id: "test-entity",
-			schema_key: "test_schema",
-			file_id: "test-file",
-			plugin_key: "test-plugin",
-			snapshot_content: JSON.stringify({ value: "first" }),
-			schema_version: "1.0",
-			created_at: "2024-01-01T00:00:00Z",
-			lixcol_version_id: "version-1",
-			lixcol_commit_id: "commit-1",
-		},
-		{
-			id: "change-2",
-			entity_id: "test-entity", // Same entity
-			schema_key: "test_schema",
-			file_id: "test-file",
-			plugin_key: "test-plugin",
-			snapshot_content: JSON.stringify({ value: "second" }),
-			schema_version: "1.0",
-			created_at: "2024-01-01T00:01:00Z",
-			lixcol_version_id: "version-1",
-			lixcol_commit_id: "commit-1",
-		},
-		{
-			id: "change-3",
-			entity_id: "test-entity", // Same entity again
-			schema_key: "test_schema",
-			file_id: "test-file",
-			plugin_key: "test-plugin",
-			snapshot_content: JSON.stringify({ value: "third" }),
-			schema_version: "1.0",
-			created_at: "2024-01-01T00:02:00Z",
-			lixcol_version_id: "version-1",
-			lixcol_commit_id: "commit-1",
-		},
-	];
-
-	// Apply all changes in a single batch
-	updateStateCache({
-		engine: lix.engine!,
-		changes,
-	});
-
-	// Query the cache to verify only the latest change is present
-	const result = await (lix.db as unknown as Kysely<LixInternalDatabaseSchema>)
-		.selectFrom("lix_internal_state_vtable")
-		.where("_pk", "like", "C%")
-		.selectAll()
-		.select(sql`json(snapshot_content)`.as("snapshot_content"))
-		.where("entity_id", "=", "test-entity")
-		.where("file_id", "=", "test-file")
-		.where("version_id", "=", "version-1")
-		.execute();
-
-	// Should have exactly one row (last change in batch wins)
-	expect(result).toHaveLength(1);
-
-	// Should be the third change (last in batch)
-	expect(result[0]!.change_id).toBe("change-3");
-	expect(result[0]!.snapshot_content).toEqual({ value: "third" });
-	expect(result[0]!.created_at).toBe("2024-01-01T00:00:00Z"); // Should preserve original created_at from first
-	expect(result[0]!.updated_at).toBe("2024-01-01T00:02:00Z"); // Should use updated_at from last
-});
-
-test("derived edge cache rows reference the commit change id", async () => {
-	const lix = await openLix({
-		keyValues: [{ key: "lix_deterministic_mode", value: { enabled: true } }],
-	});
-
-	const now = await getTimestamp({ lix });
-	const parentId = "edge-parent";
-	const childId = "edge-child";
-	const changeSetId = "edge-cs";
-	const commitChangeId = "edge-commit-change";
-
-	// Insert real commit change
-	await lix.db
-		.insertInto("change")
-		.values({
-			id: commitChangeId,
-			entity_id: childId,
-			schema_key: "lix_commit",
-			schema_version: "1.0",
-			file_id: "lix",
-			plugin_key: "lix_sdk",
-			snapshot_content: {
-				id: childId,
-				change_set_id: changeSetId,
-				parent_commit_ids: [parentId],
-			},
-			created_at: now,
-		})
-		.execute();
-
-	// Push to cache so edges are derived
-	updateStateCache({
-		engine: lix.engine!,
-		version_id: "global",
-		commit_id: childId,
-		changes: [
-			{
-				id: commitChangeId,
-				entity_id: childId,
-				schema_key: "lix_commit",
-				schema_version: "1.0",
-				file_id: "lix",
-				plugin_key: "lix_sdk",
-				snapshot_content: JSON.stringify({
-					id: childId,
-					change_set_id: changeSetId,
-					parent_commit_ids: [parentId],
-				}),
-				created_at: now,
-			},
-		],
-	});
-
-	const joined = await lix.db
-		.selectFrom("commit_edge_by_version")
-		.innerJoin("change", "change.id", "commit_edge_by_version.lixcol_change_id")
-		.where("commit_edge_by_version.lixcol_version_id", "=", "global")
-		.where("commit_edge_by_version.parent_id", "=", parentId)
-		.where("commit_edge_by_version.child_id", "=", childId)
-		.select([
-			"commit_edge_by_version.parent_id as parent_id",
-			"commit_edge_by_version.child_id as child_id",
-			"commit_edge_by_version.lixcol_change_id as change_id",
-			"change.entity_id as change_entity_id",
-			"change.snapshot_content as snap",
-		])
-		.executeTakeFirstOrThrow();
-
-	expect(joined.parent_id).toBe(parentId);
-	expect(joined.child_id).toBe(childId);
-	expect(joined.change_id).toBe(commitChangeId);
-	expect(joined.change_entity_id).toBe(childId);
-	expect(joined.snap).toMatchObject({
-		id: childId,
-		change_set_id: changeSetId,
-		parent_commit_ids: [parentId],
-	});
-});
-
-test("commit caching materializes its change set in cache", async () => {
-	const lix = await openLix({
-		keyValues: [
-			{
-				key: "lix_deterministic_mode",
-				value: { enabled: true, bootstrap: true },
-			},
-		],
-	});
-
-	const now = await getTimestamp({ lix });
-	const parentId = "cs-parent";
-	const childId = "cs-child";
-	const changeSetId = "cs-materialized";
-	const commitChangeId = "cs-commit-change";
-
-	// Insert real commit change
-	await lix.db
-		.insertInto("change")
-		.values({
-			id: commitChangeId,
-			entity_id: childId,
-			schema_key: "lix_commit",
-			schema_version: "1.0",
-			file_id: "lix",
-			plugin_key: "lix_sdk",
-			snapshot_content: {
-				id: childId,
-				change_set_id: changeSetId,
-				parent_commit_ids: [parentId],
-			},
-			created_at: now,
-		})
-		.execute();
-
-	// Push to cache so commit edges + change set are materialized
-	updateStateCache({
-		engine: lix.engine!,
-		version_id: "global",
-		commit_id: childId,
-		changes: [
-			{
-				id: commitChangeId,
-				entity_id: childId,
-				schema_key: "lix_commit",
-				schema_version: "1.0",
-				file_id: "lix",
-				plugin_key: "lix_sdk",
-				snapshot_content: JSON.stringify({
-					id: childId,
-					change_set_id: changeSetId,
-					parent_commit_ids: [parentId],
-				}),
-				created_at: now,
-			},
-		],
-	});
-
-	// Verify the change set appears via the cache in change_set_by_version
-	const cs = await lix.db
-		.selectFrom("change_set_by_version")
-		.where("id", "=", changeSetId)
-		.where("lixcol_version_id", "=", "global")
-		.selectAll()
-		.executeTakeFirstOrThrow();
-
-	expect(cs).toMatchObject({ id: changeSetId, lixcol_version_id: "global" });
-});
-
-// Edges caching from commit.parent_commit_ids
-test("caches commit edges from commit.parent_commit_ids", async () => {
-	const lix = await openLix({
-		keyValues: [
-			{
-				key: "lix_deterministic_mode",
-				value: { enabled: true },
-				lixcol_untracked: true,
-				lixcol_version_id: "global",
-			},
-		],
-	});
-
-	const now = await getTimestamp({ lix });
-	const parentId = "commit-parent";
-	const childId = "commit-child";
-	const changeSetId = "cs-merge";
-
-	updateStateCache({
-		engine: lix.engine!,
-		version_id: "global",
-		commit_id: "global-commit-edges-1",
-		changes: [
-			{
-				id: "chg-commit-with-parents",
-				entity_id: childId,
-				schema_key: "lix_commit",
-				schema_version: "1.0",
-				file_id: "lix",
-				plugin_key: "lix_sdk",
-				snapshot_content: JSON.stringify({
-					id: childId,
-					change_set_id: changeSetId,
-					parent_commit_ids: [parentId],
-				}),
-				created_at: now,
-			},
-		],
-	});
-
-	const edges = await lix.db
-		.selectFrom("commit_edge_by_version")
-		.where("lixcol_version_id", "=", "global")
-		.where("parent_id", "=", parentId)
-		.where("child_id", "=", childId)
-		.selectAll()
-		.execute();
-
-	expect(edges).toHaveLength(1);
-	expect(edges[0]).toMatchObject({
-		parent_id: parentId,
-		child_id: childId,
-		lixcol_version_id: "global",
-	});
-});
-
-test("clears cached edges when parent_commit_ids becomes empty", async () => {
-	const lix = await openLix({
-		keyValues: [
-			{
-				key: "lix_deterministic_mode",
-				value: { enabled: true },
-				lixcol_untracked: true,
-				lixcol_version_id: "global",
-			},
-		],
-	});
-
-	const now = await getTimestamp({ lix });
-	const parentId = "commit-parent-2";
-	const childId = "commit-child-2";
-	const changeSetId = "cs-merge-2";
-
-	// Seed with a commit which has a parent
-	updateStateCache({
-		engine: lix.engine!,
-		version_id: "global",
-		commit_id: "global-commit-edges-2",
-		changes: [
-			{
-				id: "chg-commit-with-parents-2",
-				entity_id: childId,
-				schema_key: "lix_commit",
-				schema_version: "1.0",
-				file_id: "lix",
-				plugin_key: "lix_sdk",
-				snapshot_content: JSON.stringify({
-					id: childId,
-					change_set_id: changeSetId,
-					parent_commit_ids: [parentId],
-				}),
-				created_at: now,
-			},
-		],
-	});
-
-	// Sanity check exists
-	const before = await lix.db
-		.selectFrom("commit_edge_by_version")
-		.where("lixcol_version_id", "=", "global")
-		.where("child_id", "=", childId)
-		.selectAll()
-		.execute();
-	expect(before.length).toBeGreaterThan(0);
-
-	// Update commit with empty parents
-	updateStateCache({
-		engine: lix.engine!,
-		version_id: "global",
-		commit_id: "global-commit-edges-3",
-		changes: [
-			{
-				id: "chg-commit-without-parents-2",
-				entity_id: childId,
-				schema_key: "lix_commit",
-				schema_version: "1.0",
-				file_id: "lix",
-				plugin_key: "lix_sdk",
-				snapshot_content: JSON.stringify({
-					id: childId,
-					change_set_id: changeSetId,
-					parent_commit_ids: [],
-				}),
-				created_at: now,
-			},
-		],
-	});
-
-	const after = await lix.db
-		.selectFrom("commit_edge_by_version")
-		.where("lixcol_version_id", "=", "global")
-		.where("child_id", "=", childId)
-		.selectAll()
-		.execute();
-	expect(after).toEqual([]);
-});