@inlang/sdk 0.36.3 → 2.0.0-beta.1

package/src/lix-plugin/inlangLixPluginV1.test.ts

@@ -0,0 +1,439 @@
+// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+// @ts-nocheck
+
+import { test, expect, describe } from "vitest";
+import { inlangLixPluginV1 } from "./inlangLixPluginV1.js";
+import { type DiffReport } from "@lix-js/sdk";
+import { newProject } from "../project/newProject.js";
+import { loadProjectInMemory } from "../project/loadProjectInMemory.js";
+import { contentFromDatabase } from "sqlite-wasm-kysely";
+import type { Variant } from "../database/schema.js";
+
+describe.skip("plugin.diff.file", () => {
+	test("insert of bundle", async () => {
+		const neuProject = await loadProjectInMemory({ blob: await newProject() });
+		await neuProject.db
+			.insertInto("bundle")
+			.values({
+				id: "1",
+			})
+			.execute();
+		const path = "/db.sqlite";
+		const diffReports = await inlangLixPluginV1.diff.file!({
+			old: undefined,
+			neu: {
+				id: "uuid",
+				path,
+				data: contentFromDatabase(neuProject._sqlite),
+				metadata: {},
+			},
+		});
+		expect(diffReports).toEqual([
+			{
+				type: "bundle",
+				operation: "create",
+				old: undefined,
+				neu: expect.objectContaining({ id: "1" }),
+			} satisfies DiffReport,
+		]);
+	});
+
+	// reanble with declarations
+	test.todo("update of bundle", async () => {
+		const oldProject = await loadProjectInMemory({ blob: await newProject() });
+		await oldProject.db
+			.insertInto("bundle")
+			.values([
+				{
+					id: "1",
+				},
+				{
+					id: "2",
+				},
+			])
+			.execute();
+		const neuProject = await loadProjectInMemory({ blob: await newProject() });
+		await neuProject.db
+			.insertInto("bundle")
+			.values([
+				{
+					id: "1",
+				},
+				{
+					id: "2",
+				},
+			])
+			.execute();
+
+		const diffReports = await inlangLixPluginV1.diff.file!({
+			old: {
+				id: "uuid",
+				path: "/db.sqlite",
+				data: contentFromDatabase(oldProject._sqlite),
+				metadata: {},
+			},
+			neu: {
+				id: "uuid",
+				path: "/db.sqlite",
+				data: contentFromDatabase(neuProject._sqlite),
+				metadata: {},
+			},
+		});
+
+		expect(diffReports).toEqual([
+			{
+				meta: {
+					id: "1",
+				},
+				type: "bundle",
+				operation: "update",
+				old: { id: "1" },
+				neu: { id: "1" },
+			} satisfies DiffReport,
+		]);
+	});
+
+	test("insert of message", async () => {
+		const neuProject = await loadProjectInMemory({ blob: await newProject() });
+		await neuProject.db
+			.insertInto("bundle")
+			.values({ id: "unknown" })
+			.execute();
+		await neuProject.db
+			.insertInto("message")
+			.values({
+				id: "1",
+				bundleId: "unknown",
+				locale: "en",
+			})
+			.execute();
+		const diffReports = await inlangLixPluginV1.diff.file!({
+			old: undefined,
+			neu: {
+				id: "uuid",
+				path: "/db.sqlite",
+				data: contentFromDatabase(neuProject._sqlite),
+				metadata: {},
+			},
+		});
+		expect(diffReports).toEqual(
+			expect.arrayContaining([
+				{
+					type: "message",
+					operation: "create",
+					old: undefined,
+					neu: {
+						id: "1",
+						bundleId: "unknown",
+						selectors: [],
+						locale: "en",
+					},
+				} satisfies DiffReport,
+			])
+		);
+	});
+
+	test("update of message", async () => {
+		const oldProject = await loadProjectInMemory({ blob: await newProject() });
+		await oldProject.db
+			.insertInto("bundle")
+			.values({ id: "unknown" })
+			.execute();
+		await oldProject.db
+			.insertInto("message")
+			.values([
+				{
+					id: "1",
+					bundleId: "unknown",
+					locale: "en",
+				},
+				{
+					id: "2",
+					bundleId: "unknown",
+					locale: "en",
+				},
+			])
+			.execute();
+		const neuProject = await loadProjectInMemory({ blob: await newProject() });
+		await neuProject.db
+			.insertInto("bundle")
+			.values({ id: "unknown" })
+			.execute();
+		await neuProject.db
+			.insertInto("message")
+			.values([
+				{
+					id: "1",
+					bundleId: "unknown",
+					locale: "de",
+				},
+				{
+					id: "2",
+					bundleId: "unknown",
+					locale: "en",
+				},
+			])
+			.execute();
+		const diffReports = await inlangLixPluginV1.diff.file!({
+			old: {
+				id: "uuid",
+				path: "/db.sqlite",
+				data: contentFromDatabase(oldProject._sqlite),
+				metadata: {},
+			},
+			neu: {
+				id: "uuid",
+				path: "/db.sqlite",
+				data: contentFromDatabase(neuProject._sqlite),
+				metadata: {},
+			},
+		});
+		expect(diffReports).toEqual(
+			expect.arrayContaining([
+				{
+					meta: {
+						id: "1",
+					},
+					type: "message",
+					operation: "update",
+					old: {
+						id: "1",
+						bundleId: "unknown",
+						selectors: [],
+						locale: "en",
+					},
+					neu: {
+						id: "1",
+						bundleId: "unknown",
+						selectors: [],
+						locale: "de",
+					},
+				} satisfies DiffReport,
+			])
+		);
+	});
+	test("insert of variant", async () => {
+		const neuProject = await loadProjectInMemory({ blob: await newProject() });
+		await neuProject.db
+			.insertInto("bundle")
+			.values({ id: "bundle1" })
+			.execute();
+		await neuProject.db
+			.insertInto("message")
+			.values({ id: "1", bundleId: "bundle1", locale: "en" })
+			.execute();
+
+		await neuProject.db
+			.insertInto("variant")
+			.values({
+				id: "1",
+				messageId: "1",
+				pattern: [{ type: "text", value: "hello world" }],
+				matches: [],
+			})
+			.execute();
+		const diffReports = await inlangLixPluginV1.diff.file!({
+			old: undefined,
+			neu: {
+				id: "uuid",
+				path: "/db.sqlite",
+				data: contentFromDatabase(neuProject._sqlite),
+				metadata: {},
+			},
+		});
+		expect(diffReports).toEqual(
+			expect.arrayContaining([
+				{
+					type: "variant",
+					operation: "create",
+					old: undefined,
+					neu: {
+						id: "1",
+						messageId: "1",
+						pattern: [{ type: "text", value: "hello world" }],
+						matches: [],
+					},
+				} satisfies DiffReport,
+			])
+		);
+	});
+	test("update of variant", async () => {
+		const oldProject = await loadProjectInMemory({ blob: await newProject() });
+		await oldProject.db
+			.insertInto("bundle")
+			.values({ id: "bundle1" })
+			.execute();
+		await oldProject.db
+			.insertInto("message")
+			.values({ id: "1", bundleId: "bundle1", locale: "en" })
+			.execute();
+		await oldProject.db
+			.insertInto("variant")
+			.values([
+				{
+					id: "1",
+					messageId: "1",
+					pattern: [{ type: "text", value: "hello world" }],
+					matches: [],
+				},
+				{
+					id: "2",
+					messageId: "1",
+					pattern: [{ type: "text", value: "hello world" }],
+					matches: [],
+				},
+			])
+			.execute();
+		const neuProject = await loadProjectInMemory({ blob: await newProject() });
+		await neuProject.db
+			.insertInto("bundle")
+			.values({ id: "bundle1" })
+			.execute();
+		await neuProject.db
+			.insertInto("message")
+			.values({ id: "1", bundleId: "bundle1", locale: "en" })
+			.execute();
+		await neuProject.db
+			.insertInto("variant")
+			.values([
+				{
+					id: "1",
+					messageId: "1",
+					pattern: [{ type: "text", value: "hello world from Berlin" }],
+					matches: [],
+				},
+				{
+					id: "2",
+					messageId: "1",
+					pattern: [{ type: "text", value: "hello world" }],
+					matches: [],
+				},
+			])
+			.execute();
+		const diffReports = await inlangLixPluginV1.diff.file!({
+			old: {
+				id: "uuid",
+				path: "/db.sqlite",
+				data: contentFromDatabase(oldProject._sqlite),
+				metadata: {},
+			},
+			neu: {
+				id: "uuid",
+				path: "/db.sqlite",
+				data: contentFromDatabase(neuProject._sqlite),
+				metadata: {},
+			},
+		});
+		expect(diffReports).toEqual([
+			{
+				meta: {
+					id: "1",
+				},
+				operation: "update",
+				type: "variant",
+				old: {
+					id: "1",
+					messageId: "1",
+					pattern: [{ type: "text", value: "hello world" }],
+					matches: [],
+				},
+				neu: {
+					id: "1",
+					messageId: "1",
+					pattern: [{ type: "text", value: "hello world from Berlin" }],
+					matches: [],
+				},
+			} satisfies DiffReport,
+		]);
+	});
+
+	// https://github.com/opral/lix-sdk/issues/33
+	test("it should generate changes after the first change", async () => {
+		const project = await loadProjectInMemory({ blob: await newProject() });
+
+		const initialChanges = await project.lix.db
+			.selectFrom("change")
+			.selectAll()
+			.execute();
+		expect(initialChanges.length).toEqual(0);
+
+		await project.db
+			.insertInto("bundle")
+			.values({
+				id: "1",
+			})
+			.execute();
+
+		// FIXME: how to await inlang sdk persisting the inlang db to lix?
+		await new Promise((resolve) => setTimeout(resolve, 500));
+
+		await project.lix.settled();
+
+		const changes = await project.lix.db
+			.selectFrom("change")
+			.selectAll()
+			.execute();
+
+		expect(changes.length).toBe(1);
+		expect(changes[0]?.value?.id).toBe("1");
+		expect(changes[0]?.operation).toBe("create");
+	});
+});
+
+describe.skip("plugin.diff.variant", () => {
+	test("old and neu are the same should not report a diff", async () => {
+		const old: Variant = {
+			id: "1",
+			matches: [],
+			messageId: "5",
+			pattern: [{ type: "text", value: "hello world" }],
+		};
+		const neu: Variant = {
+			id: "1",
+			matches: [],
+			messageId: "5",
+			pattern: [{ type: "text", value: "hello world" }],
+		};
+		const diff = await inlangLixPluginV1.diff.variant({ old, neu });
+		expect(diff).toEqual([]);
+	});
+
+	test("old and neu are different should yield a diff report", async () => {
+		const old: Variant = {
+			id: "1",
+			matches: [],
+			messageId: "5",
+			pattern: [{ type: "text", value: "hello world" }],
+		};
+		const neu: Variant = {
+			id: "1",
+			matches: [],
+			messageId: "5",
+			pattern: [{ type: "text", value: "hello world from Berlin" }],
+		};
+		const diff = await inlangLixPluginV1.diff.variant({ old, neu });
+		expect(diff).toEqual([
+			{
+				meta: { id: "1" },
+				operation: "update",
+				type: "variant",
+				neu,
+				old,
+			} satisfies DiffReport,
+		]);
+	});
+
+	test("old is undefined and neu is defined should return a diff report for the new value", async () => {
+		const old = undefined;
+		const neu: Variant = {
+			id: "1",
+			matches: [],
+			messageId: "5",
+			pattern: [{ type: "text", value: "hello world" }],
+		};
+		const diff = await inlangLixPluginV1.diff.variant({ old, neu });
+		expect(diff).toEqual([
+			{ operation: "create", type: "variant", neu, old } satisfies DiffReport,
+		]);
+	});
+});

