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

package/src/query-filter/change-set-is-descendant-of.test.ts

@@ -1,169 +0,0 @@
-import { test, expect } from "vitest";
-import { openLix } from "../lix/open-lix.js";
-import { createChangeSet } from "../change-set/create-change-set.js";
-import { changeSetIsDescendantOf } from "./change-set-is-descendant-of.js";
-import { changeSetIsAncestorOf } from "./change-set-is-ancestor-of.js";
-
-test("selects all descendants excluding the current change set", async () => {
-	const lix = await openLix({});
-
-	// Create a linear chain of change sets: cs0 <- cs1 <- cs2
-	const cs0 = await createChangeSet({
-		lix,
-		elements: [],
-	});
-
-	const cs1 = await createChangeSet({
-		lix,
-		elements: [],
-		parents: [cs0],
-	});
-
-	const cs2 = await createChangeSet({
-		lix,
-		elements: [],
-		parents: [cs1],
-	});
-
-	// Should select cs0, cs1, cs2 as descendants of cs0
-	const results = await lix.db
-		.selectFrom("change_set")
-		.where(changeSetIsDescendantOf(cs0))
-		.select("id")
-		.execute();
-
-	expect(results.map((r) => r.id).sort()).toEqual([cs1.id, cs2.id].sort());
-});
-
-test("respects the optional depth limit", async () => {
-	const lix = await openLix({});
-
-	// cs0 <- cs1 <- cs2
-	const cs0 = await createChangeSet({
-		lix,
-		elements: [],
-	});
-
-	const cs1 = await createChangeSet({
-		lix,
-		elements: [],
-		parents: [cs0],
-	});
-
-	await createChangeSet({
-		lix,
-		elements: [],
-		parents: [cs1],
-	});
-
-	// With depth: 1 starting from cs0, we expect cs0 and cs1 only
-	const results = await lix.db
-		.selectFrom("change_set")
-		.where(changeSetIsDescendantOf(cs0, { depth: 1 }))
-		.select("id")
-		.execute();
-
-	expect(results.map((r) => r.id).sort()).toEqual([cs1.id].sort());
-});
-
-test("can be combined with ancestor filter to select sets between two points", async () => {
-	const lix = await openLix({});
-
-	// Create a linear chain: cs0 <- cs1 <- cs2 <- cs3
-	const cs0 = await createChangeSet({
-		lix,
-		elements: [],
-	});
-
-	const cs1 = await createChangeSet({
-		lix,
-		elements: [],
-		parents: [cs0],
-	});
-
-	const cs2 = await createChangeSet({
-		lix,
-		elements: [],
-		parents: [cs1],
-	});
-
-	const cs3 = await createChangeSet({
-		lix,
-		elements: [],
-		parents: [cs2],
-	});
-
-	// Select change sets that are descendants of cs1 AND ancestors of cs3
-	const results = await lix.db
-		.selectFrom("change_set")
-		.where(changeSetIsDescendantOf(cs1))
-		.where(changeSetIsAncestorOf(cs3))
-		.select("id")
-		.execute();
-
-	expect(results.map((r) => r.id).sort()).toEqual([cs2.id].sort());
-});
-
-test("selects descendants including the current change set when includeSelf is true", async () => {
-	const lix = await openLix({});
-
-	// Setup: cs0 <- cs1 <- cs2
-	const cs0 = await createChangeSet({
-		lix,
-		elements: [],
-	});
-
-	const cs1 = await createChangeSet({
-		lix,
-		elements: [],
-		parents: [cs0],
-	});
-
-	const cs2 = await createChangeSet({
-		lix,
-		elements: [],
-		parents: [cs1],
-	});
-
-	// Should select cs0, cs1, cs2 when includeSelf: true starting from cs0
-	const results = await lix.db
-		.selectFrom("change_set")
-		.where(changeSetIsDescendantOf(cs0, { includeSelf: true }))
-		.select("id")
-		.execute();
-
-	expect(results.map((r) => r.id).sort()).toEqual(
-		[cs0.id, cs1.id, cs2.id].sort()
-	);
-});
-
-test("respects depth limit when includeSelf is true", async () => {
-	const lix = await openLix({});
-
-	// Setup: cs0 <- cs1 <- cs2
-	const cs0 = await createChangeSet({
-		lix,
-		elements: [],
-	});
-
-	const cs1 = await createChangeSet({
-		lix,
-		elements: [],
-		parents: [cs0],
-	});
-
-	await createChangeSet({
-		lix,
-		elements: [],
-		parents: [cs1],
-	});
-
-	// With depth: 1 and includeSelf: true starting from cs0, we expect cs0 and cs1
-	const results = await lix.db
-		.selectFrom("change_set")
-		.where(changeSetIsDescendantOf(cs0, { depth: 1, includeSelf: true }))
-		.select("id")
-		.execute();
-
-	expect(results.map((r) => r.id).sort()).toEqual([cs0.id, cs1.id].sort());
-});

