@inlang/sdk 0.36.3 → 2.0.0-prerelease.0

package/node_modules/@lix-js/sdk/src/query-filter/change-is-leaf-of.bench.ts

@@ -0,0 +1,175 @@
+import { v7 } from "uuid";
+import { bench, describe } from "vitest";
+import {
+	newLixFile,
+	openLixInMemory,
+	type Change,
+	type ChangeEdge,
+	type NewChange,
+	type NewSnapshot,
+} from "../index.js";
+import { changeIsLeafOf } from "./change-is-leaf-of.js";
+
+const createChange = (
+	schema_key: "bundle" | "message" | "variant",
+	payload: any,
+	parentChangeId: string | null
+): { change: NewChange; snapshot: NewSnapshot; edges: ChangeEdge[] } => {
+	const entityId = payload[schema_key].id;
+	const snapshotId = v7();
+	const snapshot: NewSnapshot = {
+		id: snapshotId,
+		content: payload[schema_key],
+	};
+	const change: Change = {
+		id: v7(),
+		file_id: "mock",
+		plugin_key: "inlang",
+		schema_key: schema_key,
+		snapshot_id: snapshotId,
+		entity_id: entityId,
+		created_at: "",
+	};
+
+	const edges: ChangeEdge[] = [];
+
+	if (parentChangeId) {
+		edges.push({
+			parent_id: parentChangeId,
+			child_id: change.id,
+		});
+	}
+
+	return {
+		change,
+		snapshot,
+		edges,
+	};
+};
+
+const setupLix = async (nMessages: number) => {
+	const lix = await openLixInMemory({
+		blob: await newLixFile(),
+	});
+
+	const mockChanges: {
+		change: NewChange;
+		snapshot: NewSnapshot;
+		edges: ChangeEdge[];
+	}[] = [];
+
+	for (let i = 0; i < nMessages; i++) {
+		const payloads = getPayloadsForId(v7());
+
+		// lets asume we create a bundle once and don't change it to much over its lifetime
+		mockChanges.push(createChange("bundle", payloads, null));
+
+		// lets asume we add 4 languages to the message and don't change it to much
+		// -> 6 changes
+		let lastMessageChangeId: null | string = null;
+		for (let i = 0; i < 6; i++) {
+			const changeAndSnapshot = createChange(
+				"message",
+				payloads,
+				lastMessageChangeId
+			);
+			mockChanges.push(changeAndSnapshot);
+			lastMessageChangeId = changeAndSnapshot.change.id!;
+		}
+
+		// lets assume imports some variants once (1) change and others get edited quit heavly 120 characters 10 times rewriten (1200 changes)
+		// -> 100 changes per variant
+		createChange("variant", payloads, null);
+		let lastVariantChangeId: null | string = null;
+		for (let i = 0; i < 100; i++) {
+			const changeAndSnapshot = createChange(
+				"variant",
+				payloads,
+				lastVariantChangeId
+			);
+			mockChanges.push(changeAndSnapshot);
+			lastVariantChangeId = changeAndSnapshot.change.id!;
+		}
+	}
+
+	const firstChangeId = mockChanges[0]!.change.id;
+
+	const batchSize = 256;
+	// Insert changes in batches
+	for (let i = 0; i < mockChanges.length; i += batchSize) {
+		// Extract the changes
+		const changesArray = mockChanges
+			.slice(i, i + batchSize)
+			.map((item) => item.change);
+
+		// Extract the snapshots
+		const snapshotsArray = mockChanges
+			.slice(i, i + batchSize)
+			.map((item) => item.snapshot);
+
+		const edgesArray = mockChanges
+			.slice(i, i + batchSize)
+			.flatMap((item) => item.edges);
+
+		await lix.db.insertInto("snapshot").values(snapshotsArray).execute();
+		await lix.db.insertInto("change").values(changesArray).execute();
+		await lix.db.insertInto("change_edge").values(edgesArray).execute();
+	}
+	// console.log("setting up lix with " + nMessages + ".... done");
+
+	return { lix, firstChangeId };
+};
+
+for (let i = 0; i < 5; i++) {
+	const nMessages = Math.pow(10, i);
+	describe(
+		"get Leaf Change " +
+			nMessages +
+			" messages -> " +
+			nMessages * (1 + 6 + 100) +
+			" changes",
+		async () => {
+			const project = await setupLix(nMessages);
+			bench("getLeafChange", async () => {
+				await project.lix.db
+					.selectFrom("change")
+					.where(changeIsLeafOf({ id: project.firstChangeId! }))
+					.selectAll()
+					.execute();
+			});
+		}
+	);
+}
+
+const getPayloadsForId = (id: string) => {
+	return {
+		bundle: {
+			id: id,
+			declarations: [
+				{
+					type: "input-variable",
+					name: "name",
+				},
+			],
+		},
+		message: {
+			id: id + "_en",
+			bundleId: id,
+			locale: "en",
+			selectors: [],
+		},
+		variant: {
+			id: id + "_en_variant_one",
+			messageId: "depressed_dog_en",
+			matches: [],
+			pattern: [
+				{ type: "text", value: "Good morning " },
+				{
+					type: "expression",
+					arg: { type: "variable-reference", name: "name" },
+				},
+				{ type: "text", value: "!" },
+			],
+		},
+	};
+};