package/src/lix-plugin/inlangLixPluginV1.ts

@@ -0,0 +1,132 @@
+// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+// @ts-nocheck
+
+import type { DiffReport, LixPlugin } from "@lix-js/sdk";
+import { loadDatabaseInMemory } from "sqlite-wasm-kysely";
+import { initDb } from "../database/initDb.js";
+import { applyChanges } from "./applyChanges.js";
+import { detectConflicts } from "./detectConflicts.js";
+import type { Bundle, Message, Variant } from "../database/schema.js";
+
+export const inlangLixPluginV1: LixPlugin<{
+	bundle: Bundle;
+	message: Message;
+	variant: Variant;
+}> = {
+	key: "inlang-lix-plugin-v1",
+	glob: "*",
+	applyChanges,
+	detectConflicts,
+	diff: {
+		// TODO does not account for deletions
+		file: async ({ old, neu }) => {
+			// can only handle the database for now
+			if (neu === undefined || neu.path?.endsWith("db.sqlite") === false) {
+				return [];
+			}
+			const result: DiffReport[] = [];
+			const oldDb = old
+				? initDb({ sqlite: await loadDatabaseInMemory(old.data) })
+				: undefined;
+
+			const newDb = neu
+				? initDb({
+						sqlite: await loadDatabaseInMemory(neu.data),
+					})
+				: undefined;
+
+			const newProjectBundles = await newDb
+				?.selectFrom("bundle")
+				.selectAll()
+				.execute();
+
+			const newProjectMessages = await newDb
+				?.selectFrom("message")
+				.selectAll()
+				.execute();
+			const newProjectVariants = await newDb
+				?.selectFrom("variant")
+				.selectAll()
+				.execute();
+
+			for (const bundle of newProjectBundles ?? []) {
+				const oldBundle = await oldDb
+					?.selectFrom("bundle")
+					.selectAll()
+					.where("id", "=", bundle.id)
+					.executeTakeFirst();
+				result.push(
+					...(await inlangLixPluginV1.diff.bundle({
+						old: oldBundle,
+						neu: bundle,
+					}))
+				);
+			}
+			for (const message of newProjectMessages ?? []) {
+				const oldMessage = await oldDb
+					?.selectFrom("message")
+					.selectAll()
+					.where("id", "=", message.id)
+					.executeTakeFirst();
+
+				result.push(
+					...(await inlangLixPluginV1.diff.message({
+						old: oldMessage,
+						neu: message,
+					}))
+				);
+			}
+			for (const variant of newProjectVariants ?? []) {
+				const oldVariant = await oldDb
+					?.selectFrom("variant")
+					.selectAll()
+					.where("id", "=", variant.id)
+					.executeTakeFirst();
+				result.push(
+					...(await inlangLixPluginV1.diff.variant({
+						old: oldVariant,
+						neu: variant,
+					}))
+				);
+			}
+
+			return result;
+		},
+		bundle: ({ old, neu }) => diffSnapshot({ old, neu, type: "bundle" }),
+		message: ({ old, neu }) => diffSnapshot({ old, neu, type: "message" }),
+		variant: ({ old, neu }) => diffSnapshot({ old, neu, type: "variant" }),
+	},
+};
+
+function diffSnapshot({
+	old,
+	neu,
+	type,
+}: {
+	old?: Bundle | Message | Variant;
+	neu?: Bundle | Message | Variant;
+	type: "bundle" | "message" | "variant";
+}): DiffReport[] {
+	if (old === undefined && neu) {
+		return [{ type, old, neu, operation: "create" } satisfies DiffReport];
+	} else if (old !== undefined && neu === undefined) {
+		return [{ type, old, neu, operation: "delete" } satisfies DiffReport];
+	} else if (old && neu) {
+		const hasDiff = JSON.stringify(old) !== JSON.stringify(neu);
+		if (hasDiff) {
+			return [
+				{
+					type,
+					meta: {
+						// id is required for deletions
+						id: old.id ?? neu.id,
+					},
+					operation: "update",
+					old,
+					neu,
+				} satisfies DiffReport,
+			];
+		}
+	}
+	return [];
+}