package/src/query-filter/change-set-is-descendant-of.ts

@@ -1,70 +0,0 @@
-import {
-	sql,
-	type SqlBool,
-	type ExpressionBuilder,
-	type ExpressionWrapper,
-} from "kysely";
-import type { LixDatabaseSchema } from "../database/schema.js";
-import type { ChangeSet } from "../change-set/schema.js";
-
-/**
- * Filters change sets that are descendants of the given change set.
- *
- * By default, this is **exclusive**, meaning it returns only change sets strictly
- * *after* the provided change set in the graph.
- *
- * Traverses the `change_set_edge` graph recursively, starting from the provided change set
- * (or its children if exclusive), and returns all change sets reachable via child edges.
- *
- * This filter is useful for finding changes made *after* a specific point in time (e.g., a checkpoint).
- *
- * ⚠️ This filter only defines the traversal scope — it does not filter changes directly.
- *
- * --- Options ---
- * - `includeSelf`: If `true`, includes the starting `changeSet` in the results. Defaults to `false`.
- * - `depth`: Limits the traversal depth. `depth: 1` selects only immediate children (if exclusive)
- *   or the starting node and its immediate children (if includeSelf is true).
- *
- * --- Examples ---
- *
- * @example Selecting strict descendants (default)
- * ```ts
- * db.selectFrom("change_set")
- *   .where(changeSetIsDescendantOf({ id: "cs1" }))
- *   .selectAll()
- * ```
- *
- * @example Combining with changeSetIsAncestorOf to select change sets between two points in time
- * ```ts
- * // Select all change sets between startPoint and endPoint (inclusive)
- * db.selectFrom("change_set")
- *   .where(changeSetIsDescendantOf({ id: "startPoint" }))
- *   .where(changeSetIsAncestorOf({ id: "endPoint" }))
- *   .selectAll()
- * ```
- */
-export function changeSetIsDescendantOf(
-	changeSet: Pick<ChangeSet, "id">,
-	options?: { depth?: number; includeSelf?: boolean }
-): (
-	eb: ExpressionBuilder<LixDatabaseSchema, "change_set">
-) => ExpressionWrapper<LixDatabaseSchema, "change_set", SqlBool> {
-	const depthLimit = options?.depth;
-	const includeSelf = options?.includeSelf ?? false;
-
-	return () =>
-		sql<SqlBool>`
-			change_set.id IN (
-				WITH RECURSIVE dp(id, depth) AS (
-					SELECT id, 0 AS depth FROM change_set WHERE id = ${sql.lit(changeSet.id)}
-					UNION ALL
-					SELECT change_set_edge.child_id, dp.depth + 1
-					FROM change_set_edge
-					JOIN dp ON change_set_edge.parent_id = dp.id
-					${depthLimit !== undefined ? sql`WHERE dp.depth < ${sql.lit(depthLimit)}` : sql``}
-				)
-				-- Select based on the includeSelf flag
-				SELECT id FROM dp ${includeSelf ? sql`` : sql`WHERE depth > 0`}
-			)
-		` as any;
-}

package/src/state/create-changeset-for-transaction.ts

