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

package/src/{change-set/create-merge-change-set.test.ts → commit/create-merge-commit.test.ts}

@@ -1,15 +1,18 @@
 import { expect, test } from "vitest";
 import { openLix } from "../lix/open-lix.js";
-import { createMergeChangeSet } from "./create-merge-change-set.js";
-import { createChangeSet } from "./create-change-set.js";
+import { createMergeCommit } from "./create-merge-commit.js";
+import { createChangeSet } from "../change-set/create-change-set.js";
+import { createCommit } from "./create-commit.js";
 import type { LixSchemaDefinition } from "../schema-definition/definition.js";
 
 test("it should merge non-conflicting changes", async () => {
 	const lix = await openLix({});
 
 	await lix.db
-		.insertInto("stored_schema")
+		.insertInto("stored_schema_all")
 		.values({
+			key: "test_schema",
+			version: "1.0",
 			value: {
 				"x-lix-key": "test_schema",
 				"x-lix-version": "1.0",
@@ -20,6 +23,7 @@ test("it should merge non-conflicting changes", async () => {
 				},
 				required: ["id"],
 			} satisfies LixSchemaDefinition,
+			lixcol_version_id: "global",
 		})
 		.execute();
 
@@ -65,7 +69,9 @@ test("it should merge non-conflicting changes", async () => {
 			schema_key: change.schema_key,
 			file_id: change.file_id,
 		})),
+		lixcol_version_id: "global",
 	});
+	const commit0 = await createCommit({ lix, changeSet: cs0 });
 
 	const cs1 = await createChangeSet({
 		lix,
@@ -75,7 +81,9 @@ test("it should merge non-conflicting changes", async () => {
 			schema_key: change.schema_key,
 			file_id: change.file_id,
 		})),
+		lixcol_version_id: "global",
 	});
+	const commit1 = await createCommit({ lix, changeSet: cs1 });
 
 	// simulating graph relation
 	const cs2 = await createChangeSet({
@@ -86,18 +94,23 @@ test("it should merge non-conflicting changes", async () => {
 			schema_key: change.schema_key,
 			file_id: change.file_id,
 		})),
-		parents: [cs1],
+		lixcol_version_id: "global",
+	});
+	const commit2 = await createCommit({
+		lix,
+		changeSet: cs2,
+		parentCommits: [commit1],
 	});
 
-	const merged = await createMergeChangeSet({
+	const merged = await createMergeCommit({
 		lix,
-		source: cs0,
-		target: cs2,
+		source: commit0,
+		target: commit2,
 	});
 
 	const mergedElements = await lix.db
 		.selectFrom("change_set_element")
-		.where("change_set_element.change_set_id", "=", merged.id)
+		.where("change_set_element.change_set_id", "=", merged.change_set_id)
 		.selectAll()
 		.execute();
 
@@ -111,8 +124,10 @@ test("should handle conflicting elements with source winning (until conflicts ar
 	const lix = await openLix({});
 
 	await lix.db
-		.insertInto("stored_schema")
+		.insertInto("stored_schema_all")
 		.values({
+			key: "s1",
+			version: "1.0",
 			value: {
 				"x-lix-key": "s1",
 				"x-lix-version": "1.0",
@@ -124,6 +139,7 @@ test("should handle conflicting elements with source winning (until conflicts ar
 				},
 				required: ["id"],
 			} satisfies LixSchemaDefinition,
+			lixcol_version_id: "global",
 		})
 		.execute();
 
@@ -171,6 +187,11 @@ test("should handle conflicting elements with source winning (until conflicts ar
 			schema_key: change.schema_key,
 			file_id: change.file_id,
 		})),
+		lixcol_version_id: "global",
+	});
+	const commit_base = await createCommit({
+		lix,
+		changeSet: cs_base,
 	});
 
 	// 2. Target branch - modifies e1
@@ -182,7 +203,12 @@ test("should handle conflicting elements with source winning (until conflicts ar
 			schema_key: change.schema_key,
 			file_id: change.file_id,
 		})),
-		parents: [cs_base],
+		lixcol_version_id: "global",
+	});
+	const commit_target = await createCommit({
+		lix,
+		changeSet: cs_target,
+		parentCommits: [commit_base],
 	});
 
 	// 3. Source branch - modifies e1 differently
