@inlang/sdk 0.36.3 → 2.0.0-prerelease.0

package/node_modules/@lix-js/sdk/src/file-queue/with-skip-file-queue.test.ts

@@ -0,0 +1,158 @@
+import { expect, test } from "vitest";
+import type { LixPlugin } from "../plugin/lix-plugin.js";
+import { openLixInMemory } from "../lix/open-lix-in-memory.js";
+import { fileQueueSettled } from "./file-queue-settled.js";
+import { withSkipFileQueue } from "./with-skip-file-queue.js";
+
+test("skipping the file queue should be possible", async () => {
+	const mockPlugin: LixPlugin = {
+		key: "mock-plugin",
+		detectChangesGlob: "*",
+		detectChanges: async ({ after }) => {
+			const textAfter = after
+				? new TextDecoder().decode(after.data)
+				: undefined;
+			return [
+				{
+					schema: {
+						key: "text",
+						type: "json",
+					},
+					entity_id: "test",
+					snapshot: { text: textAfter },
+				},
+			];
+		},
+	};
+
+	const lix = await openLixInMemory({
+		providePlugins: [mockPlugin],
+	});
+
+	await lix.db
+		.insertInto("file")
+		.values({
+			id: "test",
+			data: new TextEncoder().encode("update0"),
+			path: "/test.txt",
+		})
+		.execute();
+
+	await fileQueueSettled({ lix });
+
+	const changes0 = await lix.db
+		.selectFrom("change")
+		.innerJoin("snapshot", "snapshot.id", "change.snapshot_id")
+		.where("schema_key", "=", "text")
+		.selectAll()
+		.execute();
+
+	expect(changes0).toHaveLength(1);
+	expect(changes0[0]?.content).toEqual({ text: "update0" });
+
+	await withSkipFileQueue(lix.db, async (trx) => {
+		await trx
+			.updateTable("file")
+			.set({
+				data: new TextEncoder().encode("update1"),
+			})
+			.where("id", "=", "test")
+			.execute();
+	});
+
+	await fileQueueSettled({ lix });
+
+	const changes1 = await lix.db
+		.selectFrom("change")
+		.innerJoin("snapshot", "snapshot.id", "change.snapshot_id")
+		.selectAll()
+		.where("schema_key", "=", "text")
+		.execute();
+
+	// change is skipped, so no new change is created
+	expect(changes1).toHaveLength(1);
+	expect(changes1[0]?.content).toEqual({ text: "update0" });
+});
+
+test("skipping the file queue should be possible with multiple changes", async () => {
+	const mockPlugin: LixPlugin = {
+		key: "mock-plugin",
+		detectChangesGlob: "*",
+		detectChanges: async ({ after }) => {
+			const textAfter = after
+				? new TextDecoder().decode(after.data)
+				: undefined;
+			return [
+				{
+					schema: {
+						key: "text",
+						type: "json",
+					},
+					entity_id: "test",
+					snapshot: { text: textAfter },
+				},
+			];
+		},
+	};
+
+	const lix = await openLixInMemory({
+		providePlugins: [mockPlugin],
+	});
+
+	await lix.db
+		.insertInto("file")
+		.values({
+			id: "test",
+			data: new TextEncoder().encode("initial"),
+			path: "/test.txt",
+		})
+		.execute();
+
+	const manyUpdates = Array.from({ length: 100 }, (_, i) => `update${i}`);
+
+	const first50Updates = manyUpdates.slice(0, 50);
+	const last50Updates = manyUpdates.slice(50);
+
+	await lix.db.transaction().execute(async (trx) => {
+		for (const update of first50Updates) {
+			await trx
+				.updateTable("file")
+				.set({
+					data: new TextEncoder().encode(update),
+				})
+				.where("id", "=", "test")
+				.execute();
+		}
+		for (const update of last50Updates) {
+			await withSkipFileQueue(trx, async (trx) => {
+				await trx
+					.updateTable("file")
+					.set({
+						data: new TextEncoder().encode(update),
+					})
+					.where("id", "=", "test")
+					.execute();
+			});
+		}
+	});
+
+	await fileQueueSettled({ lix });
+
+	const file = await lix.db
+		.selectFrom("file")
+		.selectAll()
+		.where("id", "=", "test")
+		.executeTakeFirstOrThrow();
+
+	const changes = await lix.db
+		.selectFrom("change")
+		.innerJoin("snapshot", "snapshot.id", "change.snapshot_id")
+		.where("file_id", "=", file.id)
+		.selectAll()
+		.execute();
+
+	// expecting the latest change
+	expect(file.data).toEqual(new TextEncoder().encode("update99"));
+	// and only 50 changes + 1 insert change have been created
+	expect(changes).toHaveLength(51);
+});

