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

package/src/own-change-control/database-triggers.ts

@@ -1,189 +0,0 @@
-import type { SqliteWasmDatabase } from "sqlite-wasm-kysely";
-import type { LixDatabaseSchema, Snapshot } from "../database/schema.js";
-import type { Kysely } from "kysely";
-import {
-	changeControlledTableIds,
-	entityIdForRow,
-	type PragmaTableInfo,
-} from "./change-controlled-tables.js";
-import { createChange } from "../change/create-change.js";
-import { executeSync } from "../database/execute-sync.js";
-
-export function applyOwnChangeControlTriggers(
-	sqlite: SqliteWasmDatabase,
-	db: Kysely<LixDatabaseSchema>
-): void {
-	const tableInfos: Record<string, PragmaTableInfo> = {};
-
-	for (const table of Object.keys(changeControlledTableIds)) {
-		tableInfos[table] = sqlite.exec({
-			sql: `PRAGMA table_info(${table});`,
-			returnValue: "resultRows",
-			rowMode: "object",
-		}) as PragmaTableInfo;
-	}
-
-	sqlite.createFunction({
-		name: "handle_lix_own_change_control",
-		arity: -1,
-		// @ts-expect-error - dynamic function
-		xFunc: (
-			_ctx: number,
-			tableName: keyof typeof changeControlledTableIds,
-			operation: "insert" | "update" | "delete",
-			...value
-		) => {
-			return handleLixOwnEntityChange(
-				db,
-				sqlite,
-				tableName,
-				tableInfos,
-				operation,
-				...value
-			);
-		},
-	});
-
-	for (const table of Object.keys(changeControlledTableIds)) {
-		const tableInfo = tableInfos[table]!;
-
-		const sql = `
-      CREATE TEMP TRIGGER IF NOT EXISTS ${table}_change_control_insert
-      AFTER INSERT ON ${table}
-      BEGIN
-        SELECT handle_lix_own_change_control('${table}', 'insert', ${tableInfo.map((c) => "NEW." + c.name).join(", ")});
-      END;
-      
-      CREATE TEMP TRIGGER IF NOT EXISTS ${table}_change_control_update
-      AFTER UPDATE ON ${table}
-			${
-				// ignore update trigger if the change controlled properties
-				// did not change (a plugin likely called apply changes on the file.data)
-				table === "file"
-					? `
-			WHEN (
-				OLD.id IS NOT NEW.id OR
-				OLD.path IS NOT NEW.path OR
-				OLD.metadata IS NOT NEW.metadata
-			)`
-					: ""
-			}
-      BEGIN
-        SELECT handle_lix_own_change_control('${table}', 'update', ${tableInfo.map((c) => "NEW." + c.name).join(", ")});
-      END;
-
-      CREATE TEMP TRIGGER IF NOT EXISTS ${table}_change_control_delete
-      AFTER DELETE ON ${table}
-      BEGIN
-        SELECT handle_lix_own_change_control('${table}', 'delete', ${tableInfo.map((c) => "OLD." + c.name).join(", ")});
-      END;
-      `;
-
-		sqlite.exec(sql);
-	}
-}
-
-function handleLixOwnEntityChange(
-	db: Kysely<LixDatabaseSchema>,
-	sqlite: SqliteWasmDatabase,
-	tableName: keyof typeof changeControlledTableIds,
-	tableInfos: Record<keyof typeof changeControlledTableIds, PragmaTableInfo>,
-	operation: "insert" | "update" | "delete",
-	...values: any[]
-): void {
-	const lix = { db, sqlite };
-
-	// key values that have skip_change_control set to true should not be change controlled
-	if (tableName === "key_value" && values[2]) {
-		return;
-	}
-
-	const shouldSkip =
-		executeSync({
-			lix,
-			query: db
-				.selectFrom("key_value")
-				.where("key", "=", "lix_skip_own_change_control")
-				.select("value"),
-		})[0]?.value === "true";
-
-	if (shouldSkip) {
-		return;
-	}
-
-	// need to break the loop if own changes are detected
-	const change = executeSync({
-		lix,
-		query: db
-			.selectFrom("change")
-			.where("id", "=", values[0])
-			.select("plugin_key"),
-	})[0];
-
-	if (change?.plugin_key === "lix_own_change_control") {
-		return;
-	}
-
-	const currentVersion = executeSync({
-		lix,
-		query: db
-			.selectFrom("current_version")
-			.innerJoin("version", "current_version.id", "version.id")
-			.selectAll("version"),
-	})[0];
-
-	const authors = executeSync({
-		lix,
-		query: db.selectFrom("active_account").selectAll(),
-	});
-
-	if (authors.length === 0) {
-		console.error(tableName, change);
-		throw new Error("At least one author is required");
-	}
-
-	let snapshotContent: Snapshot["content"] | null;
-
-	if (operation === "delete") {
-		snapshotContent = null;
-	} else {
-		snapshotContent = {};
-		// construct the values as json for the snapshot
-		for (const [index, column] of tableInfos[tableName]!.entries()) {
-			snapshotContent[column.name] = values[index];
-		}
-	}
-
-	if (tableName === "file" && snapshotContent) {
-		// sqlite has it's own jsonb format
-		// hence, need to query sqlite to convert
-		// to json
-		const json = sqlite.exec("SELECT json(?)", {
-			bind: [snapshotContent.metadata],
-			returnValue: "resultRows",
-		})[0]![0];
-
-		snapshotContent["metadata"] = JSON.parse(json as string);
-
-		// remove the data field which is change controlled by plugins, not lix itself
-		delete snapshotContent.data;
-	}
-
-	const entityId = entityIdForRow(tableName, ...values);
-
-	createChange(
-		{
-			lix,
-			authors: authors,
-			version: currentVersion,
-			entityId,
-			fileId: "lix_own_change_control",
-			pluginKey: "lix_own_change_control",
-			schemaKey: `lix_${tableName}_table`,
-			snapshotContent,
-		},
-		{
-			updateVersionChanges: tableName === "version_change" ? false : true,
-		}
-	);
-}

