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

package/dist/state/commit.test.js

@@ -0,0 +1,1173 @@
+import { test, expect, describe } from "vitest";
+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;
+    // 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;
+    }, {});
+    // 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;
+    // 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;
+    // 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 = 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;
+    // 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;
+    // 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;
+    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;
+    // 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,
+        },
+    ]));
+});
+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",
+    });
+});
+//# sourceMappingURL=commit.test.js.map