package/node_modules/@lix-js/sdk/src/query-filter/change-is-leaf-of.test.ts

@@ -0,0 +1,84 @@
+import { test, expect } from "vitest";
+import { changeIsLeafOf } from "./change-is-leaf-of.js";
+import { openLixInMemory } from "../lix/open-lix-in-memory.js";
+import type { Change, ChangeEdge } from "../database/schema.js";
+import { updateChangesInVersion } from "../version/update-changes-in-version.js";
+
+test("it should find the latest child of a given change", async () => {
+	const lix = await openLixInMemory({});
+
+	const currentVersion = await lix.db
+		.selectFrom("current_version")
+		.innerJoin("version", "current_version.id", "version.id")
+		.selectAll("version")
+		.executeTakeFirstOrThrow();
+
+	const mockChanges = [
+		{
+			id: "1",
+			entity_id: "value1",
+			file_id: "mock",
+			plugin_key: "mock",
+			schema_key: "mock",
+			snapshot_id: "no-content",
+			created_at: "mock",
+		},
+		{
+			id: "2",
+			entity_id: "value1",
+			file_id: "mock",
+			plugin_key: "mock",
+			schema_key: "mock",
+			snapshot_id: "no-content",
+			created_at: "mock",
+		},
+		{
+			id: "3",
+			entity_id: "value1",
+			file_id: "mock",
+			plugin_key: "mock",
+			schema_key: "mock",
+			snapshot_id: "no-content",
+			created_at: "mock",
+		},
+	] as const satisfies Change[];
+
+	const edges: ChangeEdge[] = [
+		{ parent_id: "1", child_id: "2" },
+		{ parent_id: "2", child_id: "3" },
+	];
+
+	await lix.db.insertInto("change").values(mockChanges).execute();
+
+	await lix.db.insertInto("change_edge").values(edges).execute();
+
+	await updateChangesInVersion({
+		lix,
+		version: currentVersion,
+		changes: mockChanges,
+	});
+
+	const leafOfChange1 = await lix.db
+		.selectFrom("change")
+		.where(changeIsLeafOf(mockChanges[0]))
+		.selectAll()
+		.executeTakeFirstOrThrow();
+
+	expect(leafOfChange1.id).toBe("3");
+
+	const leafOfChange2 = await lix.db
+		.selectFrom("change")
+		.where(changeIsLeafOf(mockChanges[1]))
+		.selectAll()
+		.executeTakeFirstOrThrow();
+
+	expect(leafOfChange2.id).toBe("3");
+
+	const leafOfChange3 = await lix.db
+		.selectFrom("change")
+		.where(changeIsLeafOf(mockChanges[2]))
+		.selectAll()
+		.executeTakeFirstOrThrow();
+
+	expect(leafOfChange3.id).toBe("3");
+});

package/node_modules/@lix-js/sdk/src/query-filter/change-is-leaf-of.ts