package/src/lix-plugin/merge.test.ts

@@ -0,0 +1,133 @@
+// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+// @ts-nocheck
+
+import { merge, type NewChange } from "@lix-js/sdk";
+import { test, expect } from "vitest";
+import { loadProjectInMemory } from "../project/loadProjectInMemory.js";
+import { newProject } from "../project/newProject.js";
+import { inlangLixPluginV1 } from "./inlangLixPluginV1.js";
+import type { NewBundle, NewMessage, NewVariant } from "../database/schema.js";
+
+test.skip("it should update the variant to the source's value", async () => {
+	const target = await loadProjectInMemory({ blob: await newProject() });
+	const source = await loadProjectInMemory({ blob: await target.toBlob() });
+
+	const dbFile = await target.lix.db
+		.selectFrom("file")
+		.select("id")
+		.where("path", "=", "/db.sqlite")
+		.executeTakeFirstOrThrow();
+
+	const commonChanges: NewChange[] = [
+		{
+			id: "d92cdc2e-74cc-494c-8d51-958216272a17",
+			parent_id: undefined,
+			type: "bundle",
+			file_id: dbFile.id,
+			plugin_key: inlangLixPluginV1["key"],
+			operation: "create",
+			value: {
+				id: "even_hour_mule_drum",
+			} satisfies NewBundle,
+			commit_id: "c8ad005b-a834-4ca3-84fb-9627546f2eba",
+		},
+		{
+			id: "24f74fec-fc8a-4c68-b31c-d126417ce3af",
+			parent_id: undefined,
+			type: "message",
+			file_id: dbFile.id,
+			plugin_key: inlangLixPluginV1["key"],
+			operation: "create",
+			value: {
+				id: "c2684c3d-3e14-47e4-96b7-8d33579bb7e9",
+				bundleId: "even_hour_mule_drum",
+				locale: "en",
+				selectors: [],
+			} satisfies NewMessage,
+			commit_id: "c8ad005b-a834-4ca3-84fb-9627546f2eba",
+		},
+		{
+			id: "aaf0ec32-0c7f-4d07-af8c-922ce382aef1",
+			parent_id: undefined,
+			type: "variant",
+			file_id: dbFile.id,
+			plugin_key: inlangLixPluginV1["key"],
+			operation: "create",
+			value: {
+				id: "6a860f96-0cf3-477c-80ad-7893d8fde852",
+				messageId: "c2684c3d-3e14-47e4-96b7-8d33579bb7e9",
+				matches: [],
+				pattern: [
+					{
+						type: "text",
+						value: "My Awesome Todo App",
+					},
+				],
+			} satisfies NewVariant,
+			commit_id: "c8ad005b-a834-4ca3-84fb-9627546f2eba",
+		},
+	];
+
+	const changesOnlyInTarget: NewChange[] = [];
+	const changesOnlyInSource: NewChange[] = [
+		{
+			id: "01c059f9-8476-4aaa-aa6d-53ea3158b374",
+			parent_id: "aaf0ec32-0c7f-4d07-af8c-922ce382aef1",
+			type: "variant",
+			file_id: dbFile.id,
+			plugin_key: inlangLixPluginV1["key"],
+			operation: "update",
+			value: {
+				id: "6a860f96-0cf3-477c-80ad-7893d8fde852",
+				messageId: "c2684c3d-3e14-47e4-96b7-8d33579bb7e9",
+				matches: [],
+				pattern: [
+					{
+						type: "text",
+						value: "My app is buggy",
+					},
+				],
+			} satisfies NewVariant,
+			meta: {
+				id: "6a860f96-0cf3-477c-80ad-7893d8fde852",
+			},
+			commit_id: "df455c78-b5ed-4df0-9259-7bb694c9d755",
+		},
+	];
+
+	await source.lix.db
+		.insertInto("change")
+		.values([...commonChanges, ...changesOnlyInSource])
+		.execute();
+
+	await target.lix.db
+		.insertInto("change")
+		.values([...commonChanges, ...changesOnlyInTarget])
+		.execute();
+
+	await merge({ sourceLix: source.lix, targetLix: target.lix });
+
+	await target.lix.settled();
+
+	// need to reload project to re-initialize the state
+	const mergedProject = await loadProjectInMemory({
+		blob: await target.toBlob(),
+	});
+
+	const changes = await mergedProject.lix.db
+		.selectFrom("change")
+		.selectAll()
+		.execute();
+
+	expect(changes).lengthOf(4);
+
+	const variant = await mergedProject.db
+		.selectFrom("variant")
+		.selectAll()
+		.where("id", "=", "6a860f96-0cf3-477c-80ad-7893d8fde852")
+		.executeTakeFirstOrThrow();
+
+	expect(variant).toEqual(
+		expect.objectContaining(changesOnlyInSource[0]?.value)
+	);
+});