@@ -194,20 +220,25 @@ test("should handle conflicting elements with source winning (until conflicts ar
 			schema_key: change.schema_key,
 			file_id: change.file_id,
 		})),
-		parents: [cs_base],
+		lixcol_version_id: "global",
+	});
+	const commit_source = await createCommit({
+		lix,
+		changeSet: cs_source,
+		parentCommits: [commit_base],
 	});
 
 	// 4. Merge source into target
-	const merged = await createMergeChangeSet({
+	const merged = await createMergeCommit({
 		lix,
-		source: cs_source,
-		target: cs_target,
+		source: commit_source,
+		target: commit_target,
 	});
 
 	// 5. Verify merged change set elements
 	const mergedElements = await lix.db
 		.selectFrom("change_set_element")
-		.where("change_set_element.change_set_id", "=", merged.id)
+		.where("change_set_element.change_set_id", "=", merged.change_set_id)
 		.selectAll()
 		.execute();
 
@@ -215,7 +246,7 @@ test("should handle conflicting elements with source winning (until conflicts ar
 	expect(mergedElements).toHaveLength(1);
 	expect(mergedElements[0]).toEqual(
 		expect.objectContaining({
-			change_set_id: merged.id,
+			change_set_id: merged.change_set_id,
 			change_id: changes[2]!.id,
 			entity_id: changes[2]!.entity_id,
 			schema_key: changes[2]!.schema_key,
@@ -223,15 +254,15 @@ test("should handle conflicting elements with source winning (until conflicts ar
 		})
 	);
 
-	// 6. Verify graph structure
+	// 6. Verify graph structure - the merged commit should have edges pointing to both source and target
 	const edges = await lix.db
-		.selectFrom("change_set_edge")
+		.selectFrom("commit_edge")
 		.where("child_id", "=", merged.id)
 		.selectAll()
 		.execute();
 
 	expect(edges).toHaveLength(2);
 	expect(edges.map((e) => e.parent_id).sort()).toEqual(
-		[cs_source.id, cs_target.id].sort()
+		[commit_source.id, commit_target.id].sort()
 	);
 });

package/src/{change-set/create-merge-change-set.ts → commit/create-merge-commit.ts}

@@ -1,29 +1,31 @@
 import type { Lix } from "../lix/open-lix.js";
 import { changeSetElementInAncestryOf } from "../query-filter/change-set-element-in-ancestry-of.js";
 import { changeSetElementIsLeafOf } from "../query-filter/change-set-element-is-leaf-of.js";
-import { createChangeSet } from "./create-change-set.js";
-import type { ChangeSet } from "./schema.js";
+import { createChangeSet } from "../change-set/create-change-set.js";
+import type { LixCommit } from "./schema.js";
+import { uuidV7 } from "../deterministic/uuid-v7.js";
 
 /**
- * Merges two change sets using a "source wins" strategy (until lix models conflicts).
+ * Merges two commits using a "source wins" strategy (until lix models conflicts).
  *
- * Creates a new change set containing the merged result. If an element
- * (identified by entity_id, file_id, schema_key) exists in both the source
- * and target change sets (considering their respective histories), the element
- * from the source change set's history takes precedence.
+ * Creates a new change set containing the merged result and a commit that
+ * points to both source and target commits. If an element (identified by
+ * entity_id, file_id, schema_key) exists in both the source and target
+ * commits (considering their respective histories), the element from the
+ * source commit's history takes precedence.
  *
  * @param args - The arguments for the merge operation.
  * @param args.lix - The Lix instance.
- * @param args.source - The source change set (only `id` is needed).
- * @param args.target - The target change set (only `id` is needed).
+ * @param args.source - The source commit (only `id` is needed).
+ * @param args.target - The target commit (only `id` is needed).
  *
- * @returns A Promise resolving to the newly created ChangeSet representing the merged state.
+ * @returns A Promise resolving to the newly created Commit representing the merged state.
  */
-export async function createMergeChangeSet(args: {
+export async function createMergeCommit(args: {
 	lix: Lix;
-	source: Pick<ChangeSet, "id">;
-	target: Pick<ChangeSet, "id">;
-}): Promise<ChangeSet> {
+	source: Pick<LixCommit, "id">;
+	target: Pick<LixCommit, "id">;
+}): Promise<LixCommit> {
 	const executeInTransaction = async (trx: Lix["db"]) => {
 		// --- Calculate the merged elements using "source wins" logic ---
 		const mergedElements = await trx
@@ -84,10 +86,47 @@ export async function createMergeChangeSet(args: {
 				schema_key: ce.schema_key,
 				file_id: ce.file_id,
 			})),
-			parents: [args.source, args.target],
+			lixcol_version_id: "global",
 		});
 
-		return newChangeSet;
+		// Create a commit for the merged change set
+		const commitId = uuidV7({ lix: args.lix });
+
+		// Insert the commit
+		await trx
+			.insertInto("commit_all")
+			.values({
+				id: commitId,
+				change_set_id: newChangeSet.id,
+				lixcol_version_id: "global",
+			})
+			.execute();
+
+		// Create commit edges to both parents
+		await trx
+			.insertInto("commit_edge_all")
+			.values([
+				{
+					parent_id: args.source.id,
+					child_id: commitId,
+					lixcol_version_id: "global",
+				},
+				{
+					parent_id: args.target.id,
+					child_id: commitId,
+					lixcol_version_id: "global",
+				},
+			])
+			.execute();
+
+		// Return the commit
+		const commit = await trx
+			.selectFrom("commit")
+			.where("id", "=", commitId)
+			.selectAll()
+			.executeTakeFirstOrThrow();
+
+		return commit;
 	};
 
 	// Restore transaction handling

package/src/{change-set/create-transition-change-set.test.ts → commit/create-transition-commit.test.ts}

@@ -4,29 +4,31 @@ import {
 	mockJsonPlugin,
 	MockJsonPropertySchema,
 } from "../plugin/mock-json-plugin.js";
-import { createChangeSet } from "./create-change-set.js";
-import { applyChangeSet } from "./apply-change-set.js";
-import { createTransitionChangeSet } from "./create-transition-change-set.js";
+import { createChangeSet } from "../change-set/create-change-set.js";
+import { applyChangeSet } from "../change-set/apply-change-set.js";
+import { createTransitionCommit } from "./create-transition-commit.js";
+import { createCommit } from "./create-commit.js";
 
-// needs faster graph traversal. currently timing out.
-// related https://github.com/opral/lix-sdk/issues/311
-test.skip("it transitions state to a specific change set", async () => {
+test.todo("it transitions state to a specific commit", async () => {
 	// Create a Lix instance with our plugin
 	const lix = await openLix({
 		providePlugins: [mockJsonPlugin],
 	});
 
-	const activeVersion = await lix.db
-		.selectFrom("active_version")
-		.innerJoin("version", "version.id", "active_version.version_id")
-		.selectAll("version")
-		.executeTakeFirstOrThrow();
+	// const activeVersion = await lix.db
+	// 	.selectFrom("active_version")
+	// 	.innerJoin("version", "version.id", "active_version.version_id")
+	// 	.selectAll("version")
+	// 	.executeTakeFirstOrThrow();
 
 	// Insert the schema that the mockJsonPlugin uses
 	await lix.db
-		.insertInto("stored_schema")
+		.insertInto("stored_schema_all")
 		.values({
+			key: "mock_json_property",
+			version: "1.0",
 			value: MockJsonPropertySchema,
+			lixcol_version_id: "global",
 		})
 		.execute();
 
@@ -116,7 +118,9 @@ test.skip("it transitions state to a specific change set", async () => {
 			schema_key: change.schema_key,
 			file_id: change.file_id,
 		})),
+		lixcol_version_id: "global",
 	});
+	const commit0 = await createCommit({ lix, changeSet: cs0 });
 
 	const cs1 = await createChangeSet({
 		lix,
@@ -127,7 +131,12 @@ test.skip("it transitions state to a specific change set", async () => {
 			schema_key: change.schema_key,
 			file_id: change.file_id,
 		})),
-		parents: [cs0],
+		lixcol_version_id: "global",
+	});
+	const commit1 = await createCommit({
+		lix,
+		changeSet: cs1,
+		parentCommits: [commit0],
 	});
 
 	const cs2 = await createChangeSet({
@@ -139,7 +148,12 @@ test.skip("it transitions state to a specific change set", async () => {
 			schema_key: change.schema_key,
 			file_id: change.file_id,
 		})),
-		parents: [cs1],
+		lixcol_version_id: "global",
+	});
+	const commit2 = await createCommit({
+		lix,
+		changeSet: cs2,
+		parentCommits: [commit1],
 	});
 
 	// Apply change sets in order: cs0, then cs1, then cs2
