@inlang/sdk 2.0.0-prerelease.0 → 2.0.1

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

@@ -1,175 +0,0 @@
-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

@@ -1,84 +0,0 @@
-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

@@ -1,46 +0,0 @@
-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

@@ -1,140 +0,0 @@
-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

@@ -1,25 +0,0 @@
-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

@@ -1,173 +0,0 @@
-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

@@ -1,57 +0,0 @@
-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>;
-}