package/src/own-change-control/index.ts

@@ -1 +0,0 @@
-export { withSkipOwnChangeControl } from "./with-skip-own-change-control.js";

package/src/own-change-control/with-skip-own-change-control.test.ts

@@ -1,57 +0,0 @@
-import { test, expect } from "vitest";
-import { openLixInMemory } from "../lix/open-lix-in-memory.js";
-import { withSkipOwnChangeControl } from "./with-skip-own-change-control.js";
-
-test("skipping works", async () => {
-	const lix = await openLixInMemory({});
-
-	await withSkipOwnChangeControl(lix.db, async (trx) => {
-		await trx
-			.insertInto("key_value")
-			.values({ key: "foo", value: "bar" })
-			.execute();
-		await trx
-			.insertInto("key_value")
-			.values({ key: "foo2", value: "bar2" })
-			.execute();
-	});
-
-	const keyValues = await lix.db.selectFrom("key_value").selectAll().execute();
-	const changes = await lix.db
-		.selectFrom("change")
-		.where("schema_key", "=", "lix_key_value_table")
-		.selectAll()
-		.execute();
-
-	expect(keyValues.find((kv) => kv.key === "foo")).toBeDefined();
-	expect(keyValues.find((kv) => kv.key === "foo2")).toBeDefined();
-
-	console.log(changes);
-	expect(changes).toHaveLength(0);
-});
-
-test("if an outside transaction sets the value to true, no conflict should arise", async () => {
-	const lix = await openLixInMemory({});
-
-	// simulating an outside transaction setting the value to true
-	await withSkipOwnChangeControl(lix.db, async (trx) => {
-		// and an inside transaction setting the value to true as well
-		await withSkipOwnChangeControl(trx, async (trx2) => {
-			await trx2
-				.insertInto("key_value")
-				.values({ key: "foo", value: "bar" })
-				.execute();
-		});
-	});
-
-	const keyValues = await lix.db.selectFrom("key_value").selectAll().execute();
-	const changes = await lix.db
-		.selectFrom("change")
-		.where("schema_key", "=", "lix_key_value_table")
-		.where("entity_id", "=", "foo")
-		.selectAll()
-		.execute();
-
-	expect(changes).toHaveLength(0);
-	expect(keyValues.find((kv) => kv.key === "foo")).toBeDefined();
-});

package/src/own-change-control/with-skip-own-change-control.ts

