@lix-js/sdk 0.4.7 → 0.5.0-preview.1

package/src/query-filter/change-is-leaf-in-version.test.ts

@@ -1,77 +0,0 @@
-import { test, expect } from "vitest";
-import { openLixInMemory } from "../lix/open-lix-in-memory.js";
-import { updateChangesInVersion } from "../version/update-changes-in-version.js";
-import { changeIsLeafInVersion } from "./change-is-leaf-in-version.js";
-import { createVersion } from "../version/create-version.js";
-
-test("it should return the leaf change for the given version", async () => {
-	const lix = await openLixInMemory({});
-
-	const version0 = await createVersion({ lix, name: "version0" });
-	const version1 = await createVersion({ lix, name: "version1" });
-
-	const insertedChanges = 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",
-			},
-			{
-				id: "change3",
-				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([
-			// including change1 for re-assurance
-			{ parent_id: "change1", child_id: "change2" },
-			{ parent_id: "change2", child_id: "change3" },
-		])
-		.execute();
-
-	await updateChangesInVersion({
-		lix,
-		version: version0,
-		// only point to the second change even though
-		// the third change is a child of the second change
-		changes: [insertedChanges[1]!],
-	});
-
-	// letting another version (version1) point to the third change
-	await updateChangesInVersion({
-		lix,
-		version: version1,
-		changes: [insertedChanges[2]!],
-	});
-
-	const changes = await lix.db
-		.selectFrom("change")
-		.where(changeIsLeafInVersion(version0))
-		.selectAll()
-		.execute();
-
-	// change 2 is the leaf change for the current version
-	expect(changes).toHaveLength(1);
-	expect(changes[0]?.id).toBe("change2");
-});

package/src/query-filter/change-is-leaf-in-version.ts

@@ -1,36 +0,0 @@
-import { sql, type ExpressionWrapper, type SqlBool } from "kysely";
-import type { Version, LixDatabaseSchema } from "../database/schema.js";
-
-/**
- * Selects changes that are not a parent of any other change within the specified version.
- *
- *
- * @example
- *   ```ts
- *   await lix.db.selectFrom("change")
- *     .where(changeIsLeafInVersion(currentVersion))
- *     .selectAll()
- *     .execute();
- *   ```
- */
-export function changeIsLeafInVersion(version: Pick<Version, "id">) {
-	return sql`
-    change.id IN (
-      WITH RECURSIVE version_changes(id) AS (
-        SELECT change_id AS id
-        FROM version_change
-        WHERE version_id = ${version.id}
-        UNION ALL
-        SELECT change_edge.parent_id AS id
-        FROM change_edge
-        INNER JOIN version_changes ON version_changes.id = change_edge.child_id
-      )
-      SELECT id FROM version_changes
-      WHERE id NOT IN (
-        SELECT parent_id
-        FROM change_edge
-        WHERE child_id IN (SELECT id FROM version_changes)
-      )
-    )
-  ` as unknown as ExpressionWrapper<LixDatabaseSchema, "change", SqlBool>;
-}

package/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/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/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/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/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")
-		);
-}