@lix-js/sdk 0.0.1 → 0.2.0

package/src/lix/open-lix.test.ts

@@ -2,6 +2,8 @@ import { expect, test } from "vitest";
 import { openLixInMemory } from "./open-lix-in-memory.js";
 import { newLixFile } from "./new-lix.js";
 import type { LixPlugin } from "../plugin/lix-plugin.js";
+import { toBlob } from "./to-blob.js";
+import { usedFileExtensions } from "./open-lix.js";
 
 test("providing plugins should be possible", async () => {
 	const mockPlugin: LixPlugin = {
@@ -17,17 +19,90 @@ test("providing plugins should be possible", async () => {
 test("providing key values should be possible", async () => {
 	const lix = await openLixInMemory({
 		blob: await newLixFile(),
-		keyValues: [{ key: "key", value: "value" }],
+		keyValues: [{ key: "mock_key", value: "value" }],
 	});
-	const value = await lix.db.selectFrom("key_value").selectAll().execute();
-	expect(value).toContainEqual({ key: "key", value: "value" });
+
+	const value = await lix.db
+		.selectFrom("key_value")
+		.selectAll()
+		.where("key", "=", "mock_key")
+		.executeTakeFirstOrThrow();
+
+	expect(value).toMatchObject({ key: "mock_key", value: "value" });
 
 	// testing overwriting key values
 	const lix1 = await openLixInMemory({
-		blob: await lix.toBlob(),
-		keyValues: [{ key: "key", value: "value2" }],
+		blob: await toBlob({ lix }),
+		keyValues: [{ key: "mock_key", value: "value2" }],
+	});
+
+	const value1 = await lix1.db
+		.selectFrom("key_value")
+		.selectAll()
+		.where("key", "=", "mock_key")
+
+		.executeTakeFirstOrThrow();
+	expect(value1).toMatchObject({ key: "mock_key", value: "value2" });
+});
+
+test("providing an account should be possible", async () => {
+	const mockAccount = {
+		id: "mock-account",
+		name: "peter",
+	};
+
+	const lix = await openLixInMemory({
+		account: mockAccount,
+		blob: await newLixFile(),
+	});
+
+	const accounts = await lix.db
+		.selectFrom("active_account")
+		.selectAll()
+		.execute();
+
+	expect(accounts, "to be the provided account").toContainEqual(mockAccount);
+	expect(accounts, "no other active account is inserted").lengthOf(1);
+
+	await lix.db
+		.insertInto("key_value")
+		.values([{ key: "mock_key", value: "something" }])
+		.execute();
+
+	// lix automatically handles inserting the active account into the account table
+	const change = await lix.db
+		.selectFrom("change")
+		.innerJoin("change_author", "change_author.change_id", "change.id")
+		.where("schema_key", "=", "lix_key_value_table")
+		.where("entity_id", "=", "mock_key")
+		.select("change_author.account_id")
+		.executeTakeFirstOrThrow();
+
+	expect(change.account_id).toBe(mockAccount.id);
+});
+
+test("usedFileExtensions", async () => {
+	const lix = await openLixInMemory({
+		blob: await newLixFile(),
 	});
+	await lix.db
+		.insertInto("file")
+		.values([
+			{
+				path: "/test.txt",
+				data: new Uint8Array(),
+			},
+			{
+				path: "/test2.txt",
+				data: new Uint8Array(),
+			},
+			{
+				path: "/folder/folderwithdot./doc.pdf",
+				data: new Uint8Array(),
+			},
+		])
+		.execute();
 
-	const value1 = await lix1.db.selectFrom("key_value").selectAll().execute();
-	expect(value1).toContainEqual({ key: "key", value: "value2" });
+	const extensions = await usedFileExtensions(lix.db);
+	expect(new Set(extensions)).toEqual(new Set(["txt", "pdf"]));
 });

package/src/lix/open-lix.ts

@@ -1,13 +1,15 @@
 import type { LixPlugin } from "../plugin/lix-plugin.js";
 import { loadPlugins } from "../plugin/load-plugin.js";
-import { contentFromDatabase, type SqliteDatabase } from "sqlite-wasm-kysely";
+import { type SqliteDatabase } from "sqlite-wasm-kysely";
 import { initDb } from "../database/init-db.js";
-import { initChangeQueue } from "../change-queue/init-change-queue.js";
-import { changeQueueSettled } from "../change-queue/change-queue-settled.js";
-import type { Kysely } from "kysely";
+import { initFileQueueProcess } from "../file-queue/file-queue-process.js";
+import { sql, type Kysely } from "kysely";
 import type { LixDatabaseSchema } from "../database/schema.js";
 import { initSyncProcess } from "../sync/sync-process.js";
-import type { KeyValue } from "../key-value/database-schema.js";
+import type { NewKeyValue } from "../key-value/database-schema.js";
+import { capture } from "../services/telemetry/capture.js";
+import { ENV_VARIABLES } from "../services/env-variables/index.js";
+import type { Account } from "../account/database-schema.js";
 
 export type Lix = {
 	/**
@@ -22,17 +24,25 @@ export type Lix = {
 	 */
 	sqlite: SqliteDatabase;
 	db: Kysely<LixDatabaseSchema>;
-	toBlob: () => Promise<Blob>;
 	plugin: {
 		getAll: () => Promise<LixPlugin[]>;
 	};
-	close: () => Promise<void>;
 };
 
 /**
  * Common setup between different lix environments.
  */
 export async function openLix(args: {
+	/**
+	 * The account that is opening this lix.
+	 *
+	 * Lix will automatically set the active account to the provided account.
+	 *
+	 * @example
+	 *   const account = localStorage.getItem("account")
+	 *   const lix = await openLix({ account })
+	 */
+	account?: Account;
 	database: SqliteDatabase;
 	/**
 	 * Usecase are lix apps that define their own file format,
@@ -52,9 +62,9 @@ export async function openLix(args: {
 	 * Set the key values when opening the lix.
 	 *
 	 * @example
-	 *   const lix = await openLix({ keyValues: [{ key: "#lix_sync", value: "false" }] })
+	 *   const lix = await openLix({ keyValues: [{ key: "lix_sync", value: "false" }] })
 	 */
-	keyValues?: KeyValue[];
+	keyValues?: NewKeyValue[];
 }): Promise<Lix> {
 	const db = initDb({ sqlite: args.database });
 
@@ -68,6 +78,18 @@ export async function openLix(args: {
 			.execute();
 	}
 
+	if (args.account) {
+		await db.transaction().execute(async (trx) => {
+			// delete the default inserted active account from `initDb`
+			await trx.deleteFrom("active_account").execute();
+			await trx
+				.insertInto("active_account")
+				.values(args.account!)
+				.onConflict((oc) => oc.doUpdateSet(() => ({ ...args.account })))
+				.execute();
+		});
+	}
+
 	const plugins = await loadPlugins(db);
 	if (args.providePlugins && args.providePlugins.length > 0) {
 		plugins.push(...args.providePlugins);
@@ -77,27 +99,85 @@ export async function openLix(args: {
 		getAll: async () => plugins,
 	};
 
-	const toBlob = async () => {
-		await changeQueueSettled({ lix: { db } });
-		return new Blob([contentFromDatabase(args.database)]);
-	};
+	initFileQueueProcess({ lix: { db, plugin, sqlite: args.database } });
 
-	initChangeQueue({
-		lix: { db, plugin, sqlite: args.database },
-		rawDatabase: args.database,
-	});
+	initSyncProcess({ lix: { db, plugin, sqlite: args.database } });
 
-	initSyncProcess({ lix: { db, plugin, toBlob } });
+	captureOpened({ db });
 
 	return {
 		db,
 		sqlite: args.database,
-		toBlob,
 		plugin,
-		close: async () => {
-			await changeQueueSettled({ lix: { db } });
-			// args.database.close();
-			// await db.destroy();
-		},
 	};
 }
+
+async function captureOpened(args: { db: Kysely<LixDatabaseSchema> }) {
+	try {
+		const telemetry = await args.db
+			.selectFrom("key_value")
+			.select("value")
+			.where("key", "=", "lix_telemetry")
+			.executeTakeFirst();
+
+		if (telemetry?.value === "off") {
+			return;
+		}
+
+		const activeAccount = await args.db
+			.selectFrom("active_account")
+			.select("id")
+			.executeTakeFirstOrThrow();
+
+		const lixId = await args.db
+			.selectFrom("key_value")
+			.select("value")
+			.where("key", "=", "lix_id")
+			.executeTakeFirstOrThrow();
+
+		const fileExtensions = await usedFileExtensions(args.db);
+
+		await capture("LIX-SDK lix opened", {
+			accountId: activeAccount.id,
+			lixId: lixId.value,
+			telemetryKeyValue: telemetry?.value ?? "on",
+			properties: {
+				lix_sdk_version: ENV_VARIABLES.LIX_SDK_VERSION,
+				stored_file_extensions: fileExtensions,
+			},
+		});
+	} catch {
+		// ignore
+	}
+}
+
+/**
+ * Get all used file extensions.
+ */
+export async function usedFileExtensions(
+	db: Kysely<LixDatabaseSchema>
+): Promise<any> {
+	const result = await sql`
+	WITH RECURSIVE numbers(i) AS (
+		SELECT 1
+		UNION ALL
+		SELECT i + 1 FROM numbers WHERE i < 1000 -- Limit to 1000 characters for path length
+	),
+	REVERSED AS (
+		SELECT id,
+					GROUP_CONCAT(SUBSTR(path, LENGTH(path) - i + 1, 1), '') AS reversed_path
+		FROM file, numbers
+		WHERE i <= LENGTH(path)
+		GROUP BY id, path
+	),
+	EXTENSIONS AS (
+		SELECT DISTINCT SUBSTR(path, LENGTH(path) - INSTR(reversed_path, '.') + 2) AS extension
+		FROM file
+		JOIN REVERSED ON file.id = REVERSED.id
+		WHERE INSTR(reversed_path, '.') > 0
+	)
+	SELECT extension FROM EXTENSIONS;
+	`.execute(db);
+
+	return result.rows.map((row) => (row as any).extension);
+}

package/src/lix/to-blob.ts

@@ -0,0 +1,14 @@
+import { contentFromDatabase } from "sqlite-wasm-kysely";
+import type { Lix } from "./open-lix.js";
+
+/**
+ * Convert the lix to a blob.
+ *
+ * @example
+ *   const blob = await toBlob({ lix })
+ */
+export async function toBlob(args: {
+	lix: Pick<Lix, "db" | "sqlite">;
+}): Promise<Blob> {
+	return new Blob([contentFromDatabase(args.lix.sqlite)]);
+}

package/src/{own-entity-change-control/apply-own-entity-change.test.ts → own-change-control/apply-own-change.test.ts}

@@ -5,9 +5,9 @@ import type {
 	ChangeSet,
 	ChangeSetElement,
 } from "../database/schema.js";
-import { applyOwnEntityChanges } from "./apply-own-entity-change.js";
+import { applyOwnChanges } from "./apply-own-change.js";
 import { mockJsonSnapshot } from "../snapshot/mock-json-snapshot.js";
-import { type KeyValue } from "../key-value/database-schema.js";
+import { type NewKeyValue } from "../key-value/database-schema.js";
 
 test("it should apply insert changes correctly", async () => {
 	const lix = await openLixInMemory({});
@@ -21,8 +21,8 @@ test("it should apply insert changes correctly", async () => {
 		id: "change1",
 		entity_id: "key1",
 		schema_key: "lix_key_value_table",
-		plugin_key: "lix_own_entity",
-		file_id: "null",
+		plugin_key: "lix_own_change_control",
+		file_id: "lix_own_change_control",
 		snapshot_id: snapshot.id,
 		created_at: "2021-01-01T00:00:00.000Z",
 	};
@@ -32,7 +32,7 @@ test("it should apply insert changes correctly", async () => {
 		.values({ content: snapshot.content })
 		.execute();
 
-	await applyOwnEntityChanges({ lix, changes: [change] });
+	await applyOwnChanges({ lix, changes: [change] });
 
 	const result = await lix.db
 		.selectFrom("key_value")
@@ -40,7 +40,7 @@ test("it should apply insert changes correctly", async () => {
 		.selectAll()
 		.executeTakeFirst();
 
-	expect(result).toEqual({ key: "key1", value: "value1" });
+	expect(result).toMatchObject({ key: "key1", value: "value1" });
 });
 
 test("it should apply update changes correctly", async () => {
@@ -60,9 +60,9 @@ test("it should apply update changes correctly", async () => {
 		id: "change1",
 		schema_key: "lix_key_value_table",
 		entity_id: "key1",
-		file_id: "null",
+		file_id: "lix_own_change_control",
 		created_at: "2021-01-01T00:00:00.000Z",
-		plugin_key: "lix_own_entity",
+		plugin_key: "lix_own_change_control",
 		snapshot_id: snapshot.id,
 	};
 
@@ -73,7 +73,7 @@ test("it should apply update changes correctly", async () => {
 		})
 		.execute();
 
-	await applyOwnEntityChanges({ lix, changes: [change] });
+	await applyOwnChanges({ lix, changes: [change] });
 
 	const result = await lix.db
 		.selectFrom("key_value")
@@ -81,7 +81,7 @@ test("it should apply update changes correctly", async () => {
 		.selectAll()
 		.executeTakeFirst();
 
-	expect(result).toEqual({ key: "key1", value: "new_value" });
+	expect(result).toMatchObject({ key: "key1", value: "new_value" });
 });
 
 test("it should apply delete changes correctly", async () => {
@@ -95,14 +95,14 @@ test("it should apply delete changes correctly", async () => {
 	const change: Change = {
 		id: "change1",
 		schema_key: "lix_key_value_table",
-		file_id: "null",
+		file_id: "lix_own_change_control",
 		created_at: "2021-01-01T00:00:00.000Z",
 		entity_id: "key1",
-		plugin_key: "lix_own_entity",
+		plugin_key: "lix_own_change_control",
 		snapshot_id: "no-content",
 	};
 
-	await applyOwnEntityChanges({ lix, changes: [change] });
+	await applyOwnChanges({ lix, changes: [change] });
 
 	const result = await lix.db
 		.selectFrom("key_value")
@@ -120,7 +120,7 @@ test("it should throw an error for invalid plugin key", async () => {
 		id: "change1",
 		schema_key: "lix_key_value_table",
 		entity_id: "key1",
-		file_id: "null",
+		file_id: "lix_own_change_control",
 		created_at: "2021-01-01T00:00:00.000Z",
 		plugin_key: "invalid-plugin",
 		snapshot_id: "snapshot1",
@@ -138,10 +138,8 @@ test("it should throw an error for invalid plugin key", async () => {
 		})
 		.execute();
 
-	await expect(
-		applyOwnEntityChanges({ lix, changes: [change] })
-	).rejects.toThrow(
-		"Expected 'lix_own_entity' as plugin key but received invalid-plugin"
+	await expect(applyOwnChanges({ lix, changes: [change] })).rejects.toThrow(
+		"Expected 'lix_own_change_control' as plugin key but received invalid-plugin"
 	);
 });
 
@@ -189,13 +187,13 @@ test("file.data is not changed by applyOwnEntityChanges", async () => {
 		id: "change1",
 		entity_id: file.id,
 		schema_key: "lix_file_table",
-		plugin_key: "lix_own_entity",
+		plugin_key: "lix_own_change_control",
 		file_id: "null",
 		snapshot_id: snapshot.id,
 		created_at: "2021-01-01T00:00:00.000Z",
 	};
 
-	await applyOwnEntityChanges({ lix, changes: [mockChange] });
+	await applyOwnChanges({ lix, changes: [mockChange] });
 
 	const result = await lix.db
 		.selectFrom("file")
@@ -230,7 +228,7 @@ test("foreign key constraints are deferred to make the order of applying changes
 			id: "change2",
 			entity_id: "change-set-1,change0",
 			schema_key: "lix_change_set_element_table",
-			plugin_key: "lix_own_entity",
+			plugin_key: "lix_own_change_control",
 			file_id: "null",
 			snapshot_id: snapshots[1].id,
 			created_at: "2021-01-01T00:00:00.000Z",
@@ -239,7 +237,7 @@ test("foreign key constraints are deferred to make the order of applying changes
 			id: "change1",
 			entity_id: "change-set-1",
 			schema_key: "lix_change_set_table",
-			plugin_key: "lix_own_entity",
+			plugin_key: "lix_own_change_control",
 			file_id: "null",
 			snapshot_id: snapshots[0].id,
 			created_at: "2021-01-01T00:00:00.000Z",
@@ -270,7 +268,7 @@ test("foreign key constraints are deferred to make the order of applying changes
 		.execute();
 
 	await expect(
-		applyOwnEntityChanges({ lix, changes: mockChanges })
+		applyOwnChanges({ lix, changes: mockChanges })
 	).resolves.toBeUndefined();
 });
 
@@ -291,8 +289,8 @@ test("foreign key constraints are obeyed", async () => {
 			// the change set for this change does not exist
 			entity_id: "change-set-1,change0",
 			schema_key: "lix_change_set_element_table",
-			plugin_key: "lix_own_entity",
-			file_id: "null",
+			plugin_key: "lix_own_change_control",
+			file_id: "lix_own_change_control",
 			snapshot_id: snapshots[0].id,
 			created_at: "2021-01-01T00:00:00.000Z",
 		},
@@ -321,9 +319,7 @@ test("foreign key constraints are obeyed", async () => {
 		})
 		.execute();
 
-	expect(
-		applyOwnEntityChanges({ lix, changes: mockChanges })
-	).rejects.toThrow();
+	expect(applyOwnChanges({ lix, changes: mockChanges })).rejects.toThrow();
 });
 
 // https://github.com/opral/lix-sdk/issues/185
@@ -333,7 +329,7 @@ test("applying own entity changes doesn't lead to the creation of new changes",
 	const snapshot = mockJsonSnapshot({
 		key: "mock-key",
 		value: "1+1=2",
-	} satisfies KeyValue);
+	} satisfies NewKeyValue);
 
 	await lix.db
 		.insertInto("snapshot")
@@ -344,14 +340,14 @@ test("applying own entity changes doesn't lead to the creation of new changes",
 
 	const changesBefore = await lix.db.selectFrom("change").selectAll().execute();
 
-	await applyOwnEntityChanges({
+	await applyOwnChanges({
 		lix,
 		changes: [
 			{
 				id: "change0",
 				entity_id: "mock-key",
 				file_id: "null",
-				plugin_key: "lix_own_entity",
+				plugin_key: "lix_own_change_control",
 				schema_key: "lix_key_value_table",
 				snapshot_id: snapshot.id,
 				created_at: "2021-01-01T00:00:00Z",

package/src/{own-entity-change-control/apply-own-entity-change.ts → own-change-control/apply-own-change.ts}

@@ -16,7 +16,7 @@ import { withSkipOwnChangeControl } from "./with-skip-own-change-control.js";
 /**
  * Applies own changes to lix itself.
  */
-export async function applyOwnEntityChanges(args: {
+export async function applyOwnChanges(args: {
 	lix: Pick<Lix, "db">;
 	changes: Change[];
 }): Promise<void> {
@@ -31,9 +31,9 @@ export async function applyOwnEntityChanges(args: {
 
 			await Promise.all(
 				args.changes.map(async (change) => {
-					if (change.plugin_key !== "lix_own_entity") {
+					if (change.plugin_key !== "lix_own_change_control") {
 						throw new Error(
-							"Expected 'lix_own_entity' as plugin key but received " +
+							"Expected 'lix_own_change_control' as plugin key but received " +
 								change.plugin_key
 						);
 					}

package/src/{own-entity-change-control → own-change-control}/change-controlled-tables.ts

@@ -5,7 +5,6 @@ export const changeControlledTableIds = {
 	change_author: ["change_id", "account_id"],
 	change_set_element: ["change_set_id", "change_id"],
 	change_set_label: ["label_id", "change_set_id"],
-	change_set_label_author: ["label_id", "change_set_id", "account_id"],
 	discussion: ["id"],
 	file: ["id"],
 	key_value: ["key"],

package/src/{own-entity-change-control → own-change-control}/database-triggers.test.ts

@@ -35,12 +35,12 @@ test("it works for inserts, updates and deletions", async () => {
 
 	for (const change of changes) {
 		expect(change.entity_id).toBe("key1");
-		expect(change.file_id).toBe("null");
-		expect(change.plugin_key).toBe("lix_own_entity");
+		expect(change.file_id).toBe("lix_own_change_control");
+		expect(change.plugin_key).toBe("lix_own_change_control");
 		expect(change.schema_key).toBe("lix_key_value_table");
 	}
 
-	expect(snapshots).toStrictEqual([
+	expect(snapshots).toMatchObject([
 		// insert
 		{ key: "key1", value: "value1" },
 		// update
@@ -125,23 +125,23 @@ test("if the trigger throws, the transaction is rolled back", async () => {
 	expect(deleteChange).toBeUndefined();
 });
 
-test("skips change control of key values if the key begins with `#`", async () => {
+test("skips change control of key values if `skip_change_control` is set to true", async () => {
 	const lix = await openLixInMemory({});
 
 	await lix.db
 		.insertInto("key_value")
-		.values({ key: "#key1", value: "value1" })
+		.values({ key: "key1", value: "value1", skip_change_control: true })
 		.execute();
 
 	const key1 = await lix.db
 		.selectFrom("key_value")
-		.where("key", "=", "#key1")
+		.where("key", "=", "key1")
 		.selectAll()
 		.executeTakeFirst();
 
 	const key1Change = await lix.db
 		.selectFrom("change")
-		.where("entity_id", "=", "#key1")
+		.where("entity_id", "=", "key1")
 		.selectAll()
 		.executeTakeFirst();
 

package/src/{own-entity-change-control → own-change-control}/database-triggers.ts

@@ -9,7 +9,7 @@ import {
 import { createChange } from "../change/create-change.js";
 import { executeSync } from "../database/execute-sync.js";
 
-export function applyOwnEntityChangeControlTriggers(
+export function applyOwnChangeControlTriggers(
 	sqlite: SqliteDatabase,
 	db: Kysely<LixDatabaseSchema>
 ): void {
@@ -24,7 +24,7 @@ export function applyOwnEntityChangeControlTriggers(
 	}
 
 	sqlite.createFunction({
-		name: "handle_lix_own_entity_change",
+		name: "handle_lix_own_change_control",
 		arity: -1,
 		// @ts-expect-error - dynamic function
 		xFunc: (
@@ -51,7 +51,7 @@ export function applyOwnEntityChangeControlTriggers(
       CREATE TEMP TRIGGER IF NOT EXISTS ${table}_change_control_insert
       AFTER INSERT ON ${table}
       BEGIN
-        SELECT handle_lix_own_entity_change('${table}', 'insert', ${tableInfo.map((c) => "NEW." + c.name).join(", ")});
+        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
@@ -69,13 +69,13 @@ export function applyOwnEntityChangeControlTriggers(
 					: ""
 			}
       BEGIN
-        SELECT handle_lix_own_entity_change('${table}', 'update', ${tableInfo.map((c) => "NEW." + c.name).join(", ")});
+        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_entity_change('${table}', 'delete', ${tableInfo.map((c) => "OLD." + c.name).join(", ")});
+        SELECT handle_lix_own_change_control('${table}', 'delete', ${tableInfo.map((c) => "OLD." + c.name).join(", ")});
       END;
       `;
 
@@ -93,8 +93,8 @@ function handleLixOwnEntityChange(
 ): void {
 	const lix = { db, sqlite };
 
-	// keys starting with `#` are not change controlled
-	if (tableName === "key_value" && values[0].startsWith("#")) {
+	// key values that have skip_change_control set to true should not be change controlled
+	if (tableName === "key_value" && values[2]) {
 		return;
 	}
 
@@ -103,7 +103,7 @@ function handleLixOwnEntityChange(
 			lix,
 			query: db
 				.selectFrom("key_value")
-				.where("key", "=", "#lix_skip_own_change_control")
+				.where("key", "=", "lix_skip_own_change_control")
 				.select("value"),
 		})[0]?.value === "true";
 
@@ -120,7 +120,7 @@ function handleLixOwnEntityChange(
 			.select("plugin_key"),
 	})[0];
 
-	if (change?.plugin_key === "lix_own_entity") {
+	if (change?.plugin_key === "lix_own_change_control") {
 		return;
 	}
 
@@ -177,8 +177,8 @@ function handleLixOwnEntityChange(
 			authors: authors,
 			version: currentVersion,
 			entityId,
-			fileId: "null",
-			pluginKey: "lix_own_entity",
+			fileId: "lix_own_change_control",
+			pluginKey: "lix_own_change_control",
 			schemaKey: `lix_${tableName}_table`,
 			snapshotContent,
 		},

package/src/{own-entity-change-control → own-change-control}/with-skip-own-change-control.ts

@@ -7,7 +7,11 @@ export async function withSkipOwnChangeControl<T>(
 	const executeInTransaction = async (trx: Lix["db"]) => {
 		await trx
 			.insertInto("key_value")
-			.values({ key: "#lix_skip_own_change_control", value: "true" })
+			.values({
+				key: "lix_skip_own_change_control",
+				value: "true",
+				skip_change_control: true,
+			})
 			.onConflict((oc) => oc.doUpdateSet({ value: "true" }))
 			.execute();
 
@@ -16,7 +20,7 @@ export async function withSkipOwnChangeControl<T>(
 
 		await trx
 			.deleteFrom("key_value")
-			.where("key", "=", "#lix_skip_own_change_control")
+			.where("key", "=", "lix_skip_own_change_control")
 			.execute();
 
 		// Return the result of the operation