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

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

@@ -6,9 +6,9 @@ import {
 	mockJsonPlugin,
 	MockJsonPropertySchema,
 } from "../plugin/mock-json-plugin.js";
-import type { Change } from "../change/schema.js";
-import type { KeyValue } from "../key-value/schema.js";
-import { createCheckpoint } from "./create-checkpoint.js";
+import type { LixChange } from "../change/schema.js";
+import type { LixKeyValue } from "../key-value/schema.js";
+import { createCheckpoint } from "../commit/create-checkpoint.js";
 
 test("it applies lix own entity changes", async () => {
 	const lix = await openLix({});
@@ -16,9 +16,9 @@ test("it applies lix own entity changes", async () => {
 	const mockKeyValue = {
 		key: "test",
 		value: "something",
-	} as const satisfies KeyValue;
+	} as const satisfies LixKeyValue;
 
-	const mockKeyValueChange: Change = {
+	const mockKeyValueChange: LixChange = {
 		id: "change1",
 		file_id: "lix",
 		plugin_key: "lix_own_entity",
@@ -101,7 +101,7 @@ test("it applies the changes associated with the change set", async () => {
 		.execute();
 
 	// Apply the change set
-	await applyChangeSet({ lix, changeSet: checkpoint });
+	await applyChangeSet({ lix, changeSet: { id: checkpoint.change_set_id } });
 
 	// Verify file data was updated by the mock plugin via applyChangeSet
 	const updatedFile = await lix.db
@@ -304,7 +304,10 @@ test("file deletion bypasses plugin and removes file from state", async () => {
 
 	expect(recreatedFile).toBeDefined();
 	// Apply the deletion change set
-	await applyChangeSet({ lix, changeSet: checkpointAfterDeletion });
+	await applyChangeSet({
+		lix,
+		changeSet: { id: checkpointAfterDeletion.change_set_id },
+	});
 
 	// Verify file is deleted again after applying change set
 	const finalFile = await lix.db

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

@@ -1,14 +1,13 @@
 import type { Lix } from "../lix/index.js";
-import type { ChangeSet } from "./schema.js";
-import { sql, type Kysely } from "kysely";
-import type { LixInternalDatabaseSchema } from "../database/schema.js";
+import type { LixChangeSet } from "./schema.js";
+import { updateStateCache } from "../state/cache/update-state-cache.js";
 
 /**
  * Applies a change set to the lix.
  */
 export async function applyChangeSet(args: {
 	lix: Lix;
-	changeSet: Pick<ChangeSet, "id">;
+	changeSet: Pick<LixChangeSet, "id">;
 }): Promise<void> {
 	const executeInTransaction = async (trx: Lix["db"]) => {
 		// Get the current version
@@ -18,30 +17,44 @@ export async function applyChangeSet(args: {
 			.selectAll("version")
 			.executeTakeFirstOrThrow();
 
-		// Update the version to point to the new change set
+		// Skip change control for this transaction
+		// This allows us to apply changes without triggering change control logic
+		// This is necessary because we are applying a change set directly
+		// and we don't want to create a new change set for this operation
+		await trx
+			.insertInto("key_value_all")
+			.values({
+				key: "lix_skip_file_handlers",
+				value: true,
+				lixcol_untracked: true,
+				lixcol_version_id: version.id,
+			})
+			.execute();
+
+		// Update the version to point to the new commit
 		await trx
 			.updateTable("version")
-			.set({ change_set_id: args.changeSet.id })
+			.set({ commit_id: version.commit_id })
 			.where("id", "=", version.id)
 			.execute();
 
-		// Add a parent relationship (create the edge in the change set graph)
-		if (version.change_set_id !== args.changeSet.id) {
+		// Add a parent relationship (create the edge in the commit graph)
+		if (version.commit_id !== version.commit_id) {
 			// Check if edge already exists to avoid conflict
 			const existingEdge = await trx
-				.selectFrom("change_set_edge_all")
-				.where("parent_id", "=", version.change_set_id)
-				.where("child_id", "=", args.changeSet.id)
+				.selectFrom("commit_edge_all")
+				.where("parent_id", "=", version.commit_id)
+				.where("child_id", "=", version.commit_id)
 				.where("lixcol_version_id", "=", "global")
 				.selectAll()
 				.executeTakeFirst();
 
 			if (!existingEdge) {
 				await trx
-					.insertInto("change_set_edge_all")
+					.insertInto("commit_edge_all")
 					.values({
-						parent_id: version.change_set_id,
-						child_id: args.changeSet.id,
+						parent_id: version.commit_id,
+						child_id: version.commit_id,
 						lixcol_version_id: "global",
 					})
 					.execute();
@@ -59,53 +72,21 @@ export async function applyChangeSet(args: {
 			.where("change_set_element_all.change_set_id", "=", args.changeSet.id)
 			.where("change_set_element_all.lixcol_version_id", "=", "global")
 			.selectAll("change")
-			.select(sql`${version.id}`.as("version_id"))
 			.execute();
 
 		// Write-through cache: populate internal_state_cache for all applied changes
 		for (const change of changesResult) {
-			const cacheKey = {
-				entity_id: change.entity_id,
-				schema_key: change.schema_key,
-				file_id: change.file_id,
+			updateStateCache({
+				lix: args.lix,
+				change: {
+					...change,
+					snapshot_content: change.snapshot_content
+						? JSON.stringify(change.snapshot_content)
+						: null,
+				},
 				version_id: version.id,
-			};
-
-			if (change.snapshot_content === null) {
-				// deletion – remove from cache
-				await (trx as unknown as Kysely<LixInternalDatabaseSchema>)
-					.deleteFrom("internal_state_cache")
-					.where("entity_id", "=", cacheKey.entity_id)
-					.where("schema_key", "=", cacheKey.schema_key)
-					.where("file_id", "=", cacheKey.file_id)
-					.where("version_id", "=", version.id)
-					.execute();
-			} else {
-				// insertion/update – upsert into cache
-				await (trx as unknown as Kysely<LixInternalDatabaseSchema>)
-					.insertInto("internal_state_cache")
-					.values({
-						...cacheKey,
-						plugin_key: change.plugin_key,
-						inheritance_delete_marker: change.snapshot_content === null ? 1 : 0,
-						snapshot_content: JSON.stringify(change.snapshot_content),
-						schema_version: change.schema_version,
-						created_at: change.created_at,
-						updated_at: change.created_at,
-						change_id: change.id,
-					})
-					.onConflict((oc) =>
-						oc
-							.columns(["entity_id", "schema_key", "file_id", "version_id"])
-							.doUpdateSet({
-								plugin_key: change.plugin_key,
-								snapshot_content: sql`excluded.snapshot_content`,
-								schema_version: change.schema_version,
-								updated_at: change.created_at,
-							})
-					)
-					.execute();
-			}
+				commit_id: version.commit_id,
+			});
 		}
 
 		// Group changes by file_id for processing
@@ -177,6 +158,13 @@ export async function applyChangeSet(args: {
 					.where("id", "=", file.id)
 					.execute();
 			}
+
+			// After processing all plugins, emit file change event
+			await trx
+				.deleteFrom("key_value_all")
+				.where("lixcol_version_id", "=", version.id)
+				.where("key", "=", "lix_skip_file_handlers")
+				.execute();
 		}
 	};
 

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

@@ -138,45 +138,6 @@ test("creating a change set with labels should associate the labels with the cha
 	);
 });
 
-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({});
 

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

@@ -1,11 +1,11 @@
-import { nanoid } from "../database/nano-id.js";
+import { nanoId } from "../deterministic/index.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 { LixChangeSet, LixChangeSetElement } from "./schema.js";
+import type { LixLabel } from "../label/schema.js";
 import type { NewState } from "../entity-views/types.js";
 
 /**
- * Creates a change set and optionally attaches elements, labels and parents.
+ * Creates a change set and optionally attaches elements and labels.
  *
  * Change sets are the building blocks of versions and checkpoints. This
  * function inserts all provided relations in a single transaction and
@@ -18,17 +18,15 @@ import type { NewState } from "../entity-views/types.js";
  */
 
 export async function createChangeSet(args: {
-	lix: Pick<Lix, "db">;
+	lix: Pick<Lix, "db" | "sqlite">;
 	id?: string;
-	elements?: Omit<NewState<ChangeSetElement>, "change_set_id">[];
-	labels?: Pick<Label, "id">[];
-	/** Parent change sets that this change set will be a child of */
-	parents?: Pick<ChangeSet, "id">[];
+	elements?: Omit<NewState<LixChangeSetElement>, "change_set_id">[];
+	labels?: Pick<LixLabel, "id">[];
 	/** Version ID where the change set should be stored. Defaults to active version */
 	lixcol_version_id?: string;
-}): Promise<ChangeSet & { lixcol_version_id: string }> {
+}): Promise<LixChangeSet & { lixcol_version_id: string }> {
 	const executeInTransaction = async (trx: Lix["db"]) => {
-		const csId = args.id ?? nanoid();
+		const csId = args.id ?? nanoId({ lix: args.lix });
 
 		// Use _all view if version_id is specified, otherwise use regular view
 		if (args.lixcol_version_id) {
@@ -100,28 +98,6 @@ export async function createChangeSet(args: {
 			}
 		}
 
-		// 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()

package/src/change-set/index.ts

@@ -1,18 +1,10 @@
 export {
 	LixChangeSetSchema,
 	LixChangeSetElementSchema,
-	LixChangeSetEdgeSchema,
 	LixChangeSetLabelSchema,
-	LixChangeSetThreadSchema,
-	type ChangeSet,
-	type ChangeSetElement,
-	type ChangeSetEdge,
-	type ChangeSetLabel,
-	type ChangeSetThread,
+	type LixChangeSet,
+	type LixChangeSetElement,
+	type LixChangeSetLabel,
 } from "./schema.js";
 export { createChangeSet } from "./create-change-set.js";
 export { applyChangeSet } from "./apply-change-set.js";
-export { createMergeChangeSet } from "./create-merge-change-set.js";
-export { createUndoChangeSet } from "./create-undo-change-set.js";
-export { createCheckpoint } from "./create-checkpoint.js";
-export { createTransitionChangeSet } from "./create-transition-change-set.js";

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

@@ -419,165 +419,6 @@ describe("change_set_element", () => {
 	});
 });
 
-describe("change_set_edge", () => {
-	test("insert, delete on the change set edge view", async () => {
-		const lix = await openLix({});
-
-		// Create the referenced change sets first
-		await lix.db
-			.insertInto("change_set")
-			.values([{ id: "cs0" }, { id: "cs1" }])
-			.execute();
-
-		await lix.db
-			.insertInto("change_set_edge")
-			.values([
-				{
-					parent_id: "cs0",
-					child_id: "cs1",
-				},
-			])
-			.execute();
-
-		const viewAfterInsert = await lix.db
-			.selectFrom("change_set_edge")
-			.orderBy("parent_id", "asc")
-			.where("parent_id", "=", "cs0")
-			.selectAll()
-			.execute();
-
-		expect(viewAfterInsert).toMatchObject([
-			{
-				parent_id: "cs0",
-				child_id: "cs1",
-			},
-		]);
-
-		await lix.db
-			.deleteFrom("change_set_edge")
-			.where("parent_id", "=", "cs0")
-			.execute();
-
-		const viewAfterDelete = await lix.db
-			.selectFrom("change_set_edge")
-			.orderBy("parent_id", "asc")
-			.where("parent_id", "=", "cs0")
-			.selectAll()
-			.execute();
-
-		expect(viewAfterDelete).toEqual([]);
-	});
-
-	test("should enforce primary key constraint (parent_id, child_id)", async () => {
-		const lix = await openLix({});
-
-		// Create the referenced change sets first
-		await lix.db
-			.insertInto("change_set")
-			.values([{ id: "cs0" }, { id: "cs1" }])
-			.execute();
-
-		// Insert first edge
-		await lix.db
-			.insertInto("change_set_edge")
-			.values({
-				parent_id: "cs0",
-				child_id: "cs1",
-			})
-			.execute();
-
-		// Attempt duplicate insert with same primary key
-		await expect(
-			lix.db
-				.insertInto("change_set_edge")
-				.values({
-					parent_id: "cs0",
-					child_id: "cs1",
-				})
-				.execute()
-		).rejects.toThrow(/Primary key constraint violation/i);
-	});
-
-	test("should enforce foreign key constraint on parent_id", async () => {
-		const lix = await openLix({});
-
-		// Create only child change set (not parent)
-		await lix.db.insertInto("change_set").values({ id: "cs1" }).execute();
-
-		// Attempt to insert edge with non-existent parent_id
-		await expect(
-			lix.db
-				.insertInto("change_set_edge")
-				.values({
-					parent_id: "cs_nonexistent",
-					child_id: "cs1",
-				})
-				.execute()
-		).rejects.toThrow(/Foreign key constraint violation/i);
-	});
-
-	test("should enforce foreign key constraint on child_id", async () => {
-		const lix = await openLix({});
-
-		// Create only parent change set (not child)
-		await lix.db.insertInto("change_set").values({ id: "cs0" }).execute();
-
-		// Attempt to insert edge with non-existent child_id
-		await expect(
-			lix.db
-				.insertInto("change_set_edge")
-				.values({
-					parent_id: "cs0",
-					child_id: "cs_nonexistent",
-				})
-				.execute()
-		).rejects.toThrow(/Foreign key constraint violation/i);
-	});
-
-	test("should prevent self-referencing edges", async () => {
-		const lix = await openLix({});
-
-		// Create a change set
-		await lix.db.insertInto("change_set").values({ id: "cs1" }).execute();
-
-		// Attempt to create self-referencing edge
-		await expect(
-			lix.db
-				.insertInto("change_set_edge")
-				.values({
-					parent_id: "cs1",
-					child_id: "cs1", // Same as parent_id
-				})
-				.execute()
-		).rejects.toThrow(/Self-referencing edges are not allowed/i);
-	});
-
-	test("change_set_edge view supports updates", async () => {
-		const lix = await openLix({});
-
-		// Create change sets
-		await lix.db
-			.insertInto("change_set")
-			.values([{ id: "cs0" }, { id: "cs1" }, { id: "cs2" }])
-			.execute();
-
-		// Insert an edge
-		await lix.db
-			.insertInto("change_set_edge")
-			.values({ parent_id: "cs0", child_id: "cs1" })
-			.execute();
-
-		// Update should succeed (updating primary key creates new entity_id)
-		const result = await lix.db
-			.updateTable("change_set_edge")
-			.where("parent_id", "=", "cs0")
-			.set({ child_id: "cs2" })
-			.execute();
-
-		expect(result).toBeDefined();
-	});
-});
-
 // the unique constraint must be (change_set_id, entity_id, schema_key, file_id)
 // to allow cross change set references
 test("should allow the same change to be in multiple change sets", async () => {
@@ -828,154 +669,3 @@ describe("change_set_label", () => {
 		).rejects.toThrow(/Foreign key constraint violation/i);
 	});
 });
-
-describe("change_set_thread", () => {
-	test("insert and delete on the change_set_thread view", async () => {
-		const lix = await openLix({});
-
-		// Create change sets and threads to test with
-		await lix.db
-			.insertInto("change_set")
-			.values([{ id: "cs0" }, { id: "cs1" }])
-			.execute();
-
-		await lix.db
-			.insertInto("thread")
-			.values([{ id: "t0" }, { id: "t1" }])
-			.execute();
-
-		// Test insert
-		await lix.db
-			.insertInto("change_set_thread")
-			.values([
-				{ change_set_id: "cs0", thread_id: "t0" },
-				{ change_set_id: "cs1", thread_id: "t1" },
-			])
-			.execute();
-
-		const viewAfterInsert = await lix.db
-			.selectFrom("change_set_thread")
-			.orderBy("change_set_id", "asc")
-			.selectAll()
-			.execute();
-
-		expect(viewAfterInsert).toMatchObject([
-			{
-				change_set_id: "cs0",
-				thread_id: "t0",
-			},
-			{
-				change_set_id: "cs1",
-				thread_id: "t1",
-			},
-		]);
-
-		// Test delete
-		await lix.db
-			.deleteFrom("change_set_thread")
-			.where("change_set_id", "=", "cs0")
-			.execute();
-
-		const viewAfterDelete = await lix.db
-			.selectFrom("change_set_thread")
-			.orderBy("change_set_id", "asc")
-			.selectAll()
-			.execute();
-
-		expect(viewAfterDelete).toMatchObject([
-			{
-				change_set_id: "cs1",
-				thread_id: "t1",
-			},
-		]);
-
-		// Verify the underlying state table changes
-		const changes = await lix.db
-			.selectFrom("change")
-
-			.where("schema_key", "=", "lix_change_set_thread")
-			.where("entity_id", "in", ["cs0::t0", "cs1::t1"])
-			.orderBy("change.created_at", "asc")
-			.selectAll("change")
-
-			.execute();
-
-		expect(changes).toHaveLength(3); // 2 inserts, 1 delete
-		expect(changes[0]?.snapshot_content).toMatchObject({
-			change_set_id: "cs0",
-			thread_id: "t0",
-		});
-		expect(changes[1]?.snapshot_content).toMatchObject({
-			change_set_id: "cs1",
-			thread_id: "t1",
-		});
-		expect(changes[2]?.snapshot_content).toBe(null); // delete
-	});
-
-	test("change_set_thread view enforces foreign key constraints", async () => {
-		const lix = await openLix({});
-
-		// Try to insert with non-existent change_set_id
-		await expect(
-			lix.db
-				.insertInto("change_set_thread")
-				.values({ change_set_id: "non_existent", thread_id: "t0" })
-				.execute()
-		).rejects.toThrow();
-
-		// Try to insert with non-existent thread_id
-		await expect(
-			lix.db
-				.insertInto("change_set_thread")
-				.values({ change_set_id: "cs0", thread_id: "non_existent" })
-				.execute()
-		).rejects.toThrow();
-
-		// Create valid records
-		await lix.db
-			.insertInto("change_set")
-			.values([{ id: "cs0" }])
-			.execute();
-
-		await lix.db
-			.insertInto("thread")
-			.values([{ id: "t0" }])
-			.execute();
-
-		// Now insert should succeed
-		await lix.db
-			.insertInto("change_set_thread")
-			.values({ change_set_id: "cs0", thread_id: "t0" })
-			.execute();
-	});
-
-	test("change_set_thread view supports updates", async () => {
-		const lix = await openLix({});
-
-		// Create change sets and threads
-		await lix.db
-			.insertInto("change_set")
-			.values([{ id: "cs0" }])
-			.execute();
-
-		await lix.db
-			.insertInto("thread")
-			.values([{ id: "t0" }, { id: "t1" }])
-			.execute();
-
-		// Insert a record
-		await lix.db
-			.insertInto("change_set_thread")
-			.values({ change_set_id: "cs0", thread_id: "t0" })
-			.execute();
-
-		// Update should succeed (updating primary key creates new entity_id)
-		const result = await lix.db
-			.updateTable("change_set_thread")
-			.where("change_set_id", "=", "cs0")
-			.set({ thread_id: "t1" })
-			.execute();
-
-		expect(result).toBeDefined();
-	});
-});