@@ -0,0 +1,46 @@
+import { sql, ExpressionWrapper, type SqlBool } from "kysely";
+import type { LixDatabaseSchema } from "../database/schema.js";
+import type { Change } from "../database/schema.js";
+
+/**
+ * Filter to select the last descendant of the specified change.
+ *
+ * @example
+ *   Checking for the leaf of a change in all versiones.
+ *
+ *   ```ts
+ *   await lix.db.selectFrom("change")
+ *      .where(changeIsLeafOf(someChange))
+ *      .selectAll()
+ *      .execute();
+ *   ```
+ *
+ * @example
+ *   Checking for the leaf of a change in a specific version.
+ *
+ *   ```ts
+ *   await lix.db.selectFrom("change")
+ *     .where(changeIsLeafOf(someChange))
+ *     .where(changeInVersion(someVersion))
+ *     .selectAll()
+ *     .execute();
+ *   ```
+ */
+export function changeIsLeafOf(change: Pick<Change, "id">) {
+	return sql`
+    change.id IN (
+      WITH RECURSIVE descendants(id) AS (
+        SELECT id
+        FROM change
+        WHERE id = ${change.id}
+        UNION ALL
+        SELECT change.id
+        FROM change
+        INNER JOIN change_edge ON change_edge.child_id = change.id
+        INNER JOIN descendants ON change_edge.parent_id = descendants.id
+      )
+      SELECT id FROM descendants
+      WHERE id NOT IN (SELECT parent_id FROM change_edge)
+    )
+  ` as unknown as ExpressionWrapper<LixDatabaseSchema, "change", SqlBool>;
+}

package/node_modules/@lix-js/sdk/src/query-filter/change-is-leaf.test.ts

@@ -0,0 +1,140 @@
+import { test, expect } from "vitest";
+import { changeIsLeaf } from "./change-is-leaf.js";
+import { openLixInMemory } from "../lix/open-lix-in-memory.js";
+import { updateChangesInVersion } from "../version/update-changes-in-version.js";
+import { changeInVersion } from "./change-in-version.js";
+
+test("should only return the leaf change", async () => {
+	const lix = await openLixInMemory({});
+
+	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: "mock2",
+				file_id: "mock",
+				plugin_key: "mock",
+				schema_key: "mock",
+			},
+			{
+				id: "change3",
+				snapshot_id: "no-content",
+				entity_id: "mock2",
+				file_id: "mock",
+				plugin_key: "mock",
+				schema_key: "mock",
+			},
+		])
+		.execute();
+
+	await lix.db
+		.insertInto("change_edge")
+		.values([{ parent_id: "change2", child_id: "change3" }])
+		.execute();
+
+	const changes = await lix.db
+		.selectFrom("change")
+		.where(changeIsLeaf())
+		.selectAll()
+		.execute();
+
+	expect(changes).toHaveLength(2);
+	expect(changes.map((c) => c.id)).toEqual(["change1", "change3"]);
+});
+
+test("should return the change even if it's the only one", async () => {
+	const lix = await openLixInMemory({});
+
+	await lix.db
+		.insertInto("change")
+		.values([
+			{
+				id: "change1",
+				snapshot_id: "no-content",
+				entity_id: "mock1",
+				file_id: "mock",
+				plugin_key: "mock",
+				schema_key: "mock",
+			},
+		])
+		.execute();
+
+	const changes = await lix.db
+		.selectFrom("change")
+		.where(changeIsLeaf())
+		.selectAll()
+		.execute();
+
+	expect(changes).toHaveLength(1);
+	expect(changes.map((c) => c.id)).toEqual(["change1"]);
+});
+
+// needs sql debugging why the query is not working as expected
+test.todo(
+	"it should work in combination with the `changeInVersion()` filter",
+	async () => {
+		const lix = await openLixInMemory({});
+
+		const changes = 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",
+				},
+			])
+			.returningAll()
+			.execute();
+
+		await lix.db
+			.insertInto("change_edge")
+			.values([{ parent_id: "change1", child_id: "change2" }])
+			.execute();
+
+		const currentVersion = await lix.db
+			.selectFrom("current_version")
+			.innerJoin("version", "version.id", "current_version.id")
+			.selectAll("version")
+			.executeTakeFirstOrThrow();
+
+		// let the version point only to the first change
+		await updateChangesInVersion({
+			lix,
+			changes: [changes[0]!],
+			version: currentVersion,
+		});
+
+		const result = await lix.db
+			.selectFrom("change")
+			.where(changeIsLeaf())
+			.where(changeInVersion(currentVersion))
+			.selectAll()
+			.execute();
+
+		// expecting the leaf change in the current version to be change 1
+		expect(result).toHaveLength(1);
+		expect(result.map((c) => c.id)).toEqual(["change1"]);
+	}
+);

package/node_modules/@lix-js/sdk/src/query-filter/change-is-leaf.ts