package/node_modules/@lix-js/sdk/src/file-queue/with-skip-file-queue.ts

@@ -0,0 +1,33 @@
+import type { Lix } from "../lix/open-lix.js";
+
+export async function withSkipFileQueue<T>(
+	db: Lix["db"],
+	operation: (trx: Lix["db"]) => Promise<T>
+): Promise<T> {
+	const executeInTransaction = async (trx: Lix["db"]) => {
+		const queryEntryBefore = await trx
+			.selectFrom("file_queue")
+			.selectAll()
+			.orderBy("id desc")
+			.executeTakeFirst();
+
+		// Perform the user's operation
+		const result = await operation(trx);
+
+		// delete queue entries that came after
+		// the queue entry before the transaction
+
+		await trx
+			.deleteFrom("file_queue")
+			.where("id", ">", queryEntryBefore?.id ?? 0)
+			.execute();
+
+		// Return the result of the operation
+		return result;
+	};
+	if (db.isTransaction) {
+		return executeInTransaction(db);
+	} else {
+		return db.transaction().execute(executeInTransaction);
+	}
+}

package/node_modules/@lix-js/sdk/src/index.ts

@@ -0,0 +1,16 @@
+export * from "./account/index.js";
+export * from "./change/index.js";
+export * from "./change-set/index.js";
+export * from "./change-conflict/index.js";
+export * from "./file-queue/index.js";
+export * from "./change-schema/index.js";
+export * from "./database/index.js";
+export * from "./discussion/index.js";
+export * from "./file/index.js";
+export * from "./lix/index.js";
+export * from "./own-change-control/index.js";
+export * from "./plugin/index.js";
+export * from "./query-filter/index.js";
+export * from "./server-api-handler/index.js";
+export * from "./snapshot/index.js";
+export * from "./version/index.js";

package/node_modules/@lix-js/sdk/src/key-value/database-schema.test.ts