@@ -1,321 +0,0 @@
-import { type Kysely, sql } from "kysely";
-import type { SqliteWasmDatabase } from "sqlite-wasm-kysely";
-import {
-	type ChangeSet,
-	type ChangeSetEdge,
-	type ChangeSetElement,
-	LixChangeSetEdgeSchema,
-	LixChangeSetElementSchema,
-	LixChangeSetSchema,
-} from "../change-set/schema.js";
-import { executeSync } from "../database/execute-sync.js";
-import type { LixInternalDatabaseSchema } from "../database/schema.js";
-import { changeSetHasLabel } from "../query-filter/change-set-has-label.js";
-import { changeSetIsAncestorOf } from "../query-filter/change-set-is-ancestor-of.js";
-import { LixVersionSchema, type Version } from "../version/schema.js";
-import { createChangeWithSnapshot } from "./handle-state-mutation.js";
-import { nanoid } from "../database/nano-id.js";
-import { getVersionRecordByIdOrThrow } from "./get-version-record-by-id-or-throw.js";
-import { handleStateDelete } from "./schema.js";
-
-export function createChangesetForTransaction(
-	sqlite: SqliteWasmDatabase,
-	db: Kysely<LixInternalDatabaseSchema>,
-	currentTime: string,
-	version_id: string,
-	changes: Pick<
-		{
-			id: string;
-			entity_id: string;
-			schema_key: string;
-			schema_version: string;
-			file_id: string;
-			plugin_key: string;
-			snapshot_id: string;
-			created_at: string;
-			snapshot_content: string | null;
-		},
-		"id" | "entity_id" | "schema_key" | "file_id" | "snapshot_content"
-	>[]
-): void {
-	const versionRecord = getVersionRecordByIdOrThrow(sqlite, db, version_id);
-
-	if (!versionRecord) {
-		throw new Error(`Version with id '${version_id}' not found.`);
-	}
-	const mutatedVersion = versionRecord as any;
-	const nextChangeSetId = nanoid();
-	const changeSetChange = createChangeWithSnapshot({
-		sqlite,
-		db,
-		data: {
-			entity_id: nextChangeSetId,
-			schema_key: "lix_change_set",
-			file_id: "lix",
-			plugin_key: "lix_own_entity",
-			snapshot_content: JSON.stringify({
-				id: nextChangeSetId,
-				metadata: null,
-			} satisfies ChangeSet),
-			schema_version: LixChangeSetSchema["x-lix-version"],
-		},
-		timestamp: currentTime,
-		version_id: "global", // Always use 'global' for change sets
-	});
-
-	const changeSetEdgeChange = createChangeWithSnapshot({
-		sqlite,
-		db,
-		data: {
-			entity_id: `${mutatedVersion.change_set_id}::${nextChangeSetId}`,
-			schema_key: "lix_change_set_edge",
-			file_id: "lix",
-			plugin_key: "lix_own_entity",
-			snapshot_content: JSON.stringify({
-				parent_id: mutatedVersion.change_set_id,
-				child_id: nextChangeSetId,
-			} satisfies ChangeSetEdge),
-			schema_version: LixChangeSetEdgeSchema["x-lix-version"],
-		},
-		timestamp: currentTime,
-		version_id: "global", // Always use 'global' for change set edges
-	});
-
-	// Only create separate version change if root change is not already a version change
-	const changesToProcess = [...changes, changeSetChange, changeSetEdgeChange];
-
-	const versionChange = createChangeWithSnapshot({
-		sqlite,
-		db,
-		data: {
-			entity_id: mutatedVersion.id,
-			schema_key: "lix_version",
-			file_id: "lix",
-			plugin_key: "lix_own_entity",
-			snapshot_content: JSON.stringify({
-				...mutatedVersion,
-				change_set_id: nextChangeSetId,
-			} satisfies Version),
-			schema_version: LixVersionSchema["x-lix-version"],
-		},
-		timestamp: currentTime,
-		version_id: "global",
-	});
-	changesToProcess.push(versionChange);
-
-	for (const change of changesToProcess) {
-		// eslint-disable-next-line @typescript-eslint/no-unused-vars
-		const changeSetElementChange = createChangeWithSnapshot({
-			sqlite,
-			db,
-			data: {
-				entity_id: `${nextChangeSetId}::${change.id}`,
-				schema_key: "lix_change_set_element",
-				file_id: "lix",
-				plugin_key: "lix_own_entity",
-				snapshot_content: JSON.stringify({
-					change_set_id: nextChangeSetId,
-					change_id: change.id,
-					schema_key: change.schema_key,
-					file_id: change.file_id,
-					entity_id: change.entity_id,
-				} satisfies ChangeSetElement),
-				schema_version: LixChangeSetElementSchema["x-lix-version"],
-			},
-			timestamp: currentTime,
-			version_id: "global",
-		});
-		// TODO investigate if needed as part of a change set itself
-		// seems to make queries slower
-		// creating a change set element for the change set element change
-		// this is meta but allows us to reconstruct and mutate a change set
-		// createChangeWithSnapshot({
-		// 	sqlite,
-		// 	db,
-		// 	data: {
-		// 		entity_id: changeSetElementChange.entity_id,
-		// 		schema_key: "lix_change_set_element",
-		// 		file_id: "lix",
-		// 		plugin_key: "lix_own_entity",
-		// 		snapshot_content: JSON.stringify({
-		// 			change_set_id: changeSetId,
-		// 			change_id: changeSetElementChange.id,
-		// 			schema_key: "lix_change_set_element",
-		// 			file_id: "lix",
-		// 			entity_id: changeSetElementChange.entity_id,
-		// 		} satisfies ChangeSetElement),
-		// 	},
-		// });
-	}
-
-	// Create/update working change set element for user data changes
-	// TODO skipping lix internal entities is likely undesired.
-	// Skip lix internal entities (change sets, edges, etc.)
-	for (const change of changes) {
-		if (
-			change.schema_key !== "lix_change_set" &&
-			change.schema_key !== "lix_change_set_edge" &&
-			change.schema_key !== "lix_change_set_element" &&
-			change.schema_key !== "lix_version"
-		) {
-			const parsedSnapshot = change.snapshot_content
-				? JSON.parse(change.snapshot_content)
-				: null;
-			const isDeletion =
-				!parsedSnapshot || parsedSnapshot.snapshot_id === "no-content";
-
-			if (isDeletion) {
-				// Delete reconciliation: check if entity existed at last checkpoint using state_history
-				const entityAtCheckpoint = executeSync({
-					lix: { sqlite },
-					query: db
-						.selectFrom("state_history")
-						.where("entity_id", "=", change.entity_id)
-						.where("schema_key", "=", change.schema_key)
-						.where("file_id", "=", change.file_id)
-						.where("depth", "=", 0)
-						.where(
-							"change_set_id",
-							"=",
-							// get the previous checkpoint change set
-							db
-								.selectFrom("change_set")
-								.where(changeSetHasLabel({ name: "checkpoint" }))
-								.where(
-									changeSetIsAncestorOf(
-										{ id: mutatedVersion.change_set_id },
-										{ includeSelf: true, depth: 1 }
-									)
-								)
-								.select("id")
-						)
-						.select("entity_id"),
-				});
-
-				const entityExistedAtCheckpoint = entityAtCheckpoint.length > 0;
-
-				// Always remove existing working change set element first
-				const toDelete = executeSync({
-					lix: { sqlite },
-					query: db
-						.selectFrom("state_all")
-
-						// @ts-expect-error - rowid is a valid SQLite column but not in Kysely types
-						.select("rowid")
-						.where(
-							"entity_id",
-							"like",
-							`${mutatedVersion.working_change_set_id}::%`
-						)
-						.where("schema_key", "=", "lix_change_set_element")
-						.where("file_id", "=", "lix")
-						.where("version_id", "=", "global")
-						.where(
-							sql`json_extract(snapshot_content, '$.entity_id')`,
-							"=",
-							change.entity_id
-						)
-						.where(
-							sql`json_extract(snapshot_content, '$.schema_key')`,
-							"=",
-							change.schema_key
-						)
-						.where(
-							sql`json_extract(snapshot_content, '$.file_id')`,
-							"=",
-							change.file_id
-						),
-				});
-
-				if (toDelete.length > 0) {
-					handleStateDelete(sqlite, toDelete[0]!.rowid, db);
-				}
-
-				// If entity existed at checkpoint, add deletion to working change set
-				if (entityExistedAtCheckpoint) {
-					createChangeWithSnapshot({
-						sqlite,
-						db,
-						data: {
-							entity_id: `${mutatedVersion.working_change_set_id}::${change.id}`,
-							schema_key: "lix_change_set_element",
-							file_id: "lix",
-							plugin_key: "lix_own_entity",
-							snapshot_content: JSON.stringify({
-								change_set_id: mutatedVersion.working_change_set_id,
-								change_id: change.id,
-								entity_id: change.entity_id,
-								schema_key: change.schema_key,
-								file_id: change.file_id,
-							} satisfies ChangeSetElement),
-							schema_version: LixChangeSetElementSchema["x-lix-version"],
-						},
-						timestamp: currentTime,
-						version_id: "global",
-					});
-				}
-				// If entity didn't exist at checkpoint, just remove from working change set (already done above)
-			} else {
-				// Non-deletion: create/update working change set element (latest change wins)
-				// First, remove any existing working change set element for this entity
-				const toDelete = executeSync({
-					lix: { sqlite },
-					query: db
-						.selectFrom("state_all")
-						// @ts-expect-error - rowid is a valid SQLite column but not in Kysely types
-						.select("rowid")
-						.where(
-							"entity_id",
-							"like",
-							`${mutatedVersion.working_change_set_id}::%`
-						)
-						.where("schema_key", "=", "lix_change_set_element")
-						.where("file_id", "=", "lix")
-						.where("version_id", "=", "global")
-						.where(
-							sql`json_extract(snapshot_content, '$.entity_id')`,
-							"=",
-							change.entity_id
-						)
-						.where(
-							sql`json_extract(snapshot_content, '$.schema_key')`,
-							"=",
-							change.schema_key
-						)
-						.where(
-							sql`json_extract(snapshot_content, '$.file_id')`,
-							"=",
-							change.file_id
-						),
-				});
-
-				if (toDelete.length > 0) {
-					// throw new Error("not implement - us the delete function ");
-					handleStateDelete(sqlite, toDelete[0]!.rowid, db);
-				}
-
-				// Then create new element with latest change
-				createChangeWithSnapshot({
-					sqlite,
-					db,
-					data: {
-						entity_id: `${mutatedVersion.working_change_set_id}::${change.id}`,
-						schema_key: "lix_change_set_element",
-						file_id: "lix",
-						plugin_key: "lix_own_entity",
-						snapshot_content: JSON.stringify({
-							change_set_id: mutatedVersion.working_change_set_id,
-							change_id: change.id,
-							entity_id: change.entity_id,
-							schema_key: change.schema_key,
-							file_id: change.file_id,
-						} satisfies ChangeSetElement),
-						schema_version: LixChangeSetElementSchema["x-lix-version"],
-					},
-					timestamp: currentTime,
-					version_id: "global",
-				});
-			}
-		}
-	}
-}

