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

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

@@ -1,26 +1,46 @@
 import { test, expect } from "vitest";
-import { openLixInMemory } from "../lix/open-lix-in-memory.js";
+import { openLix } from "../lix/open-lix.js";
 import { createChangeSet } from "./create-change-set.js";
+import type { LixSchemaDefinition } from "../schema-definition/definition.js";
 
 test("creating a change set should succeed", async () => {
-	const lix = await openLixInMemory({});
+	const lix = await openLix({});
+
+	await lix.db
+		.insertInto("stored_schema")
+		.values({
+			value: {
+				"x-lix-key": "mock-schema",
+				"x-lix-version": "1.0",
+				type: "object",
+				properties: {
+					id: { type: "string" },
+				},
+				required: ["id"],
+			} satisfies LixSchemaDefinition,
+		})
+		.execute();
 
 	const mockChanges = await lix.db
 		.insertInto("change")
 		.values([
 			{
-				schema_key: "file",
+				id: "change0",
+				schema_key: "mock-schema",
+				schema_version: "1.0",
 				entity_id: "value1",
 				file_id: "mock",
 				plugin_key: "mock-plugin",
-				snapshot_id: "no-content",
+				snapshot_content: null,
 			},
 			{
-				schema_key: "file",
+				id: "change1",
+				schema_key: "mock-schema",
+				schema_version: "1.0",
 				entity_id: "value2",
 				file_id: "mock",
 				plugin_key: "mock-plugin",
-				snapshot_id: "no-content",
+				snapshot_content: null,
 			},
 		])
 		.returningAll()
@@ -28,7 +48,12 @@ test("creating a change set should succeed", async () => {
 
 	const changeSet = await createChangeSet({
 		lix: lix,
-		changes: mockChanges,
+		elements: mockChanges.map((change) => ({
+			change_id: change.id,
+			entity_id: change.entity_id,
+			schema_key: change.schema_key,
+			file_id: change.file_id,
+		})),
 	});
 
 	const changeSetMembers = await lix.db
@@ -42,13 +67,13 @@ test("creating a change set should succeed", async () => {
 	);
 });
 
-test("creating a change set with empty changes array should succeed", async () => {
-	const lix = await openLixInMemory({});
+test("creating a change set with empty elements array should succeed", async () => {
+	const lix = await openLix({});
 
-	// Create a change set with an empty changes array
+	// Create a change set with an empty elements array
 	const changeSet = await createChangeSet({
 		lix: lix,
-		changes: [],
+		elements: [],
 	});
 
 	// Verify the change set was created
@@ -65,27 +90,34 @@ test("creating a change set with empty changes array should succeed", async () =
 });
 
 test("creating a change set with labels should associate the labels with the change set", async () => {
-	const lix = await openLixInMemory({});
+	const lix = await openLix({});
 
-	// Get existing labels
-	const checkpointLabel = await lix.db
-		.selectFrom("label")
-		.selectAll()
-		.where("name", "=", "checkpoint")
+	// Get the active version to ensure we work in the same context
+	const activeVersion = await lix.db
+		.selectFrom("active_version")
+		.select("version_id")
 		.executeTakeFirstOrThrow();
 
-	// Create a new label
-	const testLabel = await lix.db
+	// Create a new label in the active version context
+	await lix.db
 		.insertInto("label")
-		.values({ name: "test-label" })
-		.returningAll()
+		.values({
+			name: "test-label",
+		})
+		.execute();
+
+	const testLabel = await lix.db
+		.selectFrom("label")
+		.selectAll()
+		.where("name", "=", "test-label")
 		.executeTakeFirstOrThrow();
 
-	// Create a change set with labels
+	// Create a change set with labels in the same version context
 	const changeSet = await createChangeSet({
 		lix: lix,
-		changes: [],
-		labels: [checkpointLabel, testLabel],
+		elements: [],
+		labels: [testLabel],
+		lixcol_version_id: activeVersion.version_id,
 	});
 
 	// Verify the change set was created
@@ -95,13 +127,80 @@ test("creating a change set with labels should associate the labels with the cha
 	const changeSetLabels = await lix.db
 		.selectFrom("change_set_label")
 		.innerJoin("label", "label.id", "change_set_label.label_id")
-		.select(["label.name"])
+		.selectAll()
 		.where("change_set_id", "=", changeSet.id)
 		.execute();
 
 	// Verify both labels are associated with the change set
-	expect(changeSetLabels).toHaveLength(2);
+	expect(changeSetLabels).toHaveLength(1);
 	expect(changeSetLabels.map((label) => label.name)).toEqual(
-		expect.arrayContaining(["test-label", "checkpoint"])
+		expect.arrayContaining(["test-label"])
+	);
+});
+
+test("creating a change set with parents should establish parent-child relationships", async () => {
+	const lix = await openLix({});
+
+	// Create two parent change sets
+	const parentChangeSet1 = await createChangeSet({
+		lix,
+		elements: [],
+	});
+
+	const parentChangeSet2 = await createChangeSet({
+		lix,
+		elements: [],
+	});
+
+	// Create a child change set with two parents
+	const childChangeSet = await createChangeSet({
+		lix,
+		elements: [],
+		parents: [parentChangeSet1, parentChangeSet2],
+	});
+
+	// Get the parent-child relationships from the database
+	const edges = await lix.db
+		.selectFrom("change_set_edge")
+		.selectAll()
+		.where("child_id", "=", childChangeSet.id)
+		.execute();
+
+	// Verify both parent-child relationships were created
+	expect(edges).toHaveLength(2);
+	expect(edges.map((edge) => edge.parent_id)).toEqual(
+		expect.arrayContaining([parentChangeSet1.id, parentChangeSet2.id])
 	);
+	expect(edges.map((edge) => edge.child_id)).toEqual([
+		childChangeSet.id,
+		childChangeSet.id,
+	]);
+});
+
+test("creating a change set with version_id should store it in the specified version", async () => {
+	const lix = await openLix({});
+
+	// Get the global version ID
+	const globalVersion = "global";
+
+	// Create a change set explicitly in the global version
+	const changeSet = await createChangeSet({
+		lix,
+		elements: [],
+		lixcol_version_id: globalVersion,
+	});
+
+	// Verify the change set was created with the correct version_id
+	expect(changeSet.id).toBeDefined();
+	expect(changeSet.lixcol_version_id).toBe(globalVersion);
+
+	// Also verify by querying the database directly
+	const storedChangeSet = await lix.db
+		.selectFrom("change_set_all")
+		.selectAll()
+		.where("id", "=", changeSet.id)
+		.where("lixcol_version_id", "=", globalVersion)
+		.executeTakeFirstOrThrow();
+
+	expect(storedChangeSet.lixcol_version_id).toBe(globalVersion);
 });

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

@@ -1,63 +1,139 @@
-import type { Change, ChangeSet, Label } from "../database/schema.js";
+import { nanoid } from "../database/nano-id.js";
 import type { Lix } from "../lix/open-lix.js";
+import type { ChangeSet, ChangeSetElement } from "./schema.js";
+import type { Label } from "../label/schema.js";
+import type { NewState } from "../entity-views/types.js";
 
 /**
- * Creates a change set with the given changes, optionally within an open transaction.
+ * Creates a change set and optionally attaches elements, labels and parents.
  *
- * @example
- *   ```ts
- *   const changes = await lix.db.selectFrom("change").selectAll().execute();
- *   const changeSet = await createChangeSet({ db: lix.db, changes });
- *   ```
+ * Change sets are the building blocks of versions and checkpoints. This
+ * function inserts all provided relations in a single transaction and
+ * returns the newly created record.
  *
  * @example
- *   ```ts
- *   // Create a change set with labels
- *   const labels = await lix.db.selectFrom("label").selectAll().execute();
- *   const changeSet = await createChangeSet({
- *     lix,
- *     changes: [],
- *     labels
- *   });
- *   ```
+ * ```ts
+ * const cs = await createChangeSet({ lix, elements: [{ change_id, entity_id }] })
+ * ```
  */
+
 export async function createChangeSet(args: {
 	lix: Pick<Lix, "db">;
-	changes: Pick<Change, "id">[];
+	id?: string;
+	elements?: Omit<NewState<ChangeSetElement>, "change_set_id">[];
 	labels?: Pick<Label, "id">[];
-}): Promise<ChangeSet> {
+	/** Parent change sets that this change set will be a child of */
+	parents?: Pick<ChangeSet, "id">[];
+	/** Version ID where the change set should be stored. Defaults to active version */
+	lixcol_version_id?: string;
+}): Promise<ChangeSet & { lixcol_version_id: string }> {
 	const executeInTransaction = async (trx: Lix["db"]) => {
-		const changeSet = await trx
-			.insertInto("change_set")
-			.defaultValues()
-			.returningAll()
-			.executeTakeFirstOrThrow();
+		const csId = args.id ?? nanoid();
 
-		if (args.changes.length > 0) {
+		// Use _all view if version_id is specified, otherwise use regular view
+		if (args.lixcol_version_id) {
 			await trx
-				.insertInto("change_set_element")
-				.values(
-					args.changes.map((change) => ({
-						change_id: change.id,
-						change_set_id: changeSet.id,
-					}))
-				)
-				.execute();
+				.insertInto("change_set_all")
+				.values({
+					id: csId,
+					lixcol_version_id: args.lixcol_version_id,
+				})
+				.executeTakeFirstOrThrow();
+		} else {
+			await trx
+				.insertInto("change_set")
+				.values({
+					id: csId,
+				})
+				.executeTakeFirstOrThrow();
+		}
+
+		if (args.elements && args.elements.length > 0) {
+			// Insert elements linking change set to changes
+			if (args.lixcol_version_id) {
+				await trx
+					.insertInto("change_set_element_all")
+					.values(
+						args.elements.map((element) => ({
+							change_set_id: csId,
+							lixcol_version_id: args.lixcol_version_id,
+							...element,
+						}))
+					)
+					.execute();
+			} else {
+				await trx
+					.insertInto("change_set_element")
+					.values(
+						args.elements.map((element) => ({
+							change_set_id: csId,
+							...element,
+						}))
+					)
+					.execute();
+			}
 		}
 
 		// Add labels if provided
 		if (args.labels && args.labels.length > 0) {
-			await trx
-				.insertInto("change_set_label")
-				.values(
-					args.labels.map((label) => ({
-						label_id: label.id,
-						change_set_id: changeSet.id,
-					}))
-				)
-				.execute();
+			if (args.lixcol_version_id) {
+				await trx
+					.insertInto("change_set_label_all")
+					.values(
+						args.labels.map((label) => ({
+							lixcol_version_id: args.lixcol_version_id,
+							label_id: label.id,
+							change_set_id: csId,
+						}))
+					)
+					.execute();
+			} else {
+				await trx
+					.insertInto("change_set_label")
+					.values(
+						args.labels.map((label) => ({
+							label_id: label.id,
+							change_set_id: csId,
+						}))
+					)
+					.execute();
+			}
+		}
+
+		// Add parent-child relationships if parents are provided
+		for (const parent of args.parents ?? []) {
+			if (args.lixcol_version_id) {
+				await trx
+					.insertInto("change_set_edge_all")
+					.values({
+						parent_id: parent.id,
+						child_id: csId,
+						lixcol_version_id: args.lixcol_version_id,
+					})
+					.execute();
+			} else {
+				await trx
+					.insertInto("change_set_edge")
+					.values({
+						parent_id: parent.id,
+						child_id: csId,
+					})
+					.execute();
+			}
 		}
 
+		const changeSet = await trx
+			.selectFrom("change_set_all")
+			.selectAll()
+			.where("id", "=", csId)
+			.where(
+				"lixcol_version_id",
+				"=",
+				args.lixcol_version_id ??
+					trx.selectFrom("active_version").select("version_id")
+			)
+			.executeTakeFirstOrThrow();
+
 		return changeSet;
 	};