@@ -0,0 +1,140 @@
+import { sql } from "kysely";
+import { expect, test } from "vitest";
+import { openLixInMemory } from "../lix/open-lix-in-memory.js";
+
+test("string values are accepted", async () => {
+	const lix = await openLixInMemory({});
+
+	const result = await lix.db
+		.insertInto("key_value")
+		.values({
+			key: "foo",
+			value: "bar",
+		})
+		.returningAll()
+		.execute();
+
+	expect(result).toMatchObject([
+		{
+			key: "foo",
+			value: "bar",
+		},
+	]);
+});
+
+test("duplicate keys lead to an error", async () => {
+	const lix = await openLixInMemory({});
+
+	await lix.db
+		.insertInto("key_value")
+		.values({
+			key: "foo",
+			value: "bar",
+		})
+		.returningAll()
+		.execute();
+
+	expect(
+		lix.db
+			.insertInto("key_value")
+			.values({
+				key: "foo",
+				value: "bar",
+			})
+			.returningAll()
+			.execute()
+	).rejects.toThrowErrorMatchingInlineSnapshot(
+		`[SQLite3Error: SQLITE_CONSTRAINT_PRIMARYKEY: sqlite3 result code 1555: UNIQUE constraint failed: key_value.key]`
+	);
+});
+
+test("using json as value should work", async () => {
+	const lix = await openLixInMemory({});
+
+	await lix.db
+		.insertInto("key_value")
+		.values([
+			{
+				key: "foo",
+				value: JSON.stringify({
+					bar: "baz",
+					age: 42,
+					location: "Berlin",
+				}),
+			},
+		])
+		.returningAll()
+		.execute();
+
+	const onlyOneProperty = await lix.db
+		.selectFrom("key_value")
+		.where("key", "=", "foo")
+		.select(sql`json_extract(value, '$.bar')`.as("bar"))
+		.executeTakeFirstOrThrow();
+
+	// The JSON parsing plugin needs improvements.
+	// not important for now
+	// const parsedAsJson = await db
+	// 	.selectFrom("key_value")
+	// 	.where("key", "=", "foo")
+	// 	.select(sql`json(value)`.as("value"))
+	// 	.executeTakeFirstOrThrow();
+
+	// expect(parsedAsJson).toMatchObject({
+	// 	value: {
+	// 		bar: "baz",
+	// 		age: 42,
+	// 		location: "Berlin",
+	// 	},
+	// });
+
+	expect(onlyOneProperty).toMatchObject({
+		bar: "baz",
+	});
+});
+
+// 1919T IDs needed, in order to have a 1% probability of at least one collision.
+test("it should default add nano_id(18) for the lix_id if not exits", async () => {
+	const lix = await openLixInMemory({});
+
+	const result = await lix.db
+		.selectFrom("key_value")
+		.where("key", "=", "lix_id")
+		.selectAll()
+		.executeTakeFirstOrThrow();
+
+	expect(result.value).toHaveLength(18);
+});
+
+test("default value for lix_sync to reduce conditional logic (the key is always set)", async () => {
+	const lix = await openLixInMemory({});
+
+	const result = await lix.db
+		.selectFrom("key_value")
+		.where("key", "=", "lix_sync")
+		.selectAll()
+		.executeTakeFirstOrThrow();
+
+	expect(result.value).toBe("false");
+});
+
+test("skip_change_control should default to false", async () => {
+	const lix = await openLixInMemory({});
+
+	const result = await lix.db
+		.insertInto("key_value")
+		.values({ key: "mock_key", value: "mock_value" })
+		.returningAll()
+		.executeTakeFirstOrThrow();
+
+	expect(result.skip_change_control).toBeFalsy();
+
+	const updated = await lix.db
+		.updateTable("key_value")
+		.set({ skip_change_control: true })
+		.where("key", "=", "mock_key")
+		.returningAll()
+		.executeTakeFirstOrThrow();
+
+	expect(updated.skip_change_control).toBeTruthy();
+});

package/node_modules/@lix-js/sdk/src/key-value/database-schema.ts

@@ -0,0 +1,66 @@
+import type { Generated, Insertable, Selectable, Updateable } from "kysely";
+import type { SqliteDatabase } from "sqlite-wasm-kysely";
+
+export function applyKeyValueDatabaseSchema(
+	sqlite: SqliteDatabase
+): SqliteDatabase {
+	return sqlite.exec`
+	CREATE TABLE IF NOT EXISTS key_value (
+		key TEXT PRIMARY KEY,
+		value TEXT NOT NULL,
+
+		-- Options
+		skip_change_control INT DEFAULT FALSE
+	) STRICT;
+
+	INSERT OR IGNORE INTO key_value (key, value)
+	VALUES ('lix_id', nano_id(18));
+
+	-- default value for lix sync to false
+	-- if not exist to remove conditional logic
+	-- if the key exists or not
+	INSERT OR IGNORE INTO key_value (key, value, skip_change_control)
+	VALUES ('lix_sync', 'false', 1);
+`;
+}
+
+export type KeyValue = Selectable<KeyValueTable>;
+export type NewKeyValue = Insertable<KeyValueTable>;
+export type KeyValueUpdate = Updateable<KeyValueTable>;
+export type KeyValueTable = {
+	/**
+	 * The key of the key-value pair.
+	 *
+	 * Lix prefixes its keys with "lix-" to avoid conflicts with user-defined keys.
+	 *
+	 * @example
+	 *   "namespace-cool-key"
+	 */
+	key: KeyValueKeys;
+	/**
+	 * The value of the key-value pair.
+	 *
+	 * Must be a string. A JSON is a string too ;)
+	 *
+	 * @example
+	 *   "some value"
+	 *   "{ "foo": "bar" }"
+	 *
+	 */
+	value: string;
+	/**
+	 * If `true`, the key-value pair is not tracked with own change control.
+	 *
+	 * Carefull (!) when querying the database. The return value will be `0` or `1`.
+	 * SQLite does not have a boolean select type https://www.sqlite.org/datatype3.html.
+	 *
+	 * @default false
+	 */
+	skip_change_control: Generated<boolean>;
+};
+
+type PredefinedKeys = "lix_id" | "lix_server_url" | "lix_sync";
+// The string & {} ensures TypeScript recognizes KeyValueKeys
+// as a superset of string, preventing conflicts when using other string values.
+type KeyType = string & {};
+type KeyValueKeys = PredefinedKeys | KeyType;