package/src/state/get-version-record-by-id-or-throw.ts

@@ -1,51 +0,0 @@
-import { type Kysely, sql } from "kysely";
-import type { SqliteWasmDatabase } from "sqlite-wasm-kysely";
-import { executeSync } from "../database/execute-sync.js";
-import type { LixInternalDatabaseSchema } from "../database/schema.js";
-import type { Version } from "../version/schema.js";
-
-export function getVersionRecordByIdOrThrow(
-	sqlite: SqliteWasmDatabase,
-	db: Kysely<LixInternalDatabaseSchema>,
-	version_id: string
-): Version {
-	let [versionRecord] = executeSync({
-		lix: { sqlite },
-		query: db
-			.selectFrom("internal_state_cache")
-			.where("schema_key", "=", "lix_version")
-			.where("entity_id", "=", version_id)
-			.select("snapshot_content as content"),
-	}) as [{ content: string } | undefined];
-
-	// If not found in cache, try the change/snapshot tables (normal operation)
-	if (!versionRecord) {
-		[versionRecord] = executeSync({
-			lix: { sqlite },
-			// TODO @samuelstroschein wouldn't we need the view that quieries the union of the temp table and this one?
-			query: db
-				.selectFrom("internal_change")
-				.innerJoin(
-					"internal_snapshot",
-					"internal_change.snapshot_id",
-					"internal_snapshot.id"
-				)
-				.where("internal_change.schema_key", "=", "lix_version")
-				.where("internal_change.entity_id", "=", version_id)
-				.where("internal_change.snapshot_id", "!=", "no-content")
-				// TODO @samuelstroschein how does this ording work with a second branch in version?
-				// @ts-expect-error - rowid is a valid SQLite column but not in Kysely types
-				.orderBy("internal_change.rowid", "desc")
-				.limit(1)
-				.select(sql`json(internal_snapshot.content)`.as("content")),
-		}) as [{ content: string } | undefined];
-	}
-
-	// Bootstrap is now handled through proper change tracking in newLixFile()
-
-	if (!versionRecord) {
-		throw new Error(`Version with id '${version_id}' not found.`);
-	}
-
-	return JSON.parse(versionRecord.content) as Version;
-}