@@ -1,34 +0,0 @@
-import type { Lix } from "../lix/open-lix.js";
-
-export async function withSkipOwnChangeControl<T>(
-	db: Lix["db"],
-	operation: (trx: Lix["db"]) => Promise<T>
-): Promise<T> {
-	const executeInTransaction = async (trx: Lix["db"]) => {
-		await trx
-			.insertInto("key_value")
-			.values({
-				key: "lix_skip_own_change_control",
-				value: "true",
-				skip_change_control: true,
-			})
-			.onConflict((oc) => oc.doUpdateSet({ value: "true" }))
-			.execute();
-
-		// Perform the user's operation
-		const result = await operation(trx);
-
-		await trx
-			.deleteFrom("key_value")
-			.where("key", "=", "lix_skip_own_change_control")
-			.execute();
-
-		// Return the result of the operation
-		return result;
-	};
-	if (db.isTransaction) {
-		return executeInTransaction(db);
-	} else {
-		return db.transaction().execute(executeInTransaction);
-	}
-}

package/src/plugin/load-plugin.ts

@@ -1,37 +0,0 @@
-import type { LixDatabaseSchema, LixFile } from "../database/schema.js";
-import type { LixPlugin } from "./lix-plugin.js";
-import { Kysely, sql } from "kysely";
-
-export async function loadPlugins(
-	db: Kysely<LixDatabaseSchema>
-): Promise<LixPlugin[]> {
-	// https://github.com/opral/inlang-paraglide-js/issues/350
-
-	// this function need an overhaul. text @samuelstroschein before you implement stuff.
-	// - needs manifest file, not match by "plugin/*" to avoid accidental loading of non-plugins
-
-	throw new Error("not implemented");
-	// @ts-expect-error - currently disabled
-	const pluginFiles = (
-		await sql`
-    SELECT * FROM file
-    WHERE path GLOB 'lix/plugin/*'
-  `.execute(db)
-	).rows as unknown as LixFile[];
-
-	const decoder = new TextDecoder("utf8");
-	const plugins: LixPlugin[] = [];
-	for (const plugin of pluginFiles) {
-		const blob = new Blob([decoder.decode(plugin.data)], {
-			type: "text/javascript",
-		});
-		const blobUrl = URL.createObjectURL(blob);
-		const pluginModule = await import(/* @vite-ignore */ blobUrl);
-
-		plugins.push(pluginModule.default);
-		if (pluginModule.default.setup) {
-			await pluginModule.default.setup();
-		}
-	}
-	return plugins as LixPlugin[];
-}

package/src/plugin/with-transaction.ts

@@ -1,22 +0,0 @@
-import type { Transaction } from "kysely";
-import type { LixDatabaseSchema } from "../database/schema.js";
-import type { Lix } from "../lix/open-lix.js";
-import type { LixReadonly } from "./lix-plugin.js";
-
-/**
- * Turns a `Lix` into a `LixReadonly`.
- *
- * TODO https://github.com/opral/lix-sdk/issues/123
- */
-export function withTransaction(
-	lix: Lix,
-	trx: Transaction<LixDatabaseSchema>
-): LixReadonly {
-	return {
-		db: {
-			selectFrom: trx.selectFrom,
-			withRecursive: trx.withRecursive,
-		},
-		plugin: lix.plugin,
-	};
-}

package/src/query-filter/change-conflict-in-version.test.ts

@@ -1,62 +0,0 @@
-import { test, expect } from "vitest";
-import { openLixInMemory } from "../lix/open-lix-in-memory.js";
-import { createChangeConflict } from "../change-conflict/create-change-conflict.js";
-import { changeConflictInVersion } from "./change-conflict-in-version.js";
-import { createVersion } from "../version/create-version.js";
-
-test("should find conflicts in the given version", async () => {
-	const lix = await openLixInMemory({});
-
-	// Insert changes
-	await lix.db
-		.insertInto("change")
-		.values([
-			{
-				id: "change0",
-				plugin_key: "mock-plugin",
-				schema_key: "mock",
-				file_id: "mock",
-				entity_id: "value0",
-				snapshot_id: "no-content",
-			},
-			{
-				id: "change1",
-				plugin_key: "mock-plugin",
-				schema_key: "mock",
-				file_id: "mock",
-				entity_id: "value1",
-				snapshot_id: "no-content",
-			},
-		])
-		.execute();
-
-	const version0 = await createVersion({ lix, name: "version0" });
-
-	const version1 = await createVersion({ lix, name: "version1" });
-
-	// Create change conflicts
-	const mockConflict0 = await createChangeConflict({
-		lix,
-		version: version0,
-		key: "mock-conflict0",
-		conflictingChangeIds: new Set(["change0", "change1"]),
-	});
-
-	// conflict in another version that should not be returned
-	await createChangeConflict({
-		lix,
-		version: version1,
-		key: "mock-conflict1",
-		conflictingChangeIds: new Set(["change0"]),
-	});
-
-	// Query conflicts in the version
-	const conflictsInversion = await lix.db
-		.selectFrom("change_conflict")
-		.where(changeConflictInVersion(version0))
-		.selectAll()
-		.execute();
-
-	expect(conflictsInversion.length).toBe(1);
-	expect(conflictsInversion[0]?.id).toBe(mockConflict0.id);
-});