@@ -202,34 +216,31 @@ test.skip("it transitions state to a specific change set", async () => {
 
 	expect(actualJsonStateCs2).toEqual(expectedJsonStateCs2);
 
-	// Action: Create transition change set to restore to cs0
-	const transitionChangeSet = await createTransitionChangeSet({
+	// Action: Create transition commit to restore to commit0
+	const transitionCommit = await createTransitionCommit({
 		lix,
-		sourceChangeSet: cs2,
-		targetChangeSet: cs0,
+		sourceCommit: commit2,
+		targetCommit: commit0,
 	});
 
-	// Apply the transition change set
+	// Apply the transition commit
 	await applyChangeSet({
 		lix,
-		changeSet: transitionChangeSet,
+		changeSet: { id: transitionCommit.change_set_id },
 	});
 
 	// Verify final state
-	// 1. Check that versions change set parent is cs2
-	const finalVersion = await lix.db
-		.selectFrom("version")
-		.where("id", "=", activeVersion.id)
-		.select(["change_set_id"])
-		.executeTakeFirstOrThrow();
-
-	const parentCs = await lix.db
-		.selectFrom("change_set_edge")
-		.where("child_id", "=", finalVersion.change_set_id)
+	// 1. Check that the transition commit has both source and target as parents
+	const parentCommits = await lix.db
+		.selectFrom("commit_edge")
+		.where("child_id", "=", transitionCommit.id)
 		.select(["parent_id"])
-		.executeTakeFirstOrThrow();
+		.execute();
 
-	expect(parentCs.parent_id).toBe(cs2.id);
+	expect(parentCommits).toHaveLength(2);
+	expect(parentCommits.map((e) => e.parent_id).sort()).toEqual(
+		[commit2.id, commit0.id].sort()
+	);
 
 	// 2. Check if data is updated
 	const finalFile = await lix.db

package/src/{change-set/create-transition-change-set.ts → commit/create-transition-commit.ts}

@@ -1,24 +1,25 @@
 import type { Lix } from "../lix/index.js";
-import type { ChangeSet } from "./schema.js";
+import type { LixCommit } from "./schema.js";
 import { changeSetElementIsLeafOf } from "../query-filter/change-set-element-is-leaf-of.js";
 import { changeSetElementInAncestryOf } from "../query-filter/change-set-element-in-ancestry-of.js";
-import { createChangeSet } from "./create-change-set.js";
+import { createChangeSet } from "../change-set/create-change-set.js";
+import { uuidV7 } from "../deterministic/uuid-v7.js";
 
 /**
- * Creates a change set that enables a transition from a source state
- * (defined by `sourceChangeSet`) to a target state (defined by `targetChangeSet`).
+ * Creates a commit that enables a transition from a source state
+ * (defined by `sourceCommit`) to a target state (defined by `targetCommit`).
  *
- * Applying the returned change set to the source state will result in a state
+ * Applying the returned commit to the source state will result in a state
  * that matches the target state.
  *
  * - switch between state (switching versions, checkpoints, etc.)
- * - restore old state (applying the transition set on top of current state)
+ * - restore old state (applying the transition commit on top of current state)
  */
-export async function createTransitionChangeSet(args: {
+export async function createTransitionCommit(args: {
 	lix: Lix;
-	sourceChangeSet: Pick<ChangeSet, "id">;
-	targetChangeSet: Pick<ChangeSet, "id">;
-}): Promise<ChangeSet> {
+	sourceCommit: Pick<LixCommit, "id">;
+	targetCommit: Pick<LixCommit, "id">;
+}): Promise<LixCommit> {
 	const executeInTransaction = async (trx: Lix["db"]) => {
 		// 1. Find leaf changes defining the state AT the *target* change set
 		const leafChangesToApply = await trx
@@ -28,8 +29,8 @@ export async function createTransitionChangeSet(args: {
 				"change_set_element.change_id",
 				"change.id"
 			)
-			.where(changeSetElementInAncestryOf([args.targetChangeSet]))
-			.where(changeSetElementIsLeafOf([args.targetChangeSet]))
+			.where(changeSetElementInAncestryOf([args.targetCommit]))
+			.where(changeSetElementIsLeafOf([args.targetCommit]))
 			.select([
 				"change.id",
 				"change.entity_id",
@@ -49,8 +50,8 @@ export async function createTransitionChangeSet(args: {
 				"change.id"
 			)
 			// Condition A: The change must be a leaf in the *source* state
-			.where(changeSetElementInAncestryOf([{ id: args.sourceChangeSet.id }]))
-			.where(changeSetElementIsLeafOf([{ id: args.sourceChangeSet.id }]))
+			.where(changeSetElementInAncestryOf([args.sourceCommit]))
+			.where(changeSetElementIsLeafOf([args.sourceCommit]))
 			// Condition B: The change must NOT be a leaf in the *target* state
 			.where(({ not, exists, selectFrom }) =>
 				not(
@@ -63,8 +64,8 @@ export async function createTransitionChangeSet(args: {
 							)
 							.whereRef("target_leaf_check.id", "=", "change.id")
 							// *** Swapped target and source here relative to previous version ***
-							.where(changeSetElementInAncestryOf([args.targetChangeSet]))
-							.where(changeSetElementIsLeafOf([args.targetChangeSet]))
+							.where(changeSetElementInAncestryOf([args.targetCommit]))
+							.where(changeSetElementIsLeafOf([args.targetCommit]))
 							.select("target_leaf_check.id")
 					)
 				)
@@ -86,8 +87,8 @@ export async function createTransitionChangeSet(args: {
 							)
 							// Check if any change for this entity is a leaf AT THE TARGET change set
 							// *** Swapped target and source here relative to previous version ***
-							.where(changeSetElementInAncestryOf([args.targetChangeSet]))
-							.where(changeSetElementIsLeafOf([args.targetChangeSet]))
+							.where(changeSetElementInAncestryOf([args.targetCommit]))
+							.where(changeSetElementIsLeafOf([args.targetCommit]))
 							.select("restored_entity_check.id")
 					)
 				)
@@ -114,8 +115,7 @@ export async function createTransitionChangeSet(args: {
 								plugin_key: c.plugin_key,
 								entity_id: c.entity_id,
 								file_id: c.file_id,
-								// delete change
-								snapshot_id: "no-content",
+								snapshot_content: null, // Deletion
 							}))
 						)
 						.returning(["id", "entity_id", "schema_key", "file_id"])
@@ -125,7 +125,7 @@ export async function createTransitionChangeSet(args: {
 		const combinedChanges = [...leafChangesToApply, ...deleteChanges];
 
 		if (combinedChanges.length === 0) {
-			throw new Error("No changes to apply in the transition change set.");
+			throw new Error("No changes to apply in the transition commit.");
 		}
 
 		const transitionChangeSet = await createChangeSet({
@@ -136,9 +136,47 @@ export async function createTransitionChangeSet(args: {
 				schema_key: change.schema_key,
 				file_id: change.file_id,
 			})),
+			lixcol_version_id: "global",
 		});
 
-		return transitionChangeSet;
+		// Create a commit for the transition change set
+		const commitId = uuidV7({ lix: args.lix });
+
+		// Insert the commit
+		await trx
+			.insertInto("commit_all")
+			.values({
+				id: commitId,
+				change_set_id: transitionChangeSet.id,
+				lixcol_version_id: "global",
+			})
+			.execute();
+
+		// Create commit edges to both source and target commits
+		await trx
+			.insertInto("commit_edge_all")
+			.values([
+				{
+					parent_id: args.sourceCommit.id,
+					child_id: commitId,
+					lixcol_version_id: "global",
+				},
+				{
+					parent_id: args.targetCommit.id,
+					child_id: commitId,
+					lixcol_version_id: "global",
+				},
+			])
+			.execute();
+
+		// Return the commit
+		const commit = await trx
+			.selectFrom("commit")
+			.where("id", "=", commitId)
+			.selectAll()
+			.executeTakeFirstOrThrow();
+
+		return commit;
 	};
 
 	if (args.lix.db.isTransaction) {