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

package/dist/state-history/schema.test.js

@@ -1,8 +1,9 @@
 /* eslint-disable @typescript-eslint/no-unused-vars */
 import { test, expect } from "vitest";
 import { openLix } from "../lix/open-lix.js";
-import { createCheckpoint } from "../change-set/create-checkpoint.js";
-import { changeSetHasLabel, changeSetIsAncestorOf, changeSetIsDescendantOf, } from "../query-filter/index.js";
+import { createCheckpoint } from "../commit/create-checkpoint.js";
+import { commitIsDescendantOf, commitIsAncestorOf, } from "../query-filter/index.js";
+import { ebEntity } from "../entity/index.js";
 test("query current state at head of version lineage", async () => {
     const lix = await openLix({});
     const mockSchema = {
@@ -35,19 +36,19 @@ test("query current state at head of version lineage", async () => {
     const activeVersion = await lix.db
         .selectFrom("active_version")
         .innerJoin("version", "active_version.version_id", "version.id")
-        .select("version.change_set_id")
+        .select("version.commit_id")
         .executeTakeFirstOrThrow();
-    // Query current state using change_set_id
+    // Query current state using commit_id
     const currentState = await lix.db
         .selectFrom("state_history")
         .where("entity_id", "=", "paragraph0")
-        .where("change_set_id", "=", activeVersion.change_set_id)
+        .where("root_commit_id", "=", activeVersion.commit_id)
         .selectAll()
         .execute();
     expect(currentState).toHaveLength(1);
     expect(currentState[0]).toMatchObject({
         entity_id: "paragraph0",
-        change_set_id: activeVersion.change_set_id,
+        commit_id: activeVersion.commit_id,
         depth: 0,
         snapshot_content: { value: "initial content" },
     });
@@ -93,13 +94,13 @@ test("query state at specific depth in history", async () => {
     const activeVersion = await lix.db
         .selectFrom("active_version")
         .innerJoin("version", "active_version.version_id", "version.id")
-        .select("version.change_set_id")
+        .select("version.commit_id")
         .executeTakeFirstOrThrow();
     // Query current state (depth 0)
     const currentState = await lix.db
         .selectFrom("state_history")
         .where("entity_id", "=", "paragraph0")
-        .where("change_set_id", "=", activeVersion.change_set_id)
+        .where("root_commit_id", "=", activeVersion.commit_id)
         .where("depth", "=", 0)
         .selectAll()
         .execute();
@@ -109,7 +110,7 @@ test("query state at specific depth in history", async () => {
     const previousState = await lix.db
         .selectFrom("state_history")
         .where("entity_id", "=", "paragraph0")
-        .where("change_set_id", "=", activeVersion.change_set_id)
+        .where("root_commit_id", "=", activeVersion.commit_id)
         .where("depth", "=", 1)
         .selectAll()
         .execute();
@@ -119,42 +120,119 @@ test("query state at specific depth in history", async () => {
     const oldestState = await lix.db
         .selectFrom("state_history")
         .where("entity_id", "=", "paragraph0")
-        .where("change_set_id", "=", activeVersion.change_set_id)
+        .where("root_commit_id", "=", activeVersion.commit_id)
         .where("depth", "=", 2)
         .selectAll()
         .execute();
     expect(oldestState).toHaveLength(1);
     expect(oldestState[0]?.snapshot_content).toEqual({ value: "value0" });
 });
-test("query state at specific change set", async () => {
-    const lix = await openLix({});
+test("query state at specific commit", async () => {
+    const lix = await openLix({
+        keyValues: [
+            {
+                key: "lix_deterministic_mode",
+                value: { enabled: true, bootstrap: true },
+                lixcol_version_id: "global",
+            },
+        ],
+    });
     const mockSchema = {
-        "x-lix-key": "mock_schema",
+        "x-lix-key": "mock_entity",
         "x-lix-version": "1.0",
         additionalProperties: false,
         type: "object",
         properties: {
+            id: { type: "string" },
             value: { type: "string" },
         },
+        "x-lix-primary-key": ["id"],
     };
     await lix.db
         .insertInto("stored_schema")
         .values({ value: mockSchema })
         .execute();
-    // Create multiple change sets
+    // Get the active version before insert
+    const versionBeforeInsert = await lix.db
+        .selectFrom("active_version")
+        .innerJoin("version", "version.id", "active_version.version_id")
+        .select(["version.commit_id"])
+        .executeTakeFirstOrThrow();
+    // Insert initial state
     await lix.db
-        .insertInto("change_set")
-        .values([{ id: "changeset1" }, { id: "changeset2" }, { id: "current" }])
+        .insertInto("state")
+        .values({
+        entity_id: "test-entity-1",
+        schema_key: "mock_entity",
+        file_id: "test.json",
+        schema_version: "1.0",
+        plugin_key: "mock_plugin",
+        snapshot_content: { id: "test-entity-1", value: "initial value" },
+    })
         .execute();
-    // Query state at specific change sets
-    const changeSetStates = await lix.db
+    // Get the active version after insert
+    const stateAfterInsert = await lix.db
+        .selectFrom("state")
+        .where("entity_id", "=", "test-entity-1")
+        .select(["entity_id", "snapshot_content", "commit_id"])
+        .executeTakeFirstOrThrow();
+    const insertCommitId = stateAfterInsert.commit_id;
+    // Verify commit changed after insert
+    expect(insertCommitId).not.toBe(versionBeforeInsert.commit_id);
+    // Query state history at the insert commit
+    const historyAtInsert = await lix.db
         .selectFrom("state_history")
-        .where("entity_id", "=", "paragraph0")
-        .where("change_set_id", "in", ["changeset1", "changeset2"])
-        .selectAll()
+        .where("entity_id", "=", "test-entity-1")
+        .where("root_commit_id", "=", insertCommitId)
+        .select(["entity_id", "snapshot_content", "root_commit_id"])
+        .executeTakeFirstOrThrow();
+    // Verify the history shows the inserted state
+    expect(historyAtInsert.snapshot_content).toEqual({
+        id: "test-entity-1",
+        value: "initial value",
+    });
+    expect(historyAtInsert.root_commit_id).toBe(insertCommitId);
+    // Update the entity
+    await lix.db
+        .updateTable("state")
+        .set({
+        snapshot_content: { id: "test-entity-1", value: "updated value" },
+    })
+        .where("entity_id", "=", "test-entity-1")
         .execute();
-    // Should be able to query both change sets (even if no data exists yet)
-    expect(changeSetStates.length).toBeGreaterThanOrEqual(0);
+    // Get the commit ID after update
+    const stateAfterUpdate = await lix.db
+        .selectFrom("state")
+        .where("entity_id", "=", "test-entity-1")
+        .select(["entity_id", "snapshot_content", "commit_id"])
+        .executeTakeFirstOrThrow();
+    const updateCommitId = stateAfterUpdate.commit_id;
+    // Verify commit changed
+    expect(updateCommitId).not.toBe(insertCommitId);
+    // Query state history at the update commit
+    const historyAtUpdate = await lix.db
+        .selectFrom("state_history")
+        .where("entity_id", "=", "test-entity-1")
+        .where("root_commit_id", "=", updateCommitId)
+        .select(["entity_id", "snapshot_content", "root_commit_id"])
+        .executeTakeFirstOrThrow();
+    // Verify the history shows the updated state
+    expect(historyAtUpdate.snapshot_content).toEqual({
+        id: "test-entity-1",
+        value: "updated value",
+    });
+    expect(historyAtUpdate.root_commit_id).toBe(updateCommitId);
+    // Also verify we can still query the old state at the insert commit
+    const historyAtInsertAgain = await lix.db
+        .selectFrom("state_history")
+        .where("entity_id", "=", "test-entity-1")
+        .where("root_commit_id", "=", insertCommitId)
+        .select(["entity_id", "snapshot_content", "root_commit_id"])
+        .executeTakeFirstOrThrow();
+    expect(historyAtInsertAgain.snapshot_content).toEqual({
+        id: "test-entity-1",
+        value: "initial value",
+    });
 });
 test("query state at checkpoint using createCheckpoint API", async () => {
     const lix = await openLix({});
@@ -190,7 +268,7 @@ test("query state at checkpoint using createCheckpoint API", async () => {
     const checkpointState = await lix.db
         .selectFrom("state_history")
         .where("entity_id", "=", "paragraph0")
-        .where("change_set_id", "=", checkpoint.id)
+        .where("root_commit_id", "=", checkpoint.id)
         .where("depth", "=", 0)
         .selectAll()
         .execute();
@@ -198,7 +276,7 @@ test("query state at checkpoint using createCheckpoint API", async () => {
     expect(checkpointState[0]?.snapshot_content).toEqual({
         value: "checkpoint content",
     });
-    expect(checkpointState[0]?.change_set_id).toBe(checkpoint.id);
+    expect(checkpointState[0]?.commit_id).toBe(checkpoint.id);
 });
 test("diff detection between current and checkpoint state", async () => {
     const lix = await openLix({});
@@ -240,13 +318,13 @@ test("diff detection between current and checkpoint state", async () => {
     const updatedVersion = await lix.db
         .selectFrom("active_version")
         .innerJoin("version", "active_version.version_id", "version.id")
-        .select("version.change_set_id")
+        .select("version.commit_id")
         .executeTakeFirstOrThrow();
     // Query current state (depth 0 only)
     const currentState = await lix.db
         .selectFrom("state_history")
         .where("entity_id", "=", "paragraph0")
-        .where("change_set_id", "=", updatedVersion.change_set_id)
+        .where("root_commit_id", "=", updatedVersion.commit_id)
         .where("depth", "=", 0)
         .selectAll()
         .execute();
@@ -254,15 +332,15 @@ test("diff detection between current and checkpoint state", async () => {
     const checkpointState = await lix.db
         .selectFrom("state_history")
         .where("entity_id", "=", "paragraph0")
-        .where("change_set_id", "=", checkpoint.id)
+        .where("root_commit_id", "=", checkpoint.id)
         .where("depth", "=", 0)
         .selectAll()
         .execute();
     // Verify diff detection logic
     expect(currentState).toHaveLength(1);
     expect(checkpointState).toHaveLength(1);
-    // Different change_set_ids indicate diff detected
-    expect(currentState[0]?.change_set_id).not.toBe(checkpointState[0]?.change_set_id);
+    // Different commit_ids indicate diff detected
+    expect(currentState[0]?.commit_id).not.toBe(checkpointState[0]?.commit_id);
     expect(currentState[0]?.snapshot_content).toEqual({ value: "modified" });
     expect(checkpointState[0]?.snapshot_content).toEqual({ value: "initial" });
 });
@@ -304,13 +382,13 @@ test("deletion diff - entity exists at checkpoint but not current", async () =>
     const updatedVersion = await lix.db
         .selectFrom("active_version")
         .innerJoin("version", "active_version.version_id", "version.id")
-        .select("version.change_set_id")
+        .select("version.commit_id")
         .executeTakeFirstOrThrow();
     // Query current state (should be empty after deletion)
     const currentState = await lix.db
         .selectFrom("state_history")
         .where("entity_id", "=", "paragraph0")
-        .where("change_set_id", "=", updatedVersion.change_set_id)
+        .where("root_commit_id", "=", updatedVersion.commit_id)
         .where("depth", "=", 0)
         .selectAll()
         .execute();
@@ -318,7 +396,7 @@ test("deletion diff - entity exists at checkpoint but not current", async () =>
     const checkpointState = await lix.db
         .selectFrom("state_history")
         .where("entity_id", "=", "paragraph0")
-        .where("change_set_id", "=", checkpoint.id)
+        .where("root_commit_id", "=", checkpoint.id)
         .where("depth", "=", 0)
         .selectAll()
         .execute();
@@ -362,13 +440,13 @@ test("insertion diff - entity exists current but not at checkpoint", async () =>
     const updatedVersion = await lix.db
         .selectFrom("active_version")
         .innerJoin("version", "active_version.version_id", "version.id")
-        .select("version.change_set_id")
+        .select("version.commit_id")
         .executeTakeFirstOrThrow();
     // Query current state (should exist at depth 0)
     const currentState = await lix.db
         .selectFrom("state_history")
         .where("entity_id", "=", "paragraph0")
-        .where("change_set_id", "=", updatedVersion.change_set_id)
+        .where("root_commit_id", "=", updatedVersion.commit_id)
         .where("depth", "=", 0)
         .selectAll()
         .execute();
@@ -376,7 +454,7 @@ test("insertion diff - entity exists current but not at checkpoint", async () =>
     const checkpointState = await lix.db
         .selectFrom("state_history")
         .where("entity_id", "=", "paragraph0")
-        .where("change_set_id", "=", checkpoint.id)
+        .where("root_commit_id", "=", checkpoint.id)
         .where("depth", "=", 0)
         .selectAll()
         .execute();
@@ -403,39 +481,38 @@ test("blame functionality - track entity changes over time", async () => {
         .insertInto("stored_schema")
         .values({ value: mockSchema })
         .execute();
-    // Simulate multiple edits by different authors
+    // Simulate multiple edits
     await lix.db
-        .insertInto("state_all")
+        .insertInto("state")
         .values({
         entity_id: "paragraph0",
         file_id: "f0",
         schema_key: "mock_schema",
         plugin_key: "lix_own_entity",
-        version_id: lix.db.selectFrom("active_version").select("version_id"),
         schema_version: "1.0",
-        snapshot_content: { value: "alice's draft", author: "alice" },
+        snapshot_content: { value: "initial", author: "alice" },
     })
         .execute();
     await lix.db
-        .updateTable("state_all")
-        .set({ snapshot_content: { value: "bob's revision", author: "bob" } })
+        .updateTable("state")
+        .set({ snapshot_content: { value: "update", author: "bob" } })
         .where("entity_id", "=", "paragraph0")
         .execute();
     await lix.db
-        .updateTable("state_all")
-        .set({ snapshot_content: { value: "charlie's final", author: "charlie" } })
+        .updateTable("state")
+        .set({ snapshot_content: { value: "final", author: "charlie" } })
         .where("entity_id", "=", "paragraph0")
         .execute();
     const activeVersion = await lix.db
         .selectFrom("active_version")
         .innerJoin("version", "active_version.version_id", "version.id")
-        .select("version.change_set_id")
+        .select("version.commit_id")
         .executeTakeFirstOrThrow();
     // Query recent history for blame (last 3 changes)
     const recentHistory = await lix.db
         .selectFrom("state_history")
         .where("entity_id", "=", "paragraph0")
-        .where("change_set_id", "=", activeVersion.change_set_id)
+        .where("root_commit_id", "=", activeVersion.commit_id)
         .where("depth", "<=", 2)
         .orderBy("depth", "asc")
         .selectAll()
@@ -443,15 +520,15 @@ test("blame functionality - track entity changes over time", async () => {
     expect(recentHistory).toHaveLength(3);
     // Should show evolution from oldest to newest
     expect(recentHistory[2]?.snapshot_content).toEqual({
-        value: "alice's draft",
+        value: "initial",
         author: "alice",
     }); // depth 2 (oldest)
     expect(recentHistory[1]?.snapshot_content).toEqual({
-        value: "bob's revision",
+        value: "update",
         author: "bob",
     }); // depth 1
     expect(recentHistory[0]?.snapshot_content).toEqual({
-        value: "charlie's final",
+        value: "final",
         author: "charlie",
     }); // depth 0 (newest)
 });
@@ -501,13 +578,13 @@ test("working change set diff - compare current vs checkpoints", async () => {
     const activeVersion = await lix.db
         .selectFrom("active_version")
         .innerJoin("version", "active_version.version_id", "version.id")
-        .select("version.change_set_id")
+        .select("version.commit_id")
         .executeTakeFirstOrThrow();
     // Query current working state (depth 0 only)
     const currentState = await lix.db
         .selectFrom("state_history")
         .where("entity_id", "=", "paragraph0")
-        .where("change_set_id", "=", activeVersion.change_set_id)
+        .where("root_commit_id", "=", activeVersion.commit_id)
         .where("depth", "=", 0)
         .selectAll()
         .execute();
@@ -515,7 +592,7 @@ test("working change set diff - compare current vs checkpoints", async () => {
     const checkpointStates = await lix.db
         .selectFrom("state_history")
         .where("entity_id", "=", "paragraph0")
-        .where("change_set_id", "in", [checkpoint1.id, checkpoint2.id])
+        .where("root_commit_id", "in", [checkpoint1.id, checkpoint2.id])
         .where("depth", "=", 0)
         .selectAll()
         .execute();
@@ -525,12 +602,12 @@ test("working change set diff - compare current vs checkpoints", async () => {
         value: "working content",
     });
     expect(checkpointStates).toHaveLength(2);
-    expect(checkpointStates.find((s) => s.change_set_id === checkpoint1.id)
+    expect(checkpointStates.find((s) => s.commit_id === checkpoint1.id)
         ?.snapshot_content).toEqual({ value: "checkpoint 1 content" });
-    expect(checkpointStates.find((s) => s.change_set_id === checkpoint2.id)
+    expect(checkpointStates.find((s) => s.commit_id === checkpoint2.id)
         ?.snapshot_content).toEqual({ value: "checkpoint 2 content" });
 });
-test("query history between two change sets using ancestor/descendant filters", async () => {
+test("query history between two commits using ancestor/descendant filters", async () => {
     const lix = await openLix({});
     const mockSchema = {
         "x-lix-key": "mock_schema",
@@ -581,23 +658,23 @@ test("query history between two change sets using ancestor/descendant filters",
         .execute();
     const checkpoint4 = await createCheckpoint({ lix });
     // Query history between checkpoint1 and checkpoint4 (should include checkpoint2 and checkpoint3)
-    const betweenChangeSets = await lix.db
-        .selectFrom("change_set")
-        .where(changeSetIsDescendantOf({ id: checkpoint1.id }))
-        .where(changeSetIsAncestorOf({ id: checkpoint4.id }))
-        .where(changeSetHasLabel({ name: "checkpoint" }))
+    const betweenCommits = await lix.db
+        .selectFrom("commit")
+        .where(commitIsDescendantOf({ id: checkpoint1.id }))
+        .where(commitIsAncestorOf({ id: checkpoint4.id }))
+        .where(ebEntity("commit").hasLabel({ name: "checkpoint" }))
         .select("id")
         .execute();
     // Should find checkpoint2 and checkpoint3 (between checkpoint1 and checkpoint4)
-    expect(betweenChangeSets).toHaveLength(2);
-    const betweenIds = betweenChangeSets.map((cs) => cs.id);
+    expect(betweenCommits).toHaveLength(2);
+    const betweenIds = betweenCommits.map((c) => c.id);
     expect(betweenIds).toContain(checkpoint2.id);
     expect(betweenIds).toContain(checkpoint3.id);
     // Query state_history for entities in the range between checkpoint1 and checkpoint4
     const historyInRange = await lix.db
         .selectFrom("state_history")
         .where("entity_id", "=", "tracked-entity")
-        .where("change_set_id", "in", [checkpoint2.id, checkpoint3.id])
+        .where("root_commit_id", "in", [checkpoint2.id, checkpoint3.id])
         .where("depth", "=", 0)
         .orderBy("change_id", "asc")
         .selectAll()
@@ -645,7 +722,7 @@ test.skip("parent_change_set_ids field shows correct parent relationships", asyn
     const changeSet1 = await lix.db
         .selectFrom("active_version")
         .innerJoin("version", "active_version.version_id", "version.id")
-        .select("version.change_set_id")
+        .select("version.commit_id")
         .executeTakeFirstOrThrow();
     // Update entity to value1
     await lix.db
@@ -657,7 +734,7 @@ test.skip("parent_change_set_ids field shows correct parent relationships", asyn
     const changeSet2 = await lix.db
         .selectFrom("active_version")
         .innerJoin("version", "active_version.version_id", "version.id")
-        .select("version.change_set_id")
+        .select("version.commit_id")
         .executeTakeFirstOrThrow();
     // Update entity to value2
     await lix.db
@@ -669,13 +746,13 @@ test.skip("parent_change_set_ids field shows correct parent relationships", asyn
     const changeSet3 = await lix.db
         .selectFrom("active_version")
         .innerJoin("version", "active_version.version_id", "version.id")
-        .select("version.change_set_id")
+        .select("version.commit_id")
         .executeTakeFirstOrThrow();
     // Query all history in one go using the final change set
     const history = await lix.db
         .selectFrom("state_history")
         .where("entity_id", "=", "test-entity")
-        .where("change_set_id", "=", changeSet3.change_set_id)
+        // .where("root_change_set_id", "=", changeSet3.change_set_id)
         .orderBy("depth", "asc")
         .selectAll()
         .execute();
@@ -698,4 +775,81 @@ test.skip("parent_change_set_ids field shows correct parent relationships", asyn
     // // The oldest state (depth 2) should show parents for changeSet1 (may be empty or have working change set)
     // expect(Array.isArray(history[2]?.parent_change_set_ids)).toBe(true);
 });
+test("querying the history of the working change set", async () => {
+    const lix = await openLix({
+        keyValues: [{ key: "lix_debug", value: "true" }],
+    });
+    const mockSchema = {
+        "x-lix-key": "mock_schema",
+        "x-lix-version": "1.0",
+        additionalProperties: false,
+        type: "object",
+        properties: {
+            value: { type: "string" },
+        },
+    };
+    await lix.db
+        .insertInto("stored_schema")
+        .values({ value: mockSchema })
+        .execute();
+    // Insert initial entity
+    await lix.db
+        .insertInto("state")
+        .values({
+        entity_id: "entity0",
+        file_id: "f0",
+        schema_key: "mock_schema",
+        plugin_key: "lix_own_entity",
+        schema_version: "1.0",
+        snapshot_content: { value: "initial content" },
+    })
+        .execute();
+    const checkpoint0 = await createCheckpoint({ lix });
+    // Modify the entity
+    await lix.db
+        .updateTable("state")
+        .set({ snapshot_content: { value: "modified content" } })
+        .where("entity_id", "=", "entity0")
+        .execute();
+    const checkpoint1 = await createCheckpoint({ lix });
+    const activeVersion = await lix.db
+        .selectFrom("active_version")
+        .innerJoin("version", "active_version.version_id", "version.id")
+        .select(["version.working_commit_id", "version.commit_id"])
+        .executeTakeFirstOrThrow();
+    const checkpoint1History = await lix.db
+        .selectFrom("state_history")
+        .where("entity_id", "=", "entity0")
+        .where("root_commit_id", "=", checkpoint1.id)
+        .innerJoin("commit", "state_history.commit_id", "commit.id")
+        .where(ebEntity("commit").hasLabel({ name: "checkpoint" }))
+        .orderBy("depth", "asc")
+        .selectAll()
+        .execute();
+    expect(checkpoint1History).toHaveLength(2);
+    expect(checkpoint1History[0]?.commit_id).toBe(checkpoint1.id);
+    expect(checkpoint1History[0]?.snapshot_content).toEqual({
+        value: "modified content",
+    });
+    expect(checkpoint1History[1]?.commit_id).toBe(checkpoint0.id);
+    expect(checkpoint1History[1]?.snapshot_content).toEqual({
+        value: "initial content",
+    });
+    const workingHistory = await lix.db
+        .selectFrom("state_history")
+        .where("entity_id", "=", "entity0")
+        .where("root_commit_id", "=", activeVersion.commit_id)
+        .innerJoin("commit", "state_history.commit_id", "commit.id")
+        .where(ebEntity("commit").hasLabel({ name: "checkpoint" }))
+        .orderBy("depth", "asc")
+        .selectAll()
+        .execute();
+    expect(workingHistory).toHaveLength(2);
+    expect(workingHistory[0]?.snapshot_content).toEqual({
+        value: "modified content",
+    });
+    expect(workingHistory[1]?.snapshot_content).toEqual({
+        value: "initial content",
+    });
+});
 //# sourceMappingURL=schema.test.js.map