package/src/query-filter/change-conflict-in-version.ts

@@ -1,25 +0,0 @@
-import type { ExpressionBuilder, ExpressionWrapper, SqlBool } from "kysely";
-import type { Version, LixDatabaseSchema } from "../database/schema.js";
-
-/**
- * Filters if a conflict is in the given version.
- *
- * @example
- *   ```ts
- *   const conflicts = await lix.db.selectFrom("change_conflict")
- *      .where(changeConflictInVersion(currentVersion))
- *      .selectAll()
- *      .execute();
- *   ```
- */
-export function changeConflictInVersion(version: Pick<Version, "id">) {
-	return (
-		eb: ExpressionBuilder<LixDatabaseSchema, "change_conflict">
-	): ExpressionWrapper<LixDatabaseSchema, "change_conflict", SqlBool> =>
-		eb("change_conflict.id", "in", (subquery) =>
-			subquery
-				.selectFrom("version_change_conflict")
-				.select("change_conflict_id")
-				.where("version_change_conflict.version_id", "=", version.id)
-		);
-}

package/src/query-filter/change-in-version.test.ts

@@ -1,82 +0,0 @@
-import { expect, test } from "vitest";
-import { openLixInMemory } from "../lix/open-lix-in-memory.js";
-import { changeInVersion } from "./change-in-version.js";
-import { createVersion } from "../version/create-version.js";
-import { updateChangesInVersion } from "../version/update-changes-in-version.js";
-
-test("select changeInVersion should retrieve all changes in the version including ancestors", async () => {
-	const lix = await openLixInMemory({});
-
-	const version = await createVersion({ lix });
-
-	// Insert changes and create a parent-child chain in change_edge
-	const [, , changeC] = await lix.db
-		.insertInto("change")
-		.values([
-			{
-				id: "changeA",
-				entity_id: "entity1",
-				schema_key: "type1",
-				file_id: "file1",
-				plugin_key: "plugin1",
-				snapshot_id: "no-content",
-			},
-			{
-				id: "changeB",
-				entity_id: "entity1",
-				schema_key: "type1",
-				file_id: "file1",
-				plugin_key: "plugin1",
-				snapshot_id: "no-content",
-			},
-			{
-				id: "changeC",
-				entity_id: "entity1",
-				schema_key: "type1",
-				file_id: "file1",
-				plugin_key: "plugin1",
-				snapshot_id: "no-content",
-			},
-			{
-				id: "changeD",
-				entity_id: "entity1",
-				schema_key: "type1",
-				file_id: "file1",
-				plugin_key: "plugin1",
-				snapshot_id: "no-content",
-			},
-		])
-		.returningAll()
-		.execute();
-
-	// Link changes in change_edge (C <- B <- A)
-	await lix.db
-		.insertInto("change_edge")
-		.values([
-			{ parent_id: "changeA", child_id: "changeB" },
-			{ parent_id: "changeB", child_id: "changeC" },
-		])
-		.execute();
-
-	// Point the version to changeC, which should include changeA and changeB as ancestors
-	await updateChangesInVersion({
-		lix,
-		version,
-		changes: [changeC!],
-	});
-
-	const changes = await lix.db
-		.selectFrom("change")
-		.where(changeInVersion(version))
-		.selectAll()
-		.execute();
-
-	// Verify the returned changes include changeC and its ancestors changeA and changeB
-	const changeIds = changes.map((change) => change.id);
-
-	// change D is not pointed at in th version, so it should not be included
-	expect(changes).toHaveLength(3);
-	expect(changeIds).toContain("changeA");
-	expect(changeIds).toContain("changeB");
-	expect(changeIds).toContain("changeC");
-});

package/src/query-filter/change-in-version.ts

