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

package/dist/version/schema.test.js

@@ -1,11 +1,21 @@
 import { expect, test } from "vitest";
 import { openLix } from "../lix/open-lix.js";
 import { createVersion } from "./create-version.js";
-test("insert, update, delete on the version view", async () => {
+const testStateSchema = {
+    "x-lix-key": "test_schema",
+    "x-lix-version": "1.0",
+    type: "object",
+    additionalProperties: false,
+    properties: {
+        foo: { type: "string" },
+    },
+    required: ["foo"],
+};
+test("insert, update, delete on version descriptor", async () => {
     const lix = await openLix({});
     // Create required change sets first
     await lix.db
-        .insertInto("change_set_all")
+        .insertInto("change_set_by_version")
         .values([
         { id: "change_set_id_0", lixcol_version_id: "global" },
         { id: "change_set_id_1", lixcol_version_id: "global" },
@@ -13,22 +23,50 @@ test("insert, update, delete on the version view", async () => {
         { id: "working_cs_1", lixcol_version_id: "global" },
     ])
         .execute();
+    // Create required commits
     await lix.db
-        .insertInto("version_all")
+        .insertInto("commit_by_version")
+        .values([
+        {
+            id: "commit_id_0",
+            change_set_id: "change_set_id_0",
+            lixcol_version_id: "global",
+        },
+        {
+            id: "commit_id_1",
+            change_set_id: "change_set_id_1",
+            lixcol_version_id: "global",
+        },
+        {
+            id: "working_commit_0",
+            change_set_id: "working_cs_0",
+            lixcol_version_id: "global",
+        },
+        {
+            id: "working_commit_1",
+            change_set_id: "working_cs_1",
+            lixcol_version_id: "global",
+        },
+    ])
+        .execute();
+    await lix.db
+        .insertInto("version_by_version")
         .values([
         {
             id: "version0",
             name: "version0",
-            change_set_id: "change_set_id_0",
-            working_change_set_id: "working_cs_0",
+            // descriptor-only insert: no commit_id here
+            working_commit_id: "working_commit_0",
             lixcol_version_id: "global",
+            inherits_from_version_id: "global",
         },
         {
             id: "version1",
             name: "version1",
-            change_set_id: "change_set_id_1",
-            working_change_set_id: "working_cs_1",
+            // descriptor-only insert: no commit_id here
+            working_commit_id: "working_commit_1",
             lixcol_version_id: "global",
+            inherits_from_version_id: "global",
         },
     ])
         .execute();
@@ -38,20 +76,14 @@ test("insert, update, delete on the version view", async () => {
         .where("id", "in", ["version0", "version1"])
         .selectAll()
         .execute();
-    expect(viewAfterInsert).toMatchObject([
-        {
-            name: "version0",
-            change_set_id: "change_set_id_0",
-        },
-        {
-            name: "version1",
-            change_set_id: "change_set_id_1",
-        },
+    expect(viewAfterInsert.map((v) => ({ name: v.name }))).toMatchObject([
+        { name: "version0" },
+        { name: "version1" },
     ]);
     await lix.db
         .updateTable("version")
         .where("name", "=", "version0")
-        .set({ change_set_id: "change_set_id_1" })
+        .set({ name: "version0_renamed" })
         .execute();
     const viewAfterUpdate = await lix.db
         .selectFrom("version")
@@ -59,15 +91,9 @@ test("insert, update, delete on the version view", async () => {
         .where("id", "in", ["version0", "version1"])
         .selectAll()
         .execute();
-    expect(viewAfterUpdate).toMatchObject([
-        {
-            name: "version0",
-            change_set_id: "change_set_id_1",
-        },
-        {
-            name: "version1",
-            change_set_id: "change_set_id_1",
-        },
+    expect(viewAfterUpdate.map((v) => ({ name: v.name }))).toMatchObject([
+        { name: "version0_renamed" },
+        { name: "version1" },
     ]);
     await lix.db.deleteFrom("version").where("id", "=", "version0").execute();
     const viewAfterDelete = await lix.db
@@ -80,35 +106,22 @@ test("insert, update, delete on the version view", async () => {
         {
             id: "version1",
             name: "version1",
-            change_set_id: "change_set_id_1",
-            working_change_set_id: "working_cs_1",
+            working_commit_id: "working_commit_1",
             inherits_from_version_id: "global",
         },
     ]);
+    // Assert descriptor changes (no tip writes since commit_id not provided)
     const changes = await lix.db
         .selectFrom("change")
-        .where("schema_key", "=", "lix_version")
+        .where("schema_key", "=", "lix_version_descriptor")
         .where("entity_id", "in", ["version0", "version1"])
         .orderBy("change.created_at", "asc")
         .selectAll("change")
         .execute();
-    expect(changes.map((change) => change.snapshot_content)).toMatchObject([
-        // version 0's insert
-        {
-            name: "version0",
-            change_set_id: "change_set_id_0",
-        },
-        // version 0's insert
-        {
-            name: "version1",
-            change_set_id: "change_set_id_1",
-        },
-        {
-            // version 0's update
-            name: "version0",
-            change_set_id: "change_set_id_1",
-        },
-        // version 0's delete
+    expect(changes.map((c) => c.snapshot_content)).toMatchObject([
+        { name: "version0" },
+        { name: "version1" },
+        { name: "version0_renamed" },
         null,
     ]);
 });
@@ -116,7 +129,7 @@ test("querying by id", async () => {
     const lix = await openLix({});
     // Create required change sets first
     await lix.db
-        .insertInto("change_set_all")
+        .insertInto("change_set_by_version")
         .values([
         { id: "change_set_id_0", lixcol_version_id: "global" },
         { id: "change_set_id_1", lixcol_version_id: "global" },
@@ -124,20 +137,44 @@ test("querying by id", async () => {
         { id: "working_cs_1", lixcol_version_id: "global" },
     ])
         .execute();
+    // Create required commits
+    await lix.db
+        .insertInto("commit_by_version")
+        .values([
+        {
+            id: "commit_id_0",
+            change_set_id: "change_set_id_0",
+            lixcol_version_id: "global",
+        },
+        {
+            id: "commit_id_1",
+            change_set_id: "change_set_id_1",
+            lixcol_version_id: "global",
+        },
+        {
+            id: "working_commit_0",
+            change_set_id: "working_cs_0",
+            lixcol_version_id: "global",
+        },
+        {
+            id: "working_commit_1",
+            change_set_id: "working_cs_1",
+            lixcol_version_id: "global",
+        },
+    ])
+        .execute();
     await lix.db
         .insertInto("version")
         .values([
         {
             id: "version0",
             name: "version0",
-            change_set_id: "change_set_id_0",
-            working_change_set_id: "working_cs_0",
+            working_commit_id: "working_commit_0",
         },
         {
             id: "version1",
             name: "version1",
-            change_set_id: "change_set_id_1",
-            working_change_set_id: "working_cs_1",
+            working_commit_id: "working_commit_1",
         },
     ])
         .execute();
@@ -153,16 +190,30 @@ test("update active version view", async () => {
     const lix = await openLix({});
     // Create required change sets and version first
     await lix.db
-        .insertInto("change_set_all")
-        .values([{ id: "cs1", lixcol_version_id: "global" }])
+        .insertInto("change_set_by_version")
+        .values([
+        { id: "cs1", lixcol_version_id: "global" },
+        { id: "working_cs1", lixcol_version_id: "global" },
+    ])
+        .execute();
+    // Create required commits
+    await lix.db
+        .insertInto("commit_by_version")
+        .values([
+        { id: "commit_cs1", change_set_id: "cs1", lixcol_version_id: "global" },
+        {
+            id: "working_commit_1",
+            change_set_id: "working_cs1",
+            lixcol_version_id: "global",
+        },
+    ])
         .execute();
     await lix.db
         .insertInto("version")
         .values({
         id: "version_id_1",
         name: "test_version",
-        change_set_id: "cs1",
-        working_change_set_id: "cs1",
+        working_commit_id: "working_commit_1",
     })
         .execute();
     await lix.db
@@ -178,6 +229,49 @@ test("update active version view", async () => {
             version_id: "version_id_1",
         },
     ]);
+    await lix.close();
+});
+test("active_version update succeeds via raw SQLite trigger", async () => {
+    const lix = await openLix({});
+    // Prepare change sets and commits identical to the preprocessor-driven path.
+    await lix.db
+        .insertInto("change_set_by_version")
+        .values([
+        { id: "cs2", lixcol_version_id: "global" },
+        { id: "working_cs2", lixcol_version_id: "global" },
+    ])
+        .execute();
+    await lix.db
+        .insertInto("commit_by_version")
+        .values([
+        { id: "commit_cs2", change_set_id: "cs2", lixcol_version_id: "global" },
+        {
+            id: "working_commit_2",
+            change_set_id: "working_cs2",
+            lixcol_version_id: "global",
+        },
+    ])
+        .execute();
+    await lix.db
+        .insertInto("version")
+        .values({
+        id: "version_id_2",
+        name: "raw_update_version",
+        working_commit_id: "working_commit_2",
+    })
+        .execute();
+    // Execute the update directly through SQLite so the INSTEAD OF trigger handles it.
+    lix.engine.sqlite.exec({
+        sql: `UPDATE active_version SET version_id = ?`,
+        bind: ["version_id_2"],
+    });
+    const rawResult = lix.engine.sqlite.exec({
+        sql: `SELECT version_id FROM active_version`,
+        returnValue: "resultRows",
+        rowMode: "object",
+    });
+    expect(rawResult).toEqual([{ version_id: "version_id_2" }]);
+    await lix.close();
 });
 test("applying the schema should create an initial 'main' version", async () => {
     const lix = await openLix({});
@@ -206,30 +300,18 @@ test("applying the schema should set the initial active version to 'main'", asyn
 });
 test("should use default id and name if not provided", async () => {
     const lix = await openLix({});
-    // Pre-populate change_set table
-    await lix.db
-        .insertInto("change_set_all")
-        .values([{ id: "cs1", lixcol_version_id: "global" }])
-        .execute();
-    // Insert a version providing only change_set_id
-    await lix.db
-        .insertInto("version")
-        .values({
-        change_set_id: "cs1",
-        working_change_set_id: "cs1",
-    })
-        .execute();
+    // Insert a version providing only working_commit_id (no id/name provided)
+    await lix.db.insertInto("version").defaultValues().execute();
     // Verify the inserted data (id and name should be defaulted)
     const version = await lix.db
         .selectFrom("version")
         .selectAll()
-        .where("change_set_id", "=", "cs1")
         .executeTakeFirstOrThrow();
     expect(version?.id).toBeTypeOf("string");
     expect(version?.id.length).toBeGreaterThan(0);
     expect(version?.name).toBeTypeOf("string");
     expect(version?.name?.length).toBeGreaterThan(0);
-    expect(version?.change_set_id).toBe("cs1");
+    // commit_id (tip) is not set via version view; defaults handled elsewhere
     await lix.db
         .updateTable("version")
         .where("id", "=", version.id)
@@ -244,60 +326,64 @@ test("should use default id and name if not provided", async () => {
         .executeTakeFirstOrThrow();
     expect(updatedVersion?.name).toBe("new_name");
 });
-test("should enforce foreign key constraint on change_set_id", async () => {
+test.skip("should enforce foreign key constraint on working_commit_id", async () => {
     const lix = await openLix({});
-    // Attempt to insert version with non-existent change_set_id
-    await expect(lix.db
-        .insertInto("version")
-        .values({
-        id: "version1",
-        name: "test_version",
-        change_set_id: "cs_nonexistent",
-        working_change_set_id: "cs_nonexistent",
-    })
-        .execute()).rejects.toThrow(/Foreign key constraint violation/i);
-});
-test("should enforce foreign key constraint on working_change_set_id", async () => {
-    const lix = await openLix({});
-    // Create valid change set for change_set_id
+    // Create valid change set for commit_id
     await lix.db
-        .insertInto("change_set_all")
+        .insertInto("change_set_by_version")
         .values({ id: "cs1", lixcol_version_id: "global" })
         .execute();
-    // Attempt to insert version with non-existent working_change_set_id
+    // Create required commit
+    await lix.db
+        .insertInto("commit_by_version")
+        .values([
+        { id: "commit_cs1", change_set_id: "cs1", lixcol_version_id: "global" },
+    ])
+        .execute();
+    // Attempt to insert version with non-existent working_commit_id
     await expect(lix.db
         .insertInto("version")
         .values({
         id: "version1",
         name: "test_version",
-        change_set_id: "cs1",
-        working_change_set_id: "cs_nonexistent",
+        working_commit_id: "commit_nonexistent",
     })
-        .execute()).rejects.toThrow(/Foreign key constraint violation/i);
+        .execute()).rejects.toThrow();
 });
-test("should allow version insertion with valid change set references", async () => {
+test("should allow version insertion with valid working commit reference", async () => {
     const lix = await openLix({});
     // Create valid change sets
     await lix.db
-        .insertInto("change_set_all")
+        .insertInto("change_set_by_version")
         .values([
         { id: "cs1", lixcol_version_id: "global" },
         { id: "cs2", lixcol_version_id: "global" },
     ])
         .execute();
+    // Create valid commits
+    await lix.db
+        .insertInto("commit_by_version")
+        .values([
+        { id: "commit_cs1", change_set_id: "cs1", lixcol_version_id: "global" },
+        {
+            id: "working_commit_cs2",
+            change_set_id: "cs2",
+            lixcol_version_id: "global",
+        },
+    ])
+        .execute();
     // This should succeed with valid foreign key references
     await expect(lix.db
         .insertInto("version")
         .values({
         id: "version1",
         name: "test_version",
-        change_set_id: "cs1",
-        working_change_set_id: "cs2",
+        working_commit_id: "working_commit_cs2",
     })
         .execute()).resolves.toBeDefined();
 });
 // having the active_version as regular table is easier
-test.skip("should enforce foreign key constraint on active_version.version_id", async () => {
+test("should enforce FK on active_version.version_id against descriptor", async () => {
     const lix = await openLix({});
     // Now attempt to update active_version with non-existent version_id
     await expect(lix.db
@@ -309,16 +395,33 @@ test("should allow active_version update with valid version_id", async () => {
     const lix = await openLix({});
     // Create valid change set and version
     await lix.db
-        .insertInto("change_set_all")
+        .insertInto("change_set_by_version")
         .values({ id: "cs1", lixcol_version_id: "global" })
         .execute();
+    // Create required commit
+    await lix.db
+        .insertInto("commit_by_version")
+        .values([
+        { id: "commit_cs1", change_set_id: "cs1", lixcol_version_id: "global" },
+    ])
+        .execute();
+    // Create working commit
+    await lix.db
+        .insertInto("commit_by_version")
+        .values([
+        {
+            id: "working_commit_cs1",
+            change_set_id: "cs1",
+            lixcol_version_id: "global",
+        },
+    ])
+        .execute();
     await lix.db
         .insertInto("version")
         .values({
         id: "version1",
         name: "test_version",
-        change_set_id: "cs1",
-        working_change_set_id: "cs1",
+        working_commit_id: "working_commit_cs1",
     })
         .execute();
     // This should succeed with valid foreign key reference
@@ -331,13 +434,46 @@ test("versions should be globally accessible regardless of version context", asy
     const lix = await openLix({});
     // Create required change sets
     await lix.db
-        .insertInto("change_set_all")
+        .insertInto("change_set_by_version")
         .values([
         { id: "cs_a", lixcol_version_id: "global" },
         { id: "cs_b", lixcol_version_id: "global" },
         { id: "cs_c", lixcol_version_id: "global" },
     ])
         .execute();
+    // Create working change sets
+    await lix.db
+        .insertInto("change_set_by_version")
+        .values([
+        { id: "working_cs_a", lixcol_version_id: "global" },
+        { id: "working_cs_b", lixcol_version_id: "global" },
+        { id: "working_cs_c", lixcol_version_id: "global" },
+    ])
+        .execute();
+    // Create required commits
+    await lix.db
+        .insertInto("commit_by_version")
+        .values([
+        { id: "commit_a", change_set_id: "cs_a", lixcol_version_id: "global" },
+        { id: "commit_b", change_set_id: "cs_b", lixcol_version_id: "global" },
+        { id: "commit_c", change_set_id: "cs_c", lixcol_version_id: "global" },
+        {
+            id: "working_commit_a",
+            change_set_id: "working_cs_a",
+            lixcol_version_id: "global",
+        },
+        {
+            id: "working_commit_b",
+            change_set_id: "working_cs_b",
+            lixcol_version_id: "global",
+        },
+        {
+            id: "working_commit_c",
+            change_set_id: "working_cs_c",
+            lixcol_version_id: "global",
+        },
+    ])
+        .execute();
     // Create versions using the version view (simulating creation from different version contexts)
     await lix.db
         .insertInto("version")
@@ -345,20 +481,17 @@ test("versions should be globally accessible regardless of version context", asy
         {
             id: "version_a",
             name: "Version A",
-            change_set_id: "cs_a",
-            working_change_set_id: "cs_a",
+            working_commit_id: "working_commit_a",
         },
         {
             id: "version_b",
             name: "Version B",
-            change_set_id: "cs_b",
-            working_change_set_id: "cs_b",
+            working_commit_id: "working_commit_b",
         },
         {
             id: "version_c",
             name: "Version C",
-            change_set_id: "cs_c",
-            working_change_set_id: "cs_c",
+            working_commit_id: "working_commit_c",
         },
     ])
         .execute();
@@ -388,17 +521,21 @@ test("mutation of a version's state should NOT lead to duplicate version entries
         .selectFrom("version")
         .where("id", "=", versionA.id)
         .groupBy("id")
-        .select(["id", "name", "change_set_id", "working_change_set_id"])
+        .select(["id", "name", "commit_id", "working_commit_id"])
         .execute();
     expect(versionsBeforeMutation).toHaveLength(1);
     expect(versionsBeforeMutation[0]).toMatchObject({
         id: versionA.id,
         name: "versionA",
-        change_set_id: expect.any(String),
-        working_change_set_id: expect.any(String),
+        commit_id: expect.any(String),
+        working_commit_id: expect.any(String),
     });
     await lix.db
-        .insertInto("state_all")
+        .insertInto("stored_schema")
+        .values({ value: testStateSchema })
+        .execute();
+    await lix.db
+        .insertInto("state_by_version")
         .values({
         entity_id: "test_entity",
         version_id: versionA.id,
@@ -413,11 +550,11 @@ test("mutation of a version's state should NOT lead to duplicate version entries
         .selectFrom("version")
         .where("id", "=", versionA.id)
         .groupBy("id")
-        .select(["id", "name", "change_set_id", "working_change_set_id"])
+        .select(["id", "name", "commit_id", "working_commit_id"])
         .execute();
     expect(versionAAfterMutation).toHaveLength(1);
     // The changeset should have advanced due to the state mutation
-    expect(versionAAfterMutation[0]?.change_set_id).not.toEqual(versionA.change_set_id);
+    expect(versionAAfterMutation[0]?.commit_id).not.toEqual(versionA.commit_id);
 });
 test("direct mutation of a version shouldn't lead to duplicate entries", async () => {
     const lix = await openLix({});
@@ -440,8 +577,8 @@ test("direct mutation of a version shouldn't lead to duplicate entries", async (
         {
             id: versionA.id,
             name: "versionA",
-            change_set_id: expect.any(String),
-            working_change_set_id: expect.any(String),
+            commit_id: expect.any(String),
+            working_commit_id: expect.any(String),
         },
     ]);
     await lix.db
@@ -465,21 +602,21 @@ test("direct mutation of a version shouldn't lead to duplicate entries", async (
         {
             id: versionA.id,
             name: "new name",
-            change_set_id: expect.any(String),
-            working_change_set_id: expect.any(String),
+            commit_id: expect.any(String),
+            working_commit_id: expect.any(String),
         },
     ]);
     // the version was updated in the global version aka
     // the versions change set did not change itself
-    expect(versionsAfterMutation[0]?.change_set_id).toEqual(versionABeforeMutation[0]?.change_set_id);
-    // but the global version's change set id should have changed
-    expect(globalVersionAfterMutation.change_set_id).not.toEqual(globalVersionBeforeMutation.change_set_id);
+    expect(versionsAfterMutation[0]?.commit_id).toEqual(versionABeforeMutation[0]?.commit_id);
+    // but the global version's commit id should have changed
+    expect(globalVersionAfterMutation.commit_id).not.toEqual(globalVersionBeforeMutation.commit_id);
 });
-test("should enforce UNIQUE constraint on working_change_set_id", async () => {
+test("should enforce UNIQUE constraint on working_commit_id", async () => {
     const lix = await openLix({});
     // Insert necessary change sets to satisfy foreign keys
     await lix.db
-        .insertInto("change_set_all")
+        .insertInto("change_set_by_version")
         .values([
         { id: "cs1", lixcol_version_id: "global" },
         { id: "cs2", lixcol_version_id: "global" },
@@ -487,14 +624,31 @@ test("should enforce UNIQUE constraint on working_change_set_id", async () => {
         { id: "workingCs2", lixcol_version_id: "global" },
     ])
         .execute();
-    // Insert first version referencing workingCs1
+    // Create required commits
+    await lix.db
+        .insertInto("commit_by_version")
+        .values([
+        { id: "commit_cs1", change_set_id: "cs1", lixcol_version_id: "global" },
+        { id: "commit_cs2", change_set_id: "cs2", lixcol_version_id: "global" },
+        {
+            id: "working_commit_1",
+            change_set_id: "workingCs1",
+            lixcol_version_id: "global",
+        },
+        {
+            id: "working_commit_2",
+            change_set_id: "workingCs2",
+            lixcol_version_id: "global",
+        },
+    ])
+        .execute();
+    // Insert first version referencing working_commit_1
     await lix.db
         .insertInto("version")
         .values({
         id: "v1",
         name: "version one",
-        change_set_id: "cs1",
-        working_change_set_id: "workingCs1",
+        working_commit_id: "working_commit_1",
     })
         .execute();
     // Attempt to insert another version referencing the SAME workingCs1 -> should fail
@@ -503,23 +657,21 @@ test("should enforce UNIQUE constraint on working_change_set_id", async () => {
         .values({
         id: "v2",
         name: "version two",
-        change_set_id: "cs2", // Different historical point is fine
-        working_change_set_id: "workingCs1", // <<< Same working_change_set_id
+        working_commit_id: "working_commit_1", // <<< Same working_commit_id
     })
-        .execute()).rejects.toThrow(/Unique constraint violation.*working_change_set_id.*workingCs1/i);
-    // Inserting another version with a DIFFERENT working_change_set_id should succeed
+        .execute()).rejects.toThrow(/Unique constraint violation.*working_commit_id.*working_commit_1/i);
+    // Inserting another version with a DIFFERENT working_commit_id should succeed
     await expect(lix.db
         .insertInto("version")
         .values({
         id: "v3",
         name: "version three",
-        change_set_id: "cs1", // Can branch from same historical point
-        working_change_set_id: "workingCs2", // <<< Different working_change_set_id
+        working_commit_id: "working_commit_2", // <<< Different working_commit_id
     })
         .execute()).resolves.toBeDefined();
 });
 // there was a bug that wiped the cache, leading to a missing change_set
-test("initial version's change_set_id and working_change_set_id should exist in the change_set table", async () => {
+test("initial version's commit_id and working_commit_id should exist in the tables", async () => {
     const lix = await openLix({});
     // Get the initial 'main' version
     const mainVersion = await lix.db
@@ -527,40 +679,55 @@ test("initial version's change_set_id and working_change_set_id should exist in
         .where("name", "=", "main")
         .selectAll()
         .executeTakeFirstOrThrow();
-    // Verify change_set_id exists in change_set table
-    const changeSet = await lix.db
-        .selectFrom("change_set")
-        .where("id", "=", mainVersion.change_set_id)
+    // Verify commit_id exists in commit table
+    const commit = await lix.db
+        .selectFrom("commit")
+        .where("id", "=", mainVersion.commit_id)
         .selectAll()
         .executeTakeFirst();
-    expect(changeSet).toBeDefined();
-    expect(changeSet?.id).toBe(mainVersion.change_set_id);
-    // Verify working_change_set_id exists in change_set table
-    const workingChangeSet = await lix.db
-        .selectFrom("change_set")
-        .where("id", "=", mainVersion.working_change_set_id)
+    expect(commit).toBeDefined();
+    expect(commit?.id).toBe(mainVersion.commit_id);
+    // Verify working_commit_id exists in commit table
+    const workingCommit = await lix.db
+        .selectFrom("commit")
+        .where("id", "=", mainVersion.working_commit_id)
         .selectAll()
         .executeTakeFirst();
-    expect(workingChangeSet).toBeDefined();
-    expect(workingChangeSet?.id).toBe(mainVersion.working_change_set_id);
+    expect(workingCommit).toBeDefined();
+    expect(workingCommit?.id).toBe(mainVersion.working_commit_id);
 });
 test("inherits_from_version_id should default to global", async () => {
     const lix = await openLix({});
     // Create required change sets first
     await lix.db
-        .insertInto("change_set_all")
+        .insertInto("change_set_by_version")
         .values([
         { id: "change_set_1", lixcol_version_id: "global" },
         { id: "working_change_set_1", lixcol_version_id: "global" },
     ])
         .execute();
+    // Create required commits
+    await lix.db
+        .insertInto("commit_by_version")
+        .values([
+        {
+            id: "commit_1",
+            change_set_id: "change_set_1",
+            lixcol_version_id: "global",
+        },
+        {
+            id: "working_commit_1",
+            change_set_id: "working_change_set_1",
+            lixcol_version_id: "global",
+        },
+    ])
+        .execute();
     await lix.db
         .insertInto("version")
         .values({
         id: "test_version",
         name: "Test Version",
-        change_set_id: "change_set_1",
-        working_change_set_id: "working_change_set_1",
+        working_commit_id: "working_commit_1",
         inherits_from_version_id: undefined, // Should default to 'global'
     })
         .execute();
@@ -586,20 +753,35 @@ test("versions should have hidden property defaulting to false", async () => {
     const lix = await openLix({});
     // Create required change sets first
     await lix.db
-        .insertInto("change_set_all")
+        .insertInto("change_set_by_version")
         .values([
         { id: "cs_test", lixcol_version_id: "global" },
         { id: "working_cs_test", lixcol_version_id: "global" },
     ])
         .execute();
+    // Create required commits
+    await lix.db
+        .insertInto("commit_by_version")
+        .values([
+        {
+            id: "commit_test",
+            change_set_id: "cs_test",
+            lixcol_version_id: "global",
+        },
+        {
+            id: "working_commit_test",
+            change_set_id: "working_cs_test",
+            lixcol_version_id: "global",
+        },
+    ])
+        .execute();
     // Insert a version without specifying hidden
     await lix.db
         .insertInto("version")
         .values({
         id: "test_version",
         name: "Test Version",
-        change_set_id: "cs_test",
-        working_change_set_id: "working_cs_test",
+        working_commit_id: "working_commit_test",
     })
         .execute();
     const version = await lix.db
@@ -634,20 +816,35 @@ test("can explicitly set hidden to true", async () => {
     const lix = await openLix({});
     // Create required change sets first
     await lix.db
-        .insertInto("change_set_all")
+        .insertInto("change_set_by_version")
         .values([
         { id: "cs_hidden", lixcol_version_id: "global" },
         { id: "working_cs_hidden", lixcol_version_id: "global" },
     ])
         .execute();
+    // Create required commits
+    await lix.db
+        .insertInto("commit_by_version")
+        .values([
+        {
+            id: "commit_hidden",
+            change_set_id: "cs_hidden",
+            lixcol_version_id: "global",
+        },
+        {
+            id: "working_commit_hidden",
+            change_set_id: "working_cs_hidden",
+            lixcol_version_id: "global",
+        },
+    ])
+        .execute();
     // Insert a version with hidden explicitly set to true
     await lix.db
         .insertInto("version")
         .values({
         id: "hidden_version",
         name: "Hidden Version",
-        change_set_id: "cs_hidden",
-        working_change_set_id: "working_cs_hidden",
+        working_commit_id: "working_commit_hidden",
         hidden: true,
     })
         .execute();
@@ -658,4 +855,217 @@ test("can explicitly set hidden to true", async () => {
         .executeTakeFirstOrThrow();
     expect(version.hidden).toBe(1);
 });
+// V2 unified view tests (merged)
+test("insert via version writes descriptor + tip when commit_id provided", async () => {
+    const lix = await openLix({});
+    await lix.db
+        .insertInto("change_set_by_version")
+        .values([
+        { id: "cs_unified_1", lixcol_version_id: "global" },
+        { id: "wcs_unified_1", lixcol_version_id: "global" },
+    ])
+        .execute();
+    await lix.db
+        .insertInto("commit_by_version")
+        .values([
+        {
+            id: "c_unified_1",
+            change_set_id: "cs_unified_1",
+            lixcol_version_id: "global",
+        },
+        {
+            id: "wc_unified_1",
+            change_set_id: "wcs_unified_1",
+            lixcol_version_id: "global",
+        },
+    ])
+        .execute();
+    await lix.db
+        .insertInto("version")
+        .values({
+        id: "v_unified_1",
+        name: "v_unified_1",
+        working_commit_id: "wc_unified_1",
+        commit_id: "c_unified_1",
+    })
+        .execute();
+    const v = await lix.db
+        .selectFrom("version")
+        .where("id", "=", "v_unified_1")
+        .selectAll()
+        .executeTakeFirstOrThrow();
+    expect(v.name).toBe("v_unified_1");
+    expect(v.working_commit_id).toBe("wc_unified_1");
+    expect(v.commit_id).toBe("c_unified_1");
+    const changes = await lix.db
+        .selectFrom("change")
+        .where("entity_id", "=", "v_unified_1")
+        .orderBy("created_at", "asc")
+        .selectAll()
+        .execute();
+    const byKey = new Map(changes.map((c) => [
+        c.schema_key,
+        typeof c.snapshot_content === "string"
+            ? JSON.parse(c.snapshot_content)
+            : c.snapshot_content,
+    ]));
+    expect(byKey.get("lix_version_descriptor")).toMatchObject({
+        id: "v_unified_1",
+        name: "v_unified_1",
+    });
+    expect(byKey.get("lix_version_tip")).toMatchObject({
+        id: "v_unified_1",
+        commit_id: "c_unified_1",
+        working_commit_id: "wc_unified_1",
+    });
+});
+test("insert via version without commit_id auto-inserts a tip", async () => {
+    const lix = await openLix({});
+    await lix.db
+        .insertInto("change_set_by_version")
+        .values([{ id: "wcs_unified_2", lixcol_version_id: "global" }])
+        .execute();
+    await lix.db
+        .insertInto("commit_by_version")
+        .values([
+        {
+            id: "wc_unified_2",
+            change_set_id: "wcs_unified_2",
+            lixcol_version_id: "global",
+        },
+    ])
+        .execute();
+    await lix.db
+        .insertInto("version")
+        .values({
+        id: "v_unified_2",
+        name: "v_unified_2",
+        working_commit_id: "wc_unified_2",
+    })
+        .execute();
+    const v = await lix.db
+        .selectFrom("version")
+        .where("id", "=", "v_unified_2")
+        .selectAll()
+        .executeTakeFirstOrThrow();
+    expect(typeof v.commit_id).toBe("string");
+    expect(v.commit_id.length).toBeGreaterThan(0);
+    const tipRows = await lix.db
+        .selectFrom("change")
+        .where("entity_id", "=", "v_unified_2")
+        .where("schema_key", "=", "lix_version_tip")
+        .selectAll()
+        .execute();
+    expect(tipRows.length).toBe(1);
+});
+test("insert via version_by_version writes descriptor + tip in scoped version", async () => {
+    const lix = await openLix({});
+    await lix.db
+        .insertInto("change_set_by_version")
+        .values([
+        { id: "cs_unified_3", lixcol_version_id: "global" },
+        { id: "wcs_unified_3", lixcol_version_id: "global" },
+    ])
+        .execute();
+    await lix.db
+        .insertInto("commit_by_version")
+        .values([
+        {
+            id: "c_unified_3",
+            change_set_id: "cs_unified_3",
+            lixcol_version_id: "global",
+        },
+        {
+            id: "wc_unified_3",
+            change_set_id: "wcs_unified_3",
+            lixcol_version_id: "global",
+        },
+    ])
+        .execute();
+    await lix.db
+        .insertInto("version_by_version")
+        .values({
+        id: "v_unified_3",
+        name: "v_unified_3",
+        working_commit_id: "wc_unified_3",
+        commit_id: "c_unified_3",
+        lixcol_version_id: "global",
+    })
+        .execute();
+    const v = await lix.db
+        .selectFrom("version")
+        .where("id", "=", "v_unified_3")
+        .selectAll()
+        .executeTakeFirstOrThrow();
+    expect(v.commit_id).toBe("c_unified_3");
+});
+test("commit_id FK uses materialized mode (lenient on insert)", async () => {
+    const lix = await openLix({});
+    await lix.db
+        .insertInto("change_set_by_version")
+        .values([{ id: "wcs_unified_6", lixcol_version_id: "global" }])
+        .execute();
+    await lix.db
+        .insertInto("commit_by_version")
+        .values([
+        {
+            id: "wc_unified_6",
+            change_set_id: "wcs_unified_6",
+            lixcol_version_id: "global",
+        },
+    ])
+        .execute();
+    await expect(lix.db
+        .insertInto("version")
+        .values({
+        id: "v_unified_6",
+        name: "v_unified_6",
+        working_commit_id: "wc_unified_6",
+        commit_id: "does_not_exist",
+    })
+        .execute()).resolves.toBeDefined();
+});
+test("delete via version writes descriptor + tip tombstones", async () => {
+    const lix = await openLix({});
+    await lix.db
+        .insertInto("change_set_by_version")
+        .values([
+        { id: "cs_unified_7", lixcol_version_id: "global" },
+        { id: "wcs_unified_7", lixcol_version_id: "global" },
+    ])
+        .execute();
+    await lix.db
+        .insertInto("commit_by_version")
+        .values([
+        {
+            id: "c_unified_7",
+            change_set_id: "cs_unified_7",
+            lixcol_version_id: "global",
+        },
+        {
+            id: "wc_unified_7",
+            change_set_id: "wcs_unified_7",
+            lixcol_version_id: "global",
+        },
+    ])
+        .execute();
+    await lix.db
+        .insertInto("version")
+        .values({
+        id: "v_unified_7",
+        name: "v_unified_7",
+        working_commit_id: "wc_unified_7",
+        commit_id: "c_unified_7",
+    })
+        .execute();
+    await lix.db.deleteFrom("version").where("id", "=", "v_unified_7").execute();
+    const changes = await lix.db
+        .selectFrom("change")
+        .where("entity_id", "=", "v_unified_7")
+        .orderBy("created_at", "asc")
+        .selectAll()
+        .execute();
+    const tombstones = changes.filter((c) => c.snapshot_content === null || c.snapshot_content === undefined);
+    expect(tombstones.length).toBeGreaterThanOrEqual(2);
+});
 //# sourceMappingURL=schema.test.js.map