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

package/src/change-set/create-merge-change-set.test.ts

@@ -0,0 +1,237 @@
+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 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")
+		.values({
+			value: {
+				"x-lix-key": "test_schema",
+				"x-lix-version": "1.0",
+				type: "object",
+				additionalProperties: false,
+				properties: {
+					id: { type: "string" },
+				},
+				required: ["id"],
+			} satisfies LixSchemaDefinition,
+		})
+		.execute();
+
+	const changes = await lix.db
+		.insertInto("change")
+		.values([
+			{
+				id: "c0",
+				schema_key: "test_schema",
+				schema_version: "1.0",
+				entity_id: "e0",
+				file_id: "file0",
+				plugin_key: "mock_plugin",
+				snapshot_content: null,
+			},
+			{
+				id: "c1",
+				schema_key: "test_schema",
+				schema_version: "1.0",
+				entity_id: "e1",
+				file_id: "file0",
+				plugin_key: "mock_plugin",
+				snapshot_content: null,
+			},
+			{
+				id: "c2",
+				schema_key: "test_schema",
+				schema_version: "1.0",
+				entity_id: "e2",
+				file_id: "file0",
+				plugin_key: "mock_plugin",
+				snapshot_content: null,
+			},
+		])
+		.returningAll()
+		.execute();
+
+	const cs0 = await createChangeSet({
+		lix,
+		elements: [changes[0]!].map((change) => ({
+			change_id: change.id,
+			entity_id: change.entity_id,
+			schema_key: change.schema_key,
+			file_id: change.file_id,
+		})),
+	});
+
+	const cs1 = await createChangeSet({
+		lix,
+		elements: [changes[1]!].map((change) => ({
+			change_id: change.id,
+			entity_id: change.entity_id,
+			schema_key: change.schema_key,
+			file_id: change.file_id,
+		})),
+	});
+
+	// simulating graph relation
+	const cs2 = await createChangeSet({
+		lix,
+		elements: [changes[2]!].map((change) => ({
+			change_id: change.id,
+			entity_id: change.entity_id,
+			schema_key: change.schema_key,
+			file_id: change.file_id,
+		})),
+		parents: [cs1],
+	});
+
+	const merged = await createMergeChangeSet({
+		lix,
+		source: cs0,
+		target: cs2,
+	});
+
+	const mergedElements = await lix.db
+		.selectFrom("change_set_element")
+		.where("change_set_element.change_set_id", "=", merged.id)
+		.selectAll()
+		.execute();
+
+	expect(mergedElements).toHaveLength(3);
+	expect(mergedElements.map((e) => e.change_id).sort()).toEqual(
+		[changes[0]!.id, changes[1]!.id, changes[2]!.id].sort()
+	);
+});
+
+test("should handle conflicting elements with source winning (until conflicts are modeled in lix)", async () => {
+	const lix = await openLix({});
+
+	await lix.db
+		.insertInto("stored_schema")
+		.values({
+			value: {
+				"x-lix-key": "s1",
+				"x-lix-version": "1.0",
+				additionalProperties: false,
+				type: "object",
+				properties: {
+					id: { type: "string" },
+					text: { type: "string" },
+				},
+				required: ["id"],
+			} satisfies LixSchemaDefinition,
+		})
+		.execute();
+
+	// Create changes for the different states of the same entity
+	const changes = await lix.db
+		.insertInto("change")
+		.values([
+			{
+				id: "c_base",
+				schema_key: "s1",
+				schema_version: "1.0",
+				entity_id: "e1",
+				file_id: "file1",
+				plugin_key: "mock_plugin",
+				snapshot_content: { text: "base" },
+			},
+			{
+				id: "c_target",
+				schema_key: "s1",
+				schema_version: "1.0",
+				entity_id: "e1", // Same entity as base, different content
+				file_id: "file1",
+				plugin_key: "mock_plugin",
+				snapshot_content: { text: "target mod" },
+			},
+			{
+				id: "c_source",
+				schema_key: "s1",
+				schema_version: "1.0",
+				entity_id: "e1", // Same entity as base, different content
+				file_id: "file1",
+				plugin_key: "mock_plugin",
+				snapshot_content: { text: "source mod" },
+			},
+		])
+		.returningAll()
+		.execute();
+
+	// 1. Base change set with initial content
+	const cs_base = await createChangeSet({
+		lix,
+		elements: [changes[0]!].map((change) => ({
+			change_id: change.id,
+			entity_id: change.entity_id,
+			schema_key: change.schema_key,
+			file_id: change.file_id,
+		})),
+	});
+
+	// 2. Target branch - modifies e1
+	const cs_target = await createChangeSet({
+		lix,
+		elements: [changes[1]!].map((change) => ({
+			change_id: change.id,
+			entity_id: change.entity_id,
+			schema_key: change.schema_key,
+			file_id: change.file_id,
+		})),
+		parents: [cs_base],
+	});
+
+	// 3. Source branch - modifies e1 differently
+	const cs_source = await createChangeSet({
+		lix,
+		elements: [changes[2]!].map((change) => ({
+			change_id: change.id,
+			entity_id: change.entity_id,
+			schema_key: change.schema_key,
+			file_id: change.file_id,
+		})),
+		parents: [cs_base],
+	});
+
+	// 4. Merge source into target
+	const merged = await createMergeChangeSet({
+		lix,
+		source: cs_source,
+		target: cs_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)
+		.selectAll()
+		.execute();
+
+	// The merge should only contain the element from the source change set due to "source wins"
+	expect(mergedElements).toHaveLength(1);
+	expect(mergedElements[0]).toEqual(
+		expect.objectContaining({
+			change_set_id: merged.id,
+			change_id: changes[2]!.id,
+			entity_id: changes[2]!.entity_id,
+			schema_key: changes[2]!.schema_key,
+			file_id: changes[2]!.file_id,
+		})
+	);
+
+	// 6. Verify graph structure
+	const edges = await lix.db
+		.selectFrom("change_set_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()
+	);
+});

package/src/change-set/create-merge-change-set.ts

@@ -0,0 +1,99 @@
+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";
+
+/**
+ * Merges two change sets 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.
+ *
+ * @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).
+ *
+ * @returns A Promise resolving to the newly created ChangeSet representing the merged state.
+ */
+export async function createMergeChangeSet(args: {
+	lix: Lix;
+	source: Pick<ChangeSet, "id">;
+	target: Pick<ChangeSet, "id">;
+}): Promise<ChangeSet> {
+	const executeInTransaction = async (trx: Lix["db"]) => {
+		// --- Calculate the merged elements using "source wins" logic ---
+		const mergedElements = await trx
+			.with("SourceLeaves", (db) =>
+				db
+					.selectFrom("change_set_element")
+					.where(changeSetElementInAncestryOf([args.source]))
+					.where(changeSetElementIsLeafOf([args.source]))
+					.selectAll("change_set_element")
+			)
+			.with("TargetLeaves", (db) =>
+				db
+					.selectFrom("change_set_element")
+					.where(changeSetElementInAncestryOf([args.target]))
+					.where(changeSetElementIsLeafOf([args.target]))
+					.selectAll("change_set_element")
+			)
+			.selectFrom("SourceLeaves") // Select all source leaves (they always win)
+			.selectAll()
+			.union(
+				(db) =>
+					db
+						.selectFrom("TargetLeaves") // Select target leaves...
+						.selectAll()
+						.where(({ not, exists, selectFrom }) =>
+							not(
+								exists(
+									// ...that do NOT have a corresponding entity in SourceLeaves
+									selectFrom("SourceLeaves")
+										.select("SourceLeaves.entity_id") // Select something small
+										.whereRef(
+											"SourceLeaves.entity_id",
+											"=",
+											"TargetLeaves.entity_id"
+										)
+										.whereRef(
+											"SourceLeaves.file_id",
+											"=",
+											"TargetLeaves.file_id"
+										)
+										.whereRef(
+											"SourceLeaves.schema_key",
+											"=",
+											"TargetLeaves.schema_key"
+										)
+								)
+							)
+						) // End WHERE NOT EXISTS
+			) // End UNION
+			.execute();
+
+		// Create the new merge change set record
+		const newChangeSet = await createChangeSet({
+			lix: { ...args.lix, db: trx },
+			elements: mergedElements.map((ce) => ({
+				change_id: ce.change_id,
+				entity_id: ce.entity_id,
+				schema_key: ce.schema_key,
+				file_id: ce.file_id,
+			})),
+			parents: [args.source, args.target],
+		});
+
+		return newChangeSet;
+	};
+
+	// Restore transaction handling
+	if (args.lix.db.isTransaction) {
+		return executeInTransaction(args.lix.db);
+	} else {
+		return args.lix.db.transaction().execute(executeInTransaction);
+	}
+}

package/src/change-set/create-transition-change-set.test.ts

@@ -0,0 +1,245 @@
+import { expect, test } from "vitest";
+import { openLix } from "../lix/open-lix.js";
+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";
+
+// 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 () => {
+	// 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();
+
+	// Insert the schema that the mockJsonPlugin uses
+	await lix.db
+		.insertInto("stored_schema")
+		.values({
+			value: MockJsonPropertySchema,
+		})
+		.execute();
+
+	// Create a file
+	await lix.db
+		.insertInto("file")
+		.values({
+			id: "file1",
+			data: new TextEncoder().encode(""),
+			path: "/test.json",
+		})
+		.execute();
+
+	const file = await lix.db
+		.selectFrom("file")
+		.selectAll()
+		.where("id", "=", "file1")
+		.executeTakeFirstOrThrow();
+
+	const changes = await lix.db
+		.insertInto("change")
+		.values([
+			{
+				id: "c0",
+				file_id: file.id,
+				plugin_key: mockJsonPlugin.key,
+				entity_id: "l0",
+				schema_key: "mock_json_property",
+				schema_version: "1.0",
+				snapshot_content: { value: "Value 0" },
+			},
+			{
+				id: "c1",
+				file_id: file.id,
+				plugin_key: mockJsonPlugin.key,
+				entity_id: "l1",
+				schema_key: "mock_json_property",
+				schema_version: "1.0",
+				snapshot_content: { value: "Value 1" },
+			},
+			{
+				id: "c2",
+				file_id: file.id,
+				plugin_key: mockJsonPlugin.key,
+				entity_id: "l2",
+				schema_key: "mock_json_property",
+				schema_version: "1.0",
+				snapshot_content: { value: "Value 2" },
+			},
+			{
+				id: "c3",
+				file_id: file.id,
+				plugin_key: mockJsonPlugin.key,
+				entity_id: "l2",
+				schema_key: "mock_json_property",
+				schema_version: "1.0",
+				snapshot_content: { value: "Value 2 Modified" },
+			},
+			{
+				id: "c4",
+				file_id: file.id,
+				plugin_key: mockJsonPlugin.key,
+				entity_id: "l3",
+				schema_key: "mock_json_property",
+				schema_version: "1.0",
+				snapshot_content: { value: "Value 3" },
+			},
+			{
+				id: "c5", // Add another change/entity for complexity
+				entity_id: "l4",
+				file_id: "file1",
+				schema_key: "mock_json_property",
+				schema_version: "1.0",
+				plugin_key: mockJsonPlugin.key,
+				snapshot_content: { value: "Value 4" },
+			},
+		])
+		.returningAll()
+		.execute();
+
+	const cs0 = await createChangeSet({
+		lix,
+		id: "cs0",
+		elements: [changes[0]!, changes[1]!, changes[2]!].map((change) => ({
+			change_id: change.id,
+			entity_id: change.entity_id,
+			schema_key: change.schema_key,
+			file_id: change.file_id,
+		})),
+	});
+
+	const cs1 = await createChangeSet({
+		lix,
+		id: "cs1",
+		elements: [changes[3]!].map((change) => ({
+			change_id: change.id,
+			entity_id: change.entity_id,
+			schema_key: change.schema_key,
+			file_id: change.file_id,
+		})),
+		parents: [cs0],
+	});
+
+	const cs2 = await createChangeSet({
+		lix,
+		id: "cs2",
+		elements: [changes[4]!, changes[5]!].map((change) => ({
+			change_id: change.id,
+			entity_id: change.entity_id,
+			schema_key: change.schema_key,
+			file_id: change.file_id,
+		})),
+		parents: [cs1],
+	});
+
+	// Apply change sets in order: cs0, then cs1, then cs2
+	// This demonstrates the explicit, predictable "direct" behavior
+	await applyChangeSet({
+		lix,
+		changeSet: cs0,
+	});
+
+	const fileCs0Before = await lix.db
+		.selectFrom("file")
+		.where("id", "=", file.id)
+		.selectAll()
+		.executeTakeFirstOrThrow();
+
+	// The file data should now be a JSON string representing the state at cs0
+	const expectedJsonStateCs0 = {
+		l0: "Value 0",
+		l1: "Value 1",
+		l2: "Value 2",
+	};
+
+	const actualJsonStateCs0 = JSON.parse(
+		new TextDecoder().decode(fileCs0Before.data)
+	);
+
+	expect(actualJsonStateCs0).toEqual(expectedJsonStateCs0);
+
+	// Apply cs1 (which modifies l2 to "Value 2 Modified")
+	await applyChangeSet({
+		lix,
+		changeSet: cs1,
+	});
+
+	// Apply cs2 (which adds l3 and l4)
+	await applyChangeSet({
+		lix,
+		changeSet: cs2,
+	});
+
+	// Verify initial state
+	const fileAfterRestoreCs2 = await lix.db
+		.selectFrom("file")
+		.where("id", "=", file.id)
+		.selectAll()
+		.executeTakeFirstOrThrow();
+
+	// The file data should now be a JSON string representing the state at cs2
+	const expectedJsonStateCs2 = {
+		l0: "Value 0",
+		l1: "Value 1",
+		l2: "Value 2 Modified", // c3 replaced c2
+		l3: "Value 3", // c4 added
+		l4: "Value 4", // c5 added
+	};
+
+	const actualJsonStateCs2 = JSON.parse(
+		new TextDecoder().decode(fileAfterRestoreCs2.data)
+	);
+
+	expect(actualJsonStateCs2).toEqual(expectedJsonStateCs2);
+
+	// Action: Create transition change set to restore to cs0
+	const transitionChangeSet = await createTransitionChangeSet({
+		lix,
+		sourceChangeSet: cs2,
+		targetChangeSet: cs0,
+	});
+
+	// Apply the transition change set
+	await applyChangeSet({
+		lix,
+		changeSet: transitionChangeSet,
+	});
+
+	// 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)
+		.select(["parent_id"])
+		.executeTakeFirstOrThrow();
+
+	expect(parentCs.parent_id).toBe(cs2.id);
+
+	// 2. Check if data is updated
+	const finalFile = await lix.db
+		.selectFrom("file")
+		.where("id", "=", file.id)
+		.selectAll()
+		.executeTakeFirstOrThrow();
+
+	// The file data should now be a JSON string representing the state at cs0
+	const actualJsonState = JSON.parse(new TextDecoder().decode(finalFile.data));
+
+	expect(actualJsonState).toEqual(expectedJsonStateCs0);
+});