package/node_modules/@lix-js/sdk/src/lix/close-lix.ts

@@ -0,0 +1,8 @@
+import type { Lix } from "./open-lix.js";
+
+/**
+ * Closes the lix.
+ */
+export async function closeLix(args: { lix: Pick<Lix, "db"> }): Promise<void> {
+	await args.lix.db.destroy();
+}

package/node_modules/@lix-js/sdk/src/lix/index.ts

@@ -0,0 +1,7 @@
+export { type Lix, openLix } from "./open-lix.js";
+export { openLixInMemory } from "./open-lix-in-memory.js";
+export { newLixFile } from "./new-lix.js";
+export { toBlob } from "./to-blob.js";
+// not exporting merge for api stability milestone
+// will need an overhaul to be stable
+// export { merge } from "./merge.js";

package/node_modules/@lix-js/sdk/src/lix/merge.get-leaf-changes-only-in-source.test.ts

@@ -0,0 +1,143 @@
+import { test, expect } from "vitest";
+import { getLeafChangesOnlyInSource } from "./merge.get-leaf-changes-only-in-source.js";
+import { openLixInMemory } from "./open-lix-in-memory.js";
+import { newLixFile } from "./new-lix.js";
+import type { NewChange } from "../database/schema.js";
+import { mockJsonSnapshot } from "../snapshot/mock-json-snapshot.js";
+
+test("it should get the leaf changes that only exist in source", async () => {
+	const sourceLix = await openLixInMemory({
+		blob: await newLixFile(),
+	});
+	const targetLix = await openLixInMemory({
+		blob: await newLixFile(),
+	});
+
+	const commonSnapshots = [
+		mockJsonSnapshot({ id: "mock-id", color: "red" }),
+		mockJsonSnapshot({ id: "mock-id", color: "blue" }),
+	];
+
+	const commonChanges: NewChange[] = [
+		{
+			id: "c1",
+			file_id: "mock",
+			entity_id: "value1",
+			plugin_key: "mock",
+			schema_key: "mock",
+			snapshot_id: commonSnapshots[0]!.id,
+		},
+		{
+			id: "c2",
+			file_id: "mock",
+			entity_id: "value1",
+			plugin_key: "mock",
+			schema_key: "mock",
+			snapshot_id: commonSnapshots[1]!.id,
+		},
+	];
+
+	const commonChangesEdges = [{ parent_id: "c1", child_id: "c2" }];
+
+	const snapshotsOnlyInSource = [
+		mockJsonSnapshot({ id: "mock-id", color: "pink" }),
+		mockJsonSnapshot({ id: "mock-id", color: "orange" }),
+		mockJsonSnapshot({ id: "mock-id", color: "yellow" }),
+	];
+
+	const changesOnlyInSource: NewChange[] = [
+		{
+			id: "s1",
+			file_id: "mock",
+			entity_id: "value1",
+			plugin_key: "mock",
+			schema_key: "mock",
+			snapshot_id: snapshotsOnlyInSource[0]!.id,
+		},
+		{
+			id: "s2",
+			entity_id: "value1",
+			file_id: "mock",
+			plugin_key: "mock",
+			schema_key: "mock",
+			snapshot_id: snapshotsOnlyInSource[1]!.id,
+		},
+		{
+			id: "s3",
+			entity_id: "value1",
+			file_id: "mock",
+			plugin_key: "mock",
+			schema_key: "mock",
+			snapshot_id: snapshotsOnlyInSource[2]!.id,
+		},
+	];
+
+	const changesOnlyInSourceEdges = [
+		{ parent_id: "s1", child_id: "s2" },
+		{ parent_id: "s2", child_id: "s3" },
+	];
+
+	const snapshotsOnlyInTarget = [
+		mockJsonSnapshot({ id: "mock-id", color: "black" }),
+	];
+
+	const changesOnlyInTarget: NewChange[] = [
+		{
+			id: "t1",
+			entity_id: "value1",
+			file_id: "mock",
+			plugin_key: "mock",
+			schema_key: "mock",
+			snapshot_id: snapshotsOnlyInTarget[0]!.id,
+		},
+	];
+
+	const changesOnlyInTargetEdges = [{ parent_id: "c2", child_id: "t1" }];
+
+	await targetLix.db
+		.insertInto("snapshot")
+		.values(
+			[...commonSnapshots, ...snapshotsOnlyInTarget].map((s) => {
+				return { content: s.content };
+			})
+		)
+		.execute();
+
+	await targetLix.db
+		.insertInto("change")
+		.values([...commonChanges, ...changesOnlyInTarget])
+		.execute();
+
+	await targetLix.db
+		.insertInto("change_edge")
+		.values([...commonChangesEdges, ...changesOnlyInTargetEdges])
+		.execute();
+
+	await sourceLix.db
+		.insertInto("snapshot")
+		.values(
+			[...commonSnapshots, ...snapshotsOnlyInSource].map((s) => {
+				return { content: s.content };
+			})
+		)
+		.execute();
+
+	await sourceLix.db
+		.insertInto("change")
+		.values([...commonChanges, ...changesOnlyInSource])
+		.execute();
+
+	await sourceLix.db
+		.insertInto("change_edge")
+		.values([...commonChangesEdges, ...changesOnlyInSourceEdges])
+		.execute();
+
+	const result = await getLeafChangesOnlyInSource({
+		sourceLix: sourceLix,
+		targetLix: targetLix,
+	});
+
+	// only the last change in the source is expected,
+	// not s1 and s2 which are parents of s3
+	expect(result.map((c) => c.id)).toEqual(["s3"]);
+});