@@ -0,0 +1,25 @@
+import type { ExpressionBuilder, ExpressionWrapper, SqlBool } from "kysely";
+import type { LixDatabaseSchema } from "../database/schema.js";
+
+/**
+ * Selects changes that are not a parent of any other change.
+ *
+ * **Careful**: This filter is not specific to any version.
+ * If you want to filter changes in a specific version, use `changeIsLeafInversion`.
+ *
+ * @example
+ *   ```ts
+ *   await lix.db.selectFrom("change")
+ *     .where(changeIsLeaf())
+ *     .selectAll()
+ *     .execute();
+ *   ```
+ */
+export function changeIsLeaf() {
+	return (
+		eb: ExpressionBuilder<LixDatabaseSchema, "change">
+	): ExpressionWrapper<LixDatabaseSchema, "change", SqlBool> =>
+		eb("change.id", "not in", (subquery) =>
+			subquery.selectFrom("change_edge").select("change_edge.parent_id")
+		);
+}

package/node_modules/@lix-js/sdk/src/query-filter/change-is-lowest-common-ancestor-of.test.ts

@@ -0,0 +1,173 @@
+import { test, expect } from "vitest";
+import { openLixInMemory } from "../lix/open-lix-in-memory.js";
+import { changeIsLowestCommonAncestorOf } from "./change-is-lowest-common-ancestor-of.js";
+import type { NewChange, NewChangeEdge } from "../database/schema.js";
+
+test("it find the lowest common ancestor", async () => {
+	const lix = await openLixInMemory({});
+
+	const mockChanges = [
+		{
+			id: "0",
+			entity_id: "value1",
+			file_id: "mock",
+			plugin_key: "mock",
+			schema_key: "mock",
+			created_at: "mock",
+			snapshot_id: "no-content",
+		},
+		{
+			id: "1",
+			file_id: "mock",
+			entity_id: "value1",
+			plugin_key: "mock",
+			schema_key: "mock",
+			created_at: "mock",
+			snapshot_id: "no-content",
+		},
+		{
+			id: "2",
+			file_id: "mock",
+			entity_id: "value1",
+			plugin_key: "mock",
+			schema_key: "mock",
+			created_at: "mock",
+			snapshot_id: "no-content",
+		},
+		{
+			id: "3",
+			file_id: "mock",
+			entity_id: "value1",
+			plugin_key: "mock",
+			schema_key: "mock",
+			created_at: "mock",
+			snapshot_id: "no-content",
+		},
+		{
+			id: "common",
+			entity_id: "value1",
+			file_id: "mock",
+			plugin_key: "mock",
+			schema_key: "mock",
+			created_at: "mock",
+			snapshot_id: "no-content",
+		},
+		{
+			id: "lowest-common",
+			entity_id: "value1",
+			file_id: "mock",
+			plugin_key: "mock",
+			schema_key: "mock",
+			created_at: "mock",
+			snapshot_id: "no-content",
+		},
+	] as const satisfies NewChange[];
+
+	const edges = [
+		{ parent_id: "common", child_id: "lowest-common" },
+		{ parent_id: "lowest-common", child_id: "0" },
+		{ parent_id: "lowest-common", child_id: "1" },
+		{ parent_id: "0", child_id: "2" },
+		{ parent_id: "1", child_id: "3" },
+	] satisfies NewChangeEdge[];
+
+	await lix.db.insertInto("change").values(mockChanges).execute();
+	await lix.db.insertInto("change_edge").values(edges).execute();
+
+	// expect(commonAncestors).toHaveLength(2);
+	// expect(commonAncestors.map((a) => a.id)).toEqual(
+	// 	expect.arrayContaining(["lowest-common", "common"]),
+	// );
+
+	const lowestCommonAncestor = await lix.db
+		.selectFrom("change")
+		.where(changeIsLowestCommonAncestorOf([mockChanges[2], mockChanges[3]]))
+		.selectAll()
+		.executeTakeFirst();
+
+	expect(lowestCommonAncestor?.id).toBe("lowest-common");
+});
+
+test("it should return no results if no common parent exists", async () => {
+	const lix = await openLixInMemory({});
+
+	const mockChanges = [
+		{
+			id: "0",
+			entity_id: "value1",
+			file_id: "mock",
+			plugin_key: "mock",
+			schema_key: "mock",
+			snapshot_id: "no-content",
+		},
+		{
+			id: "1",
+			entity_id: "value1",
+			file_id: "mock",
+			plugin_key: "mock",
+			schema_key: "mock",
+			snapshot_id: "no-content",
+		},
+		{
+			id: "2",
+			entity_id: "value2",
+			file_id: "mock",
+			plugin_key: "mock",
+			schema_key: "mock",
+			snapshot_id: "no-content",
+		},
+	] as const satisfies NewChange[];
+
+	await lix.db.insertInto("change").values(mockChanges).execute();
+	await lix.db
+		.insertInto("change_edge")
+		.values([{ parent_id: "0", child_id: "1" }])
+		.execute();
+
+	const commonAncestors = await lix.db
+		.selectFrom("change")
+		.where(changeIsLowestCommonAncestorOf([mockChanges[1], mockChanges[2]]))
+		.selectAll()
+		.execute();
+
+	expect(commonAncestors).toHaveLength(0);
+});
+
+test("it should succeed if one of the given changes is the common ancestor", async () => {
+	const lix = await openLixInMemory({});
+
+	const mockChanges = [
+		{
+			id: "0",
+			entity_id: "value1",
+			file_id: "mock",
+			plugin_key: "mock",
+			schema_key: "mock",
+			snapshot_id: "no-content",
+			created_at: "mock",
+		},
+		{
+			id: "1",
+			entity_id: "value1",
+			file_id: "mock",
+			plugin_key: "mock",
+			schema_key: "mock",
+			snapshot_id: "no-content",
+			created_at: "mock",
+		},
+	] as const satisfies NewChange[];
+
+	const edges = [{ parent_id: "0", child_id: "1" }];
+
+	await lix.db.insertInto("change").values(mockChanges).execute();
+	await lix.db.insertInto("change_edge").values(edges).execute();
+
+	const commonAncestors = await lix.db
+		.selectFrom("change")
+		.where(changeIsLowestCommonAncestorOf([mockChanges[0], mockChanges[1]]))
+		.selectAll()
+		.execute();
+
+	expect(commonAncestors).toHaveLength(1);
+	expect(commonAncestors[0]?.id).toBe("0");
+});

