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

package/src/state/commit.test.ts

@@ -1,1402 +0,0 @@
-import { test, expect, describe } from "vitest";
-import type { Kysely } from "kysely";
-import type { LixInternalDatabaseSchema } from "../database/schema.js";
-import type { LixCommitEdge } from "../commit/schema.js";
-import { insertTransactionState } from "./insert-transaction-state.js";
-import { commit } from "./commit.js";
-import { openLix } from "../lix/open-lix.js";
-import { nanoId, uuidV7 } from "../deterministic/index.js";
-import { switchAccount } from "../account/switch-account.js";
-import { commitIsAncestorOf } from "../query-filter/commit-is-ancestor-of.js";
-
-test("commit should include meta changes (changeset, edges, version updates) in the change table", async () => {
-	const lix = await openLix({
-		account: { id: "test-account", name: "Test User" },
-		keyValues: [{ key: "lix_deterministic_mode", value: { enabled: true } }],
-	});
-	const db = lix.db as unknown as Kysely<LixInternalDatabaseSchema>;
-
-	// 1. Get the active version (should be 'global')
-	const activeVersions = await db
-		.selectFrom("active_version")
-		.selectAll()
-		.execute();
-
-	expect(activeVersions.length).toBe(1);
-	const activeVersion = activeVersions[0];
-	expect(activeVersion).toBeDefined();
-	const versionId = activeVersion!.version_id;
-
-	// Get the previous change set for this version
-	const versionBefore = await db
-		.selectFrom("version")
-		.where("id", "=", versionId)
-		.selectAll()
-		.executeTakeFirstOrThrow();
-	const previousCommitId = versionBefore.commit_id;
-
-	// 2. Insert transaction state
-	insertTransactionState({
-		lix: { sqlite: lix.sqlite, db },
-		data: {
-			entity_id: "test-entity-1",
-			schema_key: "lix_key_value",
-			file_id: "lix",
-			plugin_key: "lix_own_entity",
-			snapshot_content: JSON.stringify({
-				key: "test-key-1",
-				value: "test-value-1",
-			}),
-			schema_version: "1.0",
-			version_id: versionId,
-			untracked: false,
-		},
-	});
-
-	insertTransactionState({
-		lix: { sqlite: lix.sqlite, db },
-		data: {
-			entity_id: "test-entity-2",
-			schema_key: "lix_key_value",
-			file_id: "lix",
-			plugin_key: "lix_own_entity",
-			snapshot_content: JSON.stringify({
-				key: "test-key-2",
-				value: "test-value-2",
-			}),
-			schema_version: "1.0",
-			version_id: versionId,
-			untracked: false,
-		},
-	});
-
-	// 3. Commit
-	commit({ lix });
-
-	// 4. Expect the commit of the active version to have one edge to the previous one
-	const versionAfter = await db
-		.selectFrom("version")
-		.where("id", "=", versionId)
-		.selectAll()
-		.executeTakeFirstOrThrow();
-
-	const newCommitId = versionAfter.commit_id;
-	expect(newCommitId).not.toBe(previousCommitId);
-
-	// Check edges - should have exactly one edge from previous to new
-	const edges = await db
-		.selectFrom("commit_edge")
-		.where("parent_id", "=", previousCommitId)
-		.where("child_id", "=", newCommitId)
-		.selectAll()
-		.execute();
-
-	expect(edges.length).toBe(1);
-
-	// Get the change set ID from the commit
-	const newCommit = await db
-		.selectFrom("commit")
-		.where("id", "=", newCommitId)
-		.selectAll()
-		.executeTakeFirstOrThrow();
-
-	const newChangeSetId = newCommit.change_set_id;
-
-	// 5. Directly expect on the elements in this new set to contain the expected changes
-	const changeSetElements = await db
-		.selectFrom("change_set_element")
-		.where("change_set_id", "=", newChangeSetId)
-		.selectAll()
-		.execute();
-
-	// We expect exactly these elements:
-	// - 2 user data changes (test-entity-1, test-entity-2)
-	// - 2 change authors (one for each user data change)
-	// - 1 changeset creation
-	// - 1 commit creation
-	// - 1 commit edge creation
-	// - 1 version update
-	// Total: 8 elements
-	expect(changeSetElements.length).toBe(8);
-
-	// Verify the specific changes are in the change set
-	const elementChangeIds = changeSetElements.map((e) => e.change_id);
-
-	// Get the actual changes to verify content
-	const changes = await db
-		.selectFrom("change")
-		.where("id", "in", elementChangeIds)
-		.selectAll()
-		.execute();
-
-	// Group by schema_key for easier verification
-	const changesBySchema = changes.reduce(
-		(acc, change) => {
-			if (!acc[change.schema_key]) {
-				acc[change.schema_key] = [];
-			}
-			acc[change.schema_key]!.push(change);
-			return acc;
-		},
-		{} as Record<string, typeof changes>
-	);
-
-	// Verify we have the expected types of changes
-	expect(changesBySchema["lix_key_value"]?.length).toBe(2); // Our test data
-	expect(changesBySchema["lix_change_author"]?.length).toBe(2); // Change authors for test data
-	expect(changesBySchema["lix_change_set"]?.length).toBe(1); // The new changeset
-	expect(changesBySchema["lix_commit"]?.length).toBe(1); // The new commit
-	expect(changesBySchema["lix_commit_edge"]?.length).toBe(1); // The commit edge
-	expect(changesBySchema["lix_version"]?.length).toBe(1); // Version update
-
-	// Verify the test entities are included
-	const keyValueChanges = changesBySchema["lix_key_value"] || [];
-	const keyValueEntities = keyValueChanges.map((c) => c.entity_id);
-	expect(keyValueEntities).toContain("test-entity-1");
-	expect(keyValueEntities).toContain("test-entity-2");
-
-	// Verify change authors were created for user data changes
-	const changeAuthors = changesBySchema["lix_change_author"] || [];
-	expect(changeAuthors.length).toBe(2);
-
-	// Change author entity IDs should reference the user data change IDs
-	const userDataChangeIds = keyValueChanges.map((c) => c.id);
-	for (const author of changeAuthors) {
-		// Entity ID format for change authors is "changeId~accountId"
-		const changeId = author.entity_id.split("~")[0];
-		expect(userDataChangeIds).toContain(changeId);
-	}
-});
-
-test("commit with no changes should not create a change set", async () => {
-	const lix = await openLix({
-		keyValues: [{ key: "lix_deterministic_mode", value: { enabled: true } }],
-	});
-	const db = lix.db as unknown as Kysely<LixInternalDatabaseSchema>;
-
-	// Get initial state
-	const changesBeforeCommit = await db
-		.selectFrom("change")
-		.selectAll()
-		.execute();
-
-	const changeSetsBeforeCommit = await db
-		.selectFrom("change_set")
-		.selectAll()
-		.execute();
-
-	// Commit with no changes
-	commit({ lix });
-
-	// Should have same number of changes and change sets
-	const changesAfterCommit = await db
-		.selectFrom("change")
-		.selectAll()
-		.execute();
-
-	const changeSetsAfterCommit = await db
-		.selectFrom("change_set")
-		.selectAll()
-		.execute();
-
-	expect(changesAfterCommit.length).toBe(changesBeforeCommit.length);
-	expect(changeSetsAfterCommit.length).toBe(changeSetsBeforeCommit.length);
-});
-
-test("commit should handle multiple versions correctly", async () => {
-	const lix = await openLix({
-		keyValues: [{ key: "lix_deterministic_mode", value: { enabled: true } }],
-	});
-	const db = lix.db as unknown as Kysely<LixInternalDatabaseSchema>;
-
-	// Create version A with dynamic IDs
-	const versionAId = nanoId({ lix });
-	const versionACommitId = uuidV7({ lix });
-	const versionAChangeSetId = nanoId({ lix });
-	const versionAWorkingChangeSetId = nanoId({ lix });
-	const versionAWorkingCommitId = uuidV7({ lix });
-
-	// Create version B with dynamic IDs
-	const versionBId = nanoId({ lix });
-	const versionBCommitId = uuidV7({ lix });
-	const versionBChangeSetId = nanoId({ lix });
-	const versionBWorkingChangeSetId = nanoId({ lix });
-	const versionBWorkingCommitId = uuidV7({ lix });
-
-	// Create change sets for versions
-	insertTransactionState({
-		lix: { sqlite: lix.sqlite, db },
-		data: {
-			entity_id: versionAChangeSetId,
-			schema_key: "lix_change_set",
-			file_id: "lix",
-			plugin_key: "lix_own_entity",
-			snapshot_content: JSON.stringify({
-				id: versionAChangeSetId,
-			}),
-			schema_version: "1.0",
-			version_id: "global",
-			untracked: false,
-		},
-	});
-
-	insertTransactionState({
-		lix: { sqlite: lix.sqlite, db },
-		data: {
-			entity_id: versionAWorkingChangeSetId,
-			schema_key: "lix_change_set",
-			file_id: "lix",
-			plugin_key: "lix_own_entity",
-			snapshot_content: JSON.stringify({
-				id: versionAWorkingChangeSetId,
-			}),
-			schema_version: "1.0",
-			version_id: "global",
-			untracked: false,
-		},
-	});
-
-	insertTransactionState({
-		lix: { sqlite: lix.sqlite, db },
-		data: {
-			entity_id: versionBChangeSetId,
-			schema_key: "lix_change_set",
-			file_id: "lix",
-			plugin_key: "lix_own_entity",
-			snapshot_content: JSON.stringify({
-				id: versionBChangeSetId,
-			}),
-			schema_version: "1.0",
-			version_id: "global",
-			untracked: false,
-		},
-	});
-
-	insertTransactionState({
-		lix: { sqlite: lix.sqlite, db },
-		data: {
-			entity_id: versionBWorkingChangeSetId,
-			schema_key: "lix_change_set",
-			file_id: "lix",
-			plugin_key: "lix_own_entity",
-			snapshot_content: JSON.stringify({
-				id: versionBWorkingChangeSetId,
-			}),
-			schema_version: "1.0",
-			version_id: "global",
-			untracked: false,
-		},
-	});
-
-	// Create commits for version A
-	insertTransactionState({
-		lix: { sqlite: lix.sqlite, db },
-		data: {
-			entity_id: versionACommitId,
-			schema_key: "lix_commit",
-			file_id: "lix",
-			plugin_key: "lix_own_entity",
-			snapshot_content: JSON.stringify({
-				id: versionACommitId,
-				change_set_id: versionAChangeSetId,
-			}),
-			schema_version: "1.0",
-			version_id: "global",
-			untracked: false,
-		},
-	});
-
-	insertTransactionState({
-		lix: { sqlite: lix.sqlite, db },
-		data: {
-			entity_id: versionAWorkingCommitId,
-			schema_key: "lix_commit",
-			file_id: "lix",
-			plugin_key: "lix_own_entity",
-			snapshot_content: JSON.stringify({
-				id: versionAWorkingCommitId,
-				change_set_id: versionAWorkingChangeSetId,
-			}),
-			schema_version: "1.0",
-			version_id: "global",
-			untracked: false,
-		},
-	});
-
-	// Create version A
-	insertTransactionState({
-		lix: { sqlite: lix.sqlite, db },
-		data: {
-			entity_id: versionAId,
-			schema_key: "lix_version",
-			file_id: "lix",
-			plugin_key: "lix_own_entity",
-			snapshot_content: JSON.stringify({
-				id: versionAId,
-				name: "version A",
-				commit_id: versionACommitId,
-				working_commit_id: versionAWorkingCommitId,
-			}),
-			schema_version: "1.0",
-			version_id: "global",
-			untracked: false,
-		},
-	});
-
-	// Create commits for version B
-	insertTransactionState({
-		lix: { sqlite: lix.sqlite, db },
-		data: {
-			entity_id: versionBCommitId,
-			schema_key: "lix_commit",
-			file_id: "lix",
-			plugin_key: "lix_own_entity",
-			snapshot_content: JSON.stringify({
-				id: versionBCommitId,
-				change_set_id: versionBChangeSetId,
-			}),
-			schema_version: "1.0",
-			version_id: "global",
-			untracked: false,
-		},
-	});
-
-	insertTransactionState({
-		lix: { sqlite: lix.sqlite, db },
-		data: {
-			entity_id: versionBWorkingCommitId,
-			schema_key: "lix_commit",
-			file_id: "lix",
-			plugin_key: "lix_own_entity",
-			snapshot_content: JSON.stringify({
-				id: versionBWorkingCommitId,
-				change_set_id: versionBWorkingChangeSetId,
-			}),
-			schema_version: "1.0",
-			version_id: "global",
-			untracked: false,
-		},
-	});
-
-	// Create version B
-	insertTransactionState({
-		lix: { sqlite: lix.sqlite, db },
-		data: {
-			entity_id: versionBId,
-			schema_key: "lix_version",
-			file_id: "lix",
-			plugin_key: "lix_own_entity",
-			snapshot_content: JSON.stringify({
-				id: versionBId,
-				name: "version B",
-				commit_id: versionBCommitId,
-				working_commit_id: versionBWorkingCommitId,
-			}),
-			schema_version: "1.0",
-			version_id: "global",
-			untracked: false,
-		},
-	});
-
-	// Insert entity for version A
-	insertTransactionState({
-		lix: { sqlite: lix.sqlite, db },
-		data: {
-			entity_id: "version-a-entity",
-			schema_key: "lix_key_value",
-			file_id: "lix",
-			plugin_key: "lix_own_entity",
-			snapshot_content: JSON.stringify({
-				key: "version-a-key",
-				value: "version-a-value",
-			}),
-			schema_version: "1.0",
-			version_id: versionAId,
-			untracked: false,
-		},
-	});
-
-	// Insert entity for version B
-	insertTransactionState({
-		lix: { sqlite: lix.sqlite, db },
-		data: {
-			entity_id: "version-b-entity",
-			schema_key: "lix_key_value",
-			file_id: "lix",
-			plugin_key: "lix_own_entity",
-			snapshot_content: JSON.stringify({
-				key: "version-b-key",
-				value: "version-b-value",
-			}),
-			schema_version: "1.0",
-			version_id: versionBId,
-			untracked: false,
-		},
-	});
-
-	// Commit
-	commit({ lix });
-
-	// Test what matters: the versions should be properly created and working
-	// Version A should exist
-	const versionA = await db
-		.selectFrom("version")
-		.where("id", "=", versionAId)
-		.selectAll()
-		.executeTakeFirst();
-
-	expect(versionA).toBeDefined();
-	expect(versionA?.id).toBe(versionAId);
-	// After commit, the commit_id will be updated to the new commit containing changes
-	expect(versionA?.commit_id).toBeDefined();
-	expect(versionA?.working_commit_id).toBeDefined();
-
-	// Version B should exist
-	const versionB = await db
-		.selectFrom("version")
-		.where("id", "=", versionBId)
-		.selectAll()
-		.executeTakeFirst();
-
-	expect(versionB).toBeDefined();
-	expect(versionB?.id).toBe(versionBId);
-	// After commit, the commit_id will be updated to the new commit containing changes
-	expect(versionB?.commit_id).toBeDefined();
-	expect(versionB?.working_commit_id).toBeDefined();
-
-	// The test entities should exist in their respective versions
-	const versionAEntity = await db
-		.selectFrom("state_all")
-		.where("entity_id", "=", "version-a-entity")
-		.where("version_id", "=", versionAId)
-		.selectAll()
-		.executeTakeFirst();
-
-	expect(versionAEntity).toBeDefined();
-
-	const versionBEntity = await db
-		.selectFrom("state_all")
-		.where("entity_id", "=", "version-b-entity")
-		.where("version_id", "=", versionBId)
-		.selectAll()
-		.executeTakeFirst();
-
-	expect(versionBEntity).toBeDefined();
-
-	// Verify version updates
-	const versionChanges = await db
-		.selectFrom("change")
-		.selectAll()
-		.where("schema_key", "=", "lix_version")
-		.orderBy("created_at", "desc")
-		.execute();
-
-	// Should have version updates for all three versions (global, A, B)
-	const updatedVersionIds = versionChanges.map((c) => c.entity_id);
-	expect(updatedVersionIds).toContain("global");
-	expect(updatedVersionIds).toContain(versionAId);
-	expect(updatedVersionIds).toContain(versionBId);
-});
-
-describe("onStateCommit", () => {
-	test("fires when inserting data", async () => {
-		const lix = await openLix({});
-
-		// Register hook
-		let hookCallCount = 0;
-		const unsubscribe = lix.hooks.onStateCommit(() => {
-			hookCallCount++;
-		});
-
-		// Execute an INSERT
-		await lix.db
-			.insertInto("key_value")
-			.values({ key: "test", value: "value" })
-			.execute();
-
-		// Hook should fire once for the commit
-		expect(hookCallCount).toBe(1);
-
-		unsubscribe();
-	});
-
-	test("fires when updating data", async () => {
-		const lix = await openLix({});
-
-		// Insert initial data
-		await lix.db
-			.insertInto("key_value")
-			.values({ key: "test", value: "initial" })
-			.execute();
-
-		// Register hook after initial data
-		let hookCallCount = 0;
-		const unsubscribe = lix.hooks.onStateCommit(() => {
-			hookCallCount++;
-		});
-
-		// Execute an UPDATE
-		await lix.db
-			.updateTable("key_value")
-			.set({ value: "updated" })
-			.where("key", "=", "test")
-			.execute();
-
-		// Hook should fire once for the commit
-		expect(hookCallCount).toBe(1);
-
-		unsubscribe();
-	});
-
-	test("fires when deleting data", async () => {
-		const lix = await openLix({});
-
-		// Insert initial data
-		await lix.db
-			.insertInto("key_value")
-			.values({ key: "test", value: "value" })
-			.execute();
-
-		// Register hook after initial data
-		let hookCallCount = 0;
-		const unsubscribe = lix.hooks.onStateCommit(() => {
-			hookCallCount++;
-		});
-
-		// Execute a DELETE
-		await lix.db.deleteFrom("key_value").where("key", "=", "test").execute();
-
-		// Hook should fire once for the commit
-		expect(hookCallCount).toBe(1);
-
-		unsubscribe();
-	});
-
-	test("fires for batch operations", async () => {
-		const lix = await openLix({});
-
-		// Register hook
-		let hookCallCount = 0;
-		const unsubscribe = lix.hooks.onStateCommit(() => {
-			hookCallCount++;
-		});
-
-		// Execute multiple INSERTs in one operation
-		await lix.db
-			.insertInto("key_value")
-			.values([
-				{ key: "test1", value: "value1" },
-				{ key: "test2", value: "value2" },
-				{ key: "test3", value: "value3" },
-			])
-			.execute();
-
-		// Hook should fire once for the single commit
-		expect(hookCallCount).toBe(1);
-
-		unsubscribe();
-	});
-
-	test("fires once per transaction", async () => {
-		const lix = await openLix({});
-
-		// Register hook
-		let hookCallCount = 0;
-		const unsubscribe = lix.hooks.onStateCommit(() => {
-			hookCallCount++;
-		});
-
-		// Execute multiple separate operations
-		await lix.db
-			.insertInto("key_value")
-			.values({ key: "test1", value: "value1" })
-			.execute();
-
-		await lix.db
-			.insertInto("key_value")
-			.values({ key: "test2", value: "value2" })
-			.execute();
-
-		await lix.db
-			.updateTable("key_value")
-			.set({ value: "updated" })
-			.where("key", "=", "test1")
-			.execute();
-
-		// Hook should fire once for each operation
-		expect(hookCallCount).toBe(3);
-
-		unsubscribe();
-	});
-
-	test("multiple listeners all fire", async () => {
-		const lix = await openLix({});
-
-		// Register multiple hooks
-		let listener1Count = 0;
-		let listener2Count = 0;
-		let listener3Count = 0;
-
-		const unsubscribe1 = lix.hooks.onStateCommit(() => {
-			listener1Count++;
-		});
-
-		const unsubscribe2 = lix.hooks.onStateCommit(() => {
-			listener2Count++;
-		});
-
-		const unsubscribe3 = lix.hooks.onStateCommit(() => {
-			listener3Count++;
-		});
-
-		// Execute an operation
-		await lix.db
-			.insertInto("key_value")
-			.values({ key: "test", value: "value" })
-			.execute();
-
-		// All listeners should have fired
-		expect(listener1Count).toBe(1);
-		expect(listener2Count).toBe(1);
-		expect(listener3Count).toBe(1);
-
-		unsubscribe1();
-		unsubscribe2();
-		unsubscribe3();
-	});
-
-	test("unsubscribed listeners do not fire", async () => {
-		const lix = await openLix({});
-
-		// Register hook
-		let hookCallCount = 0;
-		const unsubscribe = lix.hooks.onStateCommit(() => {
-			hookCallCount++;
-		});
-
-		// First operation - hook should fire
-		await lix.db
-			.insertInto("key_value")
-			.values({ key: "test1", value: "value1" })
-			.execute();
-		expect(hookCallCount).toBe(1);
-
-		// Unsubscribe
-		unsubscribe();
-
-		// Second operation - hook should not fire
-		await lix.db
-			.insertInto("key_value")
-			.values({ key: "test2", value: "value2" })
-			.execute();
-		expect(hookCallCount).toBe(1); // Should not increase
-	});
-
-	test("does not fire for SELECT operations", async () => {
-		const lix = await openLix({});
-
-		// Insert some data first
-		await lix.db
-			.insertInto("key_value")
-			.values({ key: "test", value: "value" })
-			.execute();
-
-		// Register hook
-		let hookCallCount = 0;
-		const unsubscribe = lix.hooks.onStateCommit(() => {
-			hookCallCount++;
-		});
-
-		// Execute SELECT operations
-		await lix.db.selectFrom("key_value").selectAll().execute();
-		await lix.db.selectFrom("state").selectAll().execute();
-		await lix.db
-			.selectFrom("key_value")
-			.where("key", "=", "test")
-			.selectAll()
-			.execute();
-
-		// Hook should not fire for SELECT operations
-		expect(hookCallCount).toBe(0);
-
-		unsubscribe();
-	});
-
-	test("hook can access lix instance via closure", async () => {
-		const lix = await openLix({});
-
-		// Register hook that uses lix instance
-		let capturedValue: any = null;
-		const unsubscribe = lix.hooks.onStateCommit(() => {
-			// Access lix instance in the hook
-			capturedValue = lix.db;
-		});
-
-		// Execute an operation
-		await lix.db
-			.insertInto("key_value")
-			.values({ key: "test", value: "value" })
-			.execute();
-
-		// Hook should have access to lix instance
-		expect(capturedValue).toBeDefined();
-		expect(capturedValue).toBe(lix.db);
-
-		unsubscribe();
-	});
-
-	// TODO hooks throwing is uncaught
-	test.todo("errors in hook do not prevent commit", async () => {
-		const lix = await openLix({});
-
-		// Register hook that throws an error
-		const unsubscribe = lix.hooks.onStateCommit(() => {
-			throw new Error("Hook error");
-		});
-
-		// Operation should still succeed despite hook error
-		await expect(
-			lix.db
-				.insertInto("key_value")
-				.values({ key: "test", value: "value" })
-				.execute()
-		).resolves.not.toThrow();
-
-		// Verify data was inserted
-		const result = await lix.db
-			.selectFrom("key_value")
-			.where("key", "=", "test")
-			.selectAll()
-			.execute();
-		expect(result).toHaveLength(1);
-
-		unsubscribe();
-	});
-});
-
-/**
- * Tests that when changes are made directly to the global version,
- * the global version's change_set_id is updated to reflect those changes.
- *
- * This is a simpler case than non-global versions because:
- * - Only one version needs to be updated (global itself)
- * - The changes and the version update are both stored in the same version (global)
- */
-test("global version should move forward when mutations occur", async () => {
-	const lix = await openLix({
-		keyValues: [{ key: "lix_deterministic_mode", value: { enabled: true } }],
-	});
-	const db = lix.db as unknown as Kysely<LixInternalDatabaseSchema>;
-
-	// Get the global version before any changes
-	const globalVersionBefore = await db
-		.selectFrom("version")
-		.where("id", "=", "global")
-		.selectAll()
-		.executeTakeFirstOrThrow();
-
-	const initialCommitId = globalVersionBefore.commit_id;
-
-	// Insert data with version_id = "global"
-	insertTransactionState({
-		lix: { sqlite: lix.sqlite, db },
-		data: {
-			entity_id: "test-global-entity",
-			schema_key: "lix_key_value",
-			file_id: "lix",
-			plugin_key: "lix_own_entity",
-			snapshot_content: JSON.stringify({
-				key: "test-global-key",
-				value: "test-global-value",
-			}),
-			schema_version: "1.0",
-			version_id: "global",
-			untracked: false,
-		},
-	});
-
-	// Commit the changes
-	commit({ lix });
-
-	// Get the global version after changes
-	const globalVersionAfter = await db
-		.selectFrom("version")
-		.where("id", "=", "global")
-		.selectAll()
-		.executeTakeFirstOrThrow();
-
-	// The global version's commit_id should have been updated
-	expect(globalVersionAfter.commit_id).not.toBe(initialCommitId);
-
-	// Verify a new commit was created and linked
-	const edges = await db
-		.selectFrom("commit_edge")
-		.where("parent_id", "=", initialCommitId)
-		.where("child_id", "=", globalVersionAfter.commit_id)
-		.selectAll()
-		.execute();
-
-	expect(edges.length).toBe(1);
-
-	// Get the change set ID from the new commit
-	const newCommit = await db
-		.selectFrom("commit")
-		.where("id", "=", globalVersionAfter.commit_id)
-		.selectAll()
-		.executeTakeFirstOrThrow();
-
-	// Verify the change set contains our change
-	const changeSetElements = await db
-		.selectFrom("change_set_element")
-		.where("change_set_id", "=", newCommit.change_set_id)
-		.selectAll()
-		.execute();
-
-	// Should contain our test entity change and the meta changes
-	const elementIds = changeSetElements.map((e) => e.entity_id);
-	expect(elementIds.some((id) => id.includes("test-global-entity"))).toBe(true);
-});
-
-/**
- * Tests that edge changes are properly created during commit.
- *
- * When a version moves forward (creates a new commit), an edge change must be created
- * with schema_key='lix_commit_edge' that links the old commit to the new one.
- * This is critical for the materialization lineage CTE to traverse the commit history.
- */
-test("commit should create edge changes that are discoverable by lineage CTE", async () => {
-	const lix = await openLix({
-		keyValues: [
-			{
-				key: "lix_deterministic_mode",
-				value: { enabled: true, bootstrap: false },
-				lixcol_version_id: "global",
-			},
-		],
-	});
-	const db = lix.db as unknown as Kysely<LixInternalDatabaseSchema>;
-
-	// Get the global version before any changes
-	const globalVersionBefore = await db
-		.selectFrom("version")
-		.where("id", "=", "global")
-		.selectAll()
-		.executeTakeFirstOrThrow();
-
-	const previousCommitId = globalVersionBefore.commit_id;
-
-	// Insert data with version_id = "global"
-	insertTransactionState({
-		lix: { sqlite: lix.sqlite, db },
-		data: {
-			entity_id: "test-edge-entity",
-			schema_key: "lix_key_value",
-			file_id: "lix",
-			plugin_key: "lix_own_entity",
-			snapshot_content: JSON.stringify({
-				key: "test-edge-key",
-				value: "test-edge-value",
-			}),
-			schema_version: "1.0",
-			version_id: "global",
-			untracked: false,
-		},
-	});
-
-	// Commit the changes
-	commit({ lix });
-
-	// Get the global version after changes
-	const globalVersionAfter = await db
-		.selectFrom("version")
-		.where("id", "=", "global")
-		.selectAll()
-		.executeTakeFirstOrThrow();
-
-	const newCommitId = globalVersionAfter.commit_id;
-	expect(newCommitId).not.toBe(previousCommitId);
-
-	// CRITICAL: Verify that an actual edge CHANGE exists (not just an element)
-	const edgeChanges = await db
-		.selectFrom("change")
-		.where("schema_key", "=", "lix_commit_edge")
-		.where("entity_id", "=", `${previousCommitId}~${newCommitId}`)
-		.selectAll()
-		.execute();
-
-	expect(edgeChanges.length).toBe(1);
-
-	const edgeChange = edgeChanges[0]!;
-	expect(edgeChange.snapshot_content).toBeTruthy();
-
-	// Verify the edge snapshot content
-	const edgeSnapshot = edgeChange.snapshot_content as any;
-	expect(edgeSnapshot.parent_id).toBe(previousCommitId);
-	expect(edgeSnapshot.child_id).toBe(newCommitId);
-
-	// Verify the edge is discoverable by the lineage CTE
-	// This simulates what internal_materialization_lineage does
-	const lineageRows = lix.sqlite.exec({
-		sql: `
-			WITH RECURSIVE lineage_commits(id, version_id) AS (
-				/* anchor: use edge-based approach to find the tip */
-				SELECT 
-					json_extract(v.snapshot_content,'$.commit_id') AS id,
-					v.entity_id AS version_id 
-				FROM change v
-				WHERE v.schema_key = 'lix_version'
-				  AND v.entity_id = 'global'
-				  /* keep only the row whose commit_id has NO outgoing edge */
-				  AND NOT EXISTS (
-					SELECT 1
-					FROM change edge
-					WHERE edge.schema_key = 'lix_commit_edge'
-					  AND json_extract(edge.snapshot_content,'$.parent_id') = json_extract(v.snapshot_content,'$.commit_id')
-				  )
-
-				UNION
-
-				/* recurse upwards via parent_id */
-				SELECT 
-					json_extract(edge.snapshot_content,'$.parent_id') AS id,
-					l.version_id AS version_id
-				FROM change edge
-				JOIN lineage_commits l ON json_extract(edge.snapshot_content,'$.child_id') = l.id
-				WHERE edge.schema_key = 'lix_commit_edge'
-				  AND json_extract(edge.snapshot_content,'$.parent_id') IS NOT NULL
-			)
-			SELECT id FROM lineage_commits WHERE version_id = 'global' ORDER BY id;
-		`,
-		returnValue: "resultRows",
-	});
-
-	// Should have at least 2 entries: the new commit and its parent
-	expect(lineageRows.length).toBeGreaterThanOrEqual(2);
-
-	// Verify both commits are in the lineage
-	const lineageIds = lineageRows.map((row) => row[0]);
-	expect(lineageIds).toContain(newCommitId);
-	expect(lineageIds).toContain(previousCommitId);
-});
-
-/**
- * Tests that when changes are made to a non-global version (like the active/main version),
- * both the version itself AND the global version are updated.
- *
- * This is critical because:
- * 1. The non-global version's commit_id moves forward to include its data changes
- * 2. The global version's commit_id ALSO moves forward to track the version update itself
- * 3. All version changes (updates to any version entity) are stored in the global version's history
- *
- * Without this behavior, each version would need to maintain its own history of all other versions,
- * which would be redundant and complex. Instead, the global version serves as the central registry
- * of all version state changes.
- */
-test("active version should move forward when mutations occur", async () => {
-	const lix = await openLix({
-		keyValues: [
-			{
-				key: "lix_deterministic_mode",
-				value: { enabled: true, bootstrap: true },
-			},
-		],
-	});
-	const db = lix.db as unknown as Kysely<LixInternalDatabaseSchema>;
-
-	// Get the global version before for comparison
-	const globalVersionBefore = await db
-		.selectFrom("version")
-		.where("id", "=", "global")
-		.selectAll()
-		.executeTakeFirstOrThrow();
-
-	// Get the active version (should be the main version, not global)
-	const activeVersion = await db
-		.selectFrom("active_version")
-		.selectAll()
-		.executeTakeFirstOrThrow();
-
-	const activeVersionId = activeVersion.version_id;
-	expect(activeVersionId).not.toBe("global"); // Ensure we're testing a non-global version
-
-	// Get the version before any changes
-	const versionBefore = await db
-		.selectFrom("version")
-		.where("id", "=", activeVersionId)
-		.selectAll()
-		.executeTakeFirstOrThrow();
-
-	const initialActiveVersionCommitId = versionBefore.commit_id;
-
-	// Insert data with version_id = activeVersionId
-	insertTransactionState({
-		lix: { sqlite: lix.sqlite, db },
-		data: {
-			entity_id: "test-active-entity",
-			schema_key: "lix_key_value",
-			file_id: "lix",
-			plugin_key: "lix_own_entity",
-			snapshot_content: JSON.stringify({
-				key: "test-active-key",
-				value: "test-active-value",
-			}),
-			schema_version: "1.0",
-			version_id: activeVersionId,
-			untracked: false,
-		},
-	});
-
-	// Commit the changes
-	commit({ lix });
-
-	// Get the version after changes
-	const versionAfter = await db
-		.selectFrom("version")
-		.where("id", "=", activeVersionId)
-		.selectAll()
-		.executeTakeFirstOrThrow();
-
-	// The version's commit_id should have been updated
-	expect(versionAfter.commit_id).not.toBe(initialActiveVersionCommitId);
-
-	// Verify a new commit was created and linked
-	const edges = await db
-		.selectFrom("commit_edge")
-		.where("parent_id", "=", initialActiveVersionCommitId)
-		.where("child_id", "=", versionAfter.commit_id)
-		.selectAll()
-		.execute();
-
-	expect(edges.length).toBe(1);
-
-	// Get the change set ID from the new commit
-	const newCommit = await db
-		.selectFrom("commit")
-		.where("id", "=", versionAfter.commit_id)
-		.selectAll()
-		.executeTakeFirstOrThrow();
-
-	// Verify the change set contains our change
-	const changeSetElements = await db
-		.selectFrom("change_set_element")
-		.where("change_set_id", "=", newCommit.change_set_id)
-		.selectAll()
-		.execute();
-
-	// Should contain our test entity change and the meta changes
-	const elementIds = changeSetElements.map((e) => e.entity_id);
-	expect(elementIds.some((id) => id.includes("test-active-entity"))).toBe(true);
-
-	// Also verify that the global version DID move forward
-	// (because all version changes are tracked in global)
-	const globalVersionAfter = await db
-		.selectFrom("version")
-		.where("id", "=", "global")
-		.selectAll()
-		.executeTakeFirstOrThrow();
-
-	// Global version should have been updated to track the version change
-	expect(globalVersionAfter.commit_id).not.toBe(globalVersionBefore.commit_id);
-
-	// Get the change set ID from the global version's new commit
-	const globalNewCommit = await db
-		.selectFrom("commit")
-		.where("id", "=", globalVersionAfter.commit_id)
-		.selectAll()
-		.executeTakeFirstOrThrow();
-
-	// Verify the global version's new changeset contains the version updates
-	const globalChangeSetElements = await db
-		.selectFrom("change_set_element")
-		.where("change_set_id", "=", globalNewCommit.change_set_id)
-		.selectAll()
-		.execute();
-
-	// Should contain exactly two version updates: global and active version
-	const versionUpdateElements = globalChangeSetElements.filter(
-		(e) => e.schema_key === "lix_version"
-	);
-	expect(versionUpdateElements.length).toBe(2);
-
-	// Verify both version updates point to the correct entities
-	const versionUpdateEntityIds = versionUpdateElements.map((e) => e.entity_id);
-	expect(versionUpdateEntityIds).toContain("global");
-	expect(versionUpdateEntityIds).toContain(activeVersionId);
-
-	// Get the actual version changes to verify they have the correct change_set_ids
-	const versionChanges = await db
-		.selectFrom("change")
-		.where(
-			"id",
-			"in",
-			versionUpdateElements.map((e) => e.change_id)
-		)
-		.where("schema_key", "=", "lix_version")
-		.selectAll()
-		.execute();
-
-	// Verify the version snapshots contain the correct commit_ids
-	for (const change of versionChanges) {
-		if (change.entity_id === "global") {
-			expect(change.snapshot_content?.commit_id).toBe(
-				globalVersionAfter.commit_id
-			);
-		} else if (change.entity_id === activeVersionId) {
-			expect(change.snapshot_content?.commit_id).toBe(versionAfter.commit_id);
-		}
-	}
-});
-
-// Tests moved from handle-state-mutation.test.ts since they test commit behavior
-
-test("creates a new commit and updates the version's commit id for mutations", async () => {
-	const lix = await openLix({});
-
-	const versionBeforeInsert = await lix.db
-		.selectFrom("active_version")
-		.innerJoin("version", "version.id", "active_version.version_id")
-		.selectAll()
-		.where("name", "=", "main")
-		.executeTakeFirstOrThrow();
-
-	await lix.db
-		.insertInto("key_value")
-		.values({
-			key: "mock_key",
-			value: "mock_value",
-		})
-		.execute();
-
-	const versionAfterInsert = await lix.db
-		.selectFrom("version")
-		.selectAll()
-		.where("id", "=", versionBeforeInsert.id)
-		.executeTakeFirstOrThrow();
-
-	expect(versionAfterInsert.commit_id).not.toEqual(
-		versionBeforeInsert.commit_id
-	);
-
-	await lix.db
-		.updateTable("key_value_all")
-		.where("key", "=", "mock_key")
-		.where(
-			"lixcol_version_id",
-			"=",
-			lix.db.selectFrom("active_version").select("version_id")
-		)
-		.set({
-			value: "mock_value_updated",
-		})
-		.execute();
-
-	const versionAfterUpdate = await lix.db
-		.selectFrom("version")
-		.selectAll()
-		.where("id", "=", versionAfterInsert.id)
-		.executeTakeFirstOrThrow();
-
-	expect(versionAfterUpdate.commit_id).not.toEqual(
-		versionAfterInsert.commit_id
-	);
-
-	await lix.db.deleteFrom("key_value").where("key", "=", "mock_key").execute();
-
-	const versionAfterDelete = await lix.db
-		.selectFrom("version")
-		.selectAll()
-		.where("id", "=", versionAfterUpdate.id)
-		.executeTakeFirstOrThrow();
-
-	expect(versionAfterDelete.commit_id).not.toEqual(
-		versionAfterUpdate.commit_id
-	);
-
-	const edges = await lix.db
-		.selectFrom("commit_edge")
-		.select(["parent_id", "child_id"])
-		.execute();
-
-	expect(edges).toEqual(
-		expect.arrayContaining([
-			{
-				parent_id: versionBeforeInsert.commit_id,
-				child_id: versionAfterInsert.commit_id,
-			},
-			{
-				parent_id: versionAfterInsert.commit_id,
-				child_id: versionAfterUpdate.commit_id,
-			},
-			{
-				parent_id: versionAfterUpdate.commit_id,
-				child_id: versionAfterDelete.commit_id,
-			},
-		] satisfies LixCommitEdge[])
-	);
-});
-
-test("groups changes of a transaction into the same change set for the given version", async () => {
-	const lix = await openLix({});
-
-	const activeVersion = await lix.db
-		.selectFrom("active_version")
-		.innerJoin("version", "version.id", "active_version.version_id")
-		.selectAll("version")
-		.executeTakeFirstOrThrow();
-
-	const commitAncestryBefore = await lix.db
-		.selectFrom("commit")
-		.where(commitIsAncestorOf({ id: activeVersion.commit_id }))
-		.selectAll()
-		.execute();
-
-	await lix.db.transaction().execute(async (trx) => {
-		await trx
-			.insertInto("key_value")
-			.values({
-				key: "mock_key",
-				value: "mock_value",
-			})
-			.execute();
-
-		await trx
-			.insertInto("key_value")
-			.values({
-				key: "mock_key2",
-				value: "mock_value2",
-			})
-			.execute();
-	});
-
-	const activeVersionAfterTransaction = await lix.db
-		.selectFrom("active_version")
-		.innerJoin("version", "version.id", "active_version.version_id")
-		.selectAll("version")
-		.executeTakeFirstOrThrow();
-
-	const commitAncestryAfter = await lix.db
-		.selectFrom("commit")
-		.where(commitIsAncestorOf({ id: activeVersionAfterTransaction.commit_id }))
-		.selectAll()
-		.execute();
-
-	expect(commitAncestryAfter).toHaveLength(commitAncestryBefore.length + 1);
-});
-
-test("creates change_author records for insert, update, and delete operations", async () => {
-	const lix = await openLix({});
-
-	// Create test accounts
-	await lix.db
-		.insertInto("account")
-		.values([
-			{ id: "test-account-1", name: "Test User 1" },
-			{ id: "test-account-2", name: "Test User 2" },
-		])
-		.execute();
-
-	// Switch to single active account for insert
-	await switchAccount({
-		lix,
-		to: [{ id: "test-account-1", name: "Test User 1" }],
-	});
-
-	// INSERT: Create initial entity
-	await lix.db
-		.insertInto("key_value")
-		.values({
-			key: "crud_test_key",
-			value: "initial_value",
-		})
-		.execute();
-
-	// Switch to multiple active accounts for update
-	await switchAccount({
-		lix,
-		to: [
-			{ id: "test-account-1", name: "Test User 1" },
-			{ id: "test-account-2", name: "Test User 2" },
-		],
-	});
-
-	// UPDATE: Modify the entity
-	await lix.db
-		.updateTable("key_value")
-		.where("key", "=", "crud_test_key")
-		.set({ value: "updated_value" })
-		.execute();
-
-	// Switch back to single account for delete
-	await switchAccount({
-		lix,
-		to: [{ id: "test-account-2", name: "Test User 2" }],
-	});
-
-	// DELETE: Remove the entity
-	await lix.db
-		.deleteFrom("key_value")
-		.where("key", "=", "crud_test_key")
-		.execute();
-
-	// Get all changes for this entity
-	const changes = await lix.db
-		.selectFrom("change")
-		.where("entity_id", "=", "crud_test_key")
-		.where("schema_key", "=", "lix_key_value")
-		.orderBy("created_at", "asc")
-		.select(["id"])
-		.execute();
-
-	expect(changes).toHaveLength(3); // Insert + Update + Delete
-
-	const insertChangeId = changes[0]!.id;
-	const updateChangeId = changes[1]!.id;
-	const deleteChangeId = changes[2]!.id;
-
-	// Verify change_author records for INSERT (single account)
-	const insertAuthors = await lix.db
-		.selectFrom("change_author")
-		.where("change_id", "=", insertChangeId)
-		.selectAll()
-		.execute();
-
-	expect(insertAuthors).toHaveLength(1);
-	expect(insertAuthors[0]).toMatchObject({
-		change_id: insertChangeId,
-		account_id: "test-account-1",
-	});
-
-	// Verify change_author records for UPDATE (multiple accounts)
-	const updateAuthors = await lix.db
-		.selectFrom("change_author")
-		.where("change_id", "=", updateChangeId)
-		.selectAll()
-		.execute();
-
-	expect(updateAuthors).toHaveLength(2);
-
-	// Check that both accounts are represented
-	const updateAccountIds = updateAuthors.map((author) => author.account_id);
-	expect(updateAccountIds).toContain("test-account-1");
-	expect(updateAccountIds).toContain("test-account-2");
-
-	// Check that all records have the correct change_id
-	updateAuthors.forEach((author) => {
-		expect(author).toMatchObject({
-			change_id: updateChangeId,
-		});
-	});
-
-	// Verify change_author records for DELETE (single account)
-	const deleteAuthors = await lix.db
-		.selectFrom("change_author")
-		.where("change_id", "=", deleteChangeId)
-		.selectAll()
-		.execute();
-
-	expect(deleteAuthors).toHaveLength(1);
-	expect(deleteAuthors[0]).toMatchObject({
-		change_id: deleteChangeId,
-		account_id: "test-account-2",
-	});
-});