@@ -1,31 +0,0 @@
-import { ExpressionWrapper, sql } from "kysely";
-import type { Version, LixDatabaseSchema } from "../database/schema.js";
-import type { SqlBool } from "kysely";
-
-/**
- * Filters if a change is in the given Version.
- *
- * @example
- *   ```ts
- *   const changes = await lix.db.selectFrom("change")
- *      .where(changeInVersion(currentVersion))
- *      .selectAll()
- *      .execute();
- *   ```
- */
-export function changeInVersion(version: Pick<Version, "id">) {
-	return sql`
-    change.id IN (
-      WITH RECURSIVE recursive_changes(id) AS (
-        SELECT change_id AS id
-        FROM version_change
-        WHERE version_id = ${version.id}
-        UNION ALL
-        SELECT change_edge.parent_id AS id
-        FROM change_edge
-        INNER JOIN recursive_changes ON recursive_changes.id = change_edge.child_id
-      )
-      SELECT id FROM recursive_changes
-    )
-  ` as unknown as ExpressionWrapper<LixDatabaseSchema, "change", SqlBool>;
-}

package/src/query-filter/change-is-leaf-in-version.test.ts

@@ -1,77 +0,0 @@
-import { test, expect } from "vitest";
-import { openLixInMemory } from "../lix/open-lix-in-memory.js";
-import { updateChangesInVersion } from "../version/update-changes-in-version.js";
-import { changeIsLeafInVersion } from "./change-is-leaf-in-version.js";
-import { createVersion } from "../version/create-version.js";
-
-test("it should return the leaf change for the given version", async () => {
-	const lix = await openLixInMemory({});
-
-	const version0 = await createVersion({ lix, name: "version0" });
-	const version1 = await createVersion({ lix, name: "version1" });
-
-	const insertedChanges = await lix.db
-		.insertInto("change")
-		.values([
-			{
-				id: "change1",
-				snapshot_id: "no-content",
-				entity_id: "mock1",
-				file_id: "mock",
-				plugin_key: "mock",
-				schema_key: "mock",
-			},
-			{
-				id: "change2",
-				snapshot_id: "no-content",
-				entity_id: "mock1",
-				file_id: "mock",
-				plugin_key: "mock",
-				schema_key: "mock",
-			},
-			{
-				id: "change3",
-				snapshot_id: "no-content",
-				entity_id: "mock1",
-				file_id: "mock",
-				plugin_key: "mock",
-				schema_key: "mock",
-			},
-		])
-		.returningAll()
-		.execute();
-
-	await lix.db
-		.insertInto("change_edge")
-		.values([
-			// including change1 for re-assurance
-			{ parent_id: "change1", child_id: "change2" },
-			{ parent_id: "change2", child_id: "change3" },
-		])
-		.execute();
-
-	await updateChangesInVersion({
-		lix,
-		version: version0,
-		// only point to the second change even though
-		// the third change is a child of the second change
-		changes: [insertedChanges[1]!],
-	});
-
-	// letting another version (version1) point to the third change
-	await updateChangesInVersion({
-		lix,
-		version: version1,
-		changes: [insertedChanges[2]!],
-	});
-
-	const changes = await lix.db
-		.selectFrom("change")
-		.where(changeIsLeafInVersion(version0))
-		.selectAll()
-		.execute();
-
-	// change 2 is the leaf change for the current version
-	expect(changes).toHaveLength(1);
-	expect(changes[0]?.id).toBe("change2");
-});

package/src/query-filter/change-is-leaf-in-version.ts

@@ -1,36 +0,0 @@
-import { sql, type ExpressionWrapper, type SqlBool } from "kysely";
-import type { Version, LixDatabaseSchema } from "../database/schema.js";
-
-/**
- * Selects changes that are not a parent of any other change within the specified version.
- *
- *
- * @example
- *   ```ts
- *   await lix.db.selectFrom("change")
- *     .where(changeIsLeafInVersion(currentVersion))
- *     .selectAll()
- *     .execute();
- *   ```
- */
-export function changeIsLeafInVersion(version: Pick<Version, "id">) {
-	return sql`
-    change.id IN (
-      WITH RECURSIVE version_changes(id) AS (
-        SELECT change_id AS id
-        FROM version_change
-        WHERE version_id = ${version.id}
-        UNION ALL
-        SELECT change_edge.parent_id AS id
-        FROM change_edge
-        INNER JOIN version_changes ON version_changes.id = change_edge.child_id
-      )
-      SELECT id FROM version_changes
-      WHERE id NOT IN (
-        SELECT parent_id
-        FROM change_edge
-        WHERE child_id IN (SELECT id FROM version_changes)
-      )
-    )
-  ` as unknown as ExpressionWrapper<LixDatabaseSchema, "change", SqlBool>;
-}