package/node_modules/@lix-js/sdk/src/query-filter/change-is-lowest-common-ancestor-of.ts

@@ -0,0 +1,57 @@
+import { ExpressionWrapper, sql } from "kysely";
+import type { Change, LixDatabaseSchema } from "../database/schema.js";
+import type { SqlBool } from "kysely";
+
+/**
+ * Filters changes that are the lowest common ancestor of the given changes.
+ *
+ * @example
+ *   ```ts
+ *   const lowestCommonAncestor = await lix.db.selectFrom("change")
+ *      .where(changeIsLowestCommonAncestorOf([change1, change2, change3]))
+ *      .selectAll()
+ *      .executeTakeFirst();
+ *   ```
+ */
+export function changeIsLowestCommonAncestorOf(changes: Pick<Change, "id">[]) {
+	return sql`
+    change.id IN (
+      -- Recursive CTE to find ancestors level by level
+      WITH RECURSIVE step_ancestors(ancestor_id, originating_change, depth) AS (
+        -- Base case: Start with the input changes themselves
+        SELECT 
+          id AS ancestor_id, 
+          id AS originating_change, 
+          0 AS depth
+        FROM change
+        WHERE id IN (${sql.join(changes.map((c) => c.id))})
+
+        UNION ALL
+
+        -- Recursive step: Find the parents of the current ancestors
+        SELECT 
+          change_edge.parent_id AS ancestor_id, 
+          step_ancestors.originating_change, 
+          step_ancestors.depth + 1 AS depth
+        FROM change_edge
+        INNER JOIN step_ancestors 
+          ON change_edge.child_id = step_ancestors.ancestor_id
+      ),
+      -- Aggregate ancestors to find the first common one
+      common_ancestors AS (
+        SELECT 
+          ancestor_id, 
+          COUNT(DISTINCT originating_change) AS change_count, -- Count distinct input changes contributing to each ancestor
+          MIN(depth) AS min_depth -- The closest (lowest) ancestor has the smallest depth
+        FROM step_ancestors
+        GROUP BY ancestor_id
+        HAVING COUNT(DISTINCT originating_change) = ${changes.length} -- Only include ancestors shared by all input changes
+      )
+      -- Select the lowest common ancestor
+      SELECT ancestor_id
+      FROM common_ancestors
+      ORDER BY min_depth ASC, ancestor_id ASC -- Prioritize closest ancestor, tie-break by ID
+      LIMIT 1 -- Return only the lowest common ancestor
+    )
+  ` as unknown as ExpressionWrapper<LixDatabaseSchema, "change", SqlBool>;
+}