package/node_modules/@lix-js/sdk/src/lix/merge.get-leaf-changes-only-in-source.ts

@@ -0,0 +1,46 @@
+import type { Change } from "../database/schema.js";
+import type { LixReadonly } from "../plugin/lix-plugin.js";
+
+/**
+ * Gets the leaf changes that only exist in the source lix.
+ *
+ * @example
+ *   source changes = [c1, s1 (child of c1), s2 (child of s1), s3 (child of s2)]
+ *   target changes = [c1, t1 (child of c1)]
+ *   leaf changes only in source = [s3]
+ */
+// TODO optimize later to use a single sql query (attach mode)
+export async function getLeafChangesOnlyInSource(args: {
+	sourceLix: LixReadonly;
+	targetLix: LixReadonly;
+}): Promise<Change[]> {
+	const result: Change[] = [];
+
+	const leafChangesInSource = await args.sourceLix.db
+		.selectFrom("change")
+		.selectAll("change")
+		.where(
+			"change.id",
+			"not in",
+			args.sourceLix.db
+				.selectFrom("change")
+				.innerJoin("change_edge", "change_edge.child_id", "change.id")
+				.select("parent_id")
+				.where("parent_id", "is not", null)
+				.distinct()
+		)
+		.execute();
+
+	for (const change of leafChangesInSource) {
+		const changeExistsInTarget = await args.targetLix.db
+			.selectFrom("change")
+			.select("id")
+			.where("id", "=", change.id)
+			.executeTakeFirst();
+
+		if (!changeExistsInTarget) {
+			result.push(change);
+		}
+	}
+	return result;
+}