@inlang/sdk 2.0.0-prerelease.0 → 2.0.1

package/node_modules/@lix-js/sdk/src/sync/sync-process.test.ts

@@ -1,321 +0,0 @@
-import { test, expect, vi } from "vitest";
-import { openLixInMemory } from "../lix/open-lix-in-memory.js";
-import {
-	createLsaInMemoryEnvironment,
-	createServerApiHandler,
-} from "../server-api-handler/index.js";
-import { createVersion } from "../version/create-version.js";
-import { switchVersion } from "../version/switch-version.js";
-import type { Version } from "../database/schema.js";
-import { executeSync } from "../database/execute-sync.js";
-import { toBlob } from "../lix/to-blob.js";
-
-test("versions should be synced", async () => {
-	const environment = createLsaInMemoryEnvironment();
-	const lsaHandler = await createServerApiHandler({ environment });
-
-	global.fetch = vi.fn((request) => lsaHandler(request));
-
-	const lix0 = await openLixInMemory({
-		keyValues: [{ key: "lix_server_url", value: "http://mock.com" }],
-	});
-
-	// @ts-expect-error - eases debugging
-	lix0.db.__name = "lix0";
-
-	const lixId = await lix0.db
-		.selectFrom("key_value")
-		.where("key", "=", "lix_id")
-		.selectAll()
-		.executeTakeFirstOrThrow();
-
-	// initialize lix on the server
-	await lsaHandler(
-		new Request("http://mock.com/lsa/new-v1", {
-			method: "POST",
-			body: await toBlob({ lix: lix0 }),
-		})
-	);
-
-	// create a second client
-	const lix1 = await openLixInMemory({
-		blob: await toBlob({ lix: lix0 }),
-		keyValues: [{ key: "lix_sync", value: "true" }],
-	});
-
-	// start syncing
-	await Promise.all(
-		[lix0, lix1].map((lix) =>
-			lix.db
-				.updateTable("key_value")
-				.where("key", "=", "lix_sync")
-				.set({ value: "true" })
-				.execute()
-		)
-	);
-
-	// @ts-expect-error - eases debugging
-	lix1.db.__name = "lix1";
-
-	const server = await environment.openLix({ id: lixId.value });
-
-	let version0: Version;
-
-	// lix0 creates and switches to a new version
-	await lix0.db.transaction().execute(async (trx) => {
-		const currentVersion = await trx
-			.selectFrom("current_version")
-			.selectAll()
-			.executeTakeFirstOrThrow();
-		version0 = await createVersion({
-			lix: { ...lix0, db: trx },
-			from: currentVersion,
-			name: "version0",
-		});
-		await switchVersion({ lix: { ...lix0, db: trx }, to: version0 });
-	});
-
-	// awaiting the polling sync
-	await new Promise((resolve) => setTimeout(resolve, 2001));
-
-	// expecting the server to have received the change for the version insert
-	const serverChanges = await server.lix.db
-		.selectFrom("change")
-		.innerJoin("snapshot", "change.snapshot_id", "snapshot.id")
-		.where("schema_key", "=", "lix_version_table")
-		.selectAll()
-		.execute();
-
-	expect(serverChanges).toEqual(
-		expect.arrayContaining([
-			expect.objectContaining({
-				content: version0!,
-			}),
-		])
-	);
-
-	// expecting both lix0 and lix1 to have the same versions
-	const lix0Versions = await lix0.db
-		.selectFrom("version")
-		.selectAll()
-		.execute();
-
-	const lix1Versions = await lix1.db
-		.selectFrom("version")
-		.selectAll()
-		.execute();
-
-	expect(lix0Versions).toEqual(lix1Versions);
-
-	// expecting both lix0 and lix1 to have the same version changes
-	const [lix0VersionChanges, lix1VersionChanges] = await Promise.all(
-		[lix0, lix1].map((lix) =>
-			lix.db
-				.selectFrom("version_change")
-				.orderBy("change_id", "desc")
-				.orderBy("version_id", "desc")
-				.selectAll()
-				.execute()
-		)
-	);
-
-	expect(lix0VersionChanges).toEqual(lix1VersionChanges);
-});
-
-test("switching synced versions should work", async () => {
-	const environment = createLsaInMemoryEnvironment();
-	const lsaHandler = await createServerApiHandler({ environment });
-
-	global.fetch = vi.fn((request) => lsaHandler(request));
-	// @ts-expect-error - eases debugging
-	global.executeSync = executeSync;
-
-	const lix0 = await openLixInMemory({
-		keyValues: [{ key: "lix_sync", value: "true" }],
-	});
-	// @ts-expect-error - eases debugging
-	lix0.db.__name = "lix0";
-
-	const lixId = await lix0.db
-		.selectFrom("key_value")
-		.where("key", "=", "lix_id")
-		.selectAll()
-		.executeTakeFirstOrThrow();
-
-	const server = await environment.openLix({ id: lixId.value });
-
-	// initialize lix on the server
-	await lsaHandler(
-		new Request("http://mock.com/lsa/new-v1", {
-			method: "POST",
-			body: await toBlob({ lix: lix0 }),
-		})
-	);
-
-	// set sync server
-	await lix0.db
-		.insertInto("key_value")
-		.values({
-			key: "lix_server_url",
-			value: "http://mock.com",
-		})
-		.execute();
-
-	// create a second client
-	const lix1 = await openLixInMemory({
-		blob: await toBlob({ lix: lix0 }),
-		keyValues: [{ key: "lix_sync", value: "true" }],
-	});
-
-	// @ts-expect-error - eases debugging
-	lix1.db.__name = "lix1";
-
-	const currentVersion = await lix0.db
-		.selectFrom("current_version")
-		.selectAll()
-		.executeTakeFirstOrThrow();
-
-	// lix0 creates and switches to a new version
-	// in which a new change is created that should be
-	// synced to lix1
-	const version0 = await createVersion({
-		lix: lix0,
-		name: "version0",
-		from: currentVersion,
-	});
-
-	await switchVersion({ lix: lix0, to: version0 });
-
-	await lix0.db
-		.insertInto("key_value")
-		.values({
-			key: "mock-key",
-			value: "mock",
-		})
-		.execute();
-
-	// awaiting the polling sync
-	await new Promise((resolve) => setTimeout(resolve, 2004));
-
-	// expecting all changes to be the same across
-	// lix0, the server, and lix1
-	const keyValueChangesInLix0 = await lix0.db
-		.selectFrom("change")
-		.where("schema_key", "=", "lix_key_value_table")
-		.where("entity_id", "=", "mock-key")
-		.selectAll()
-		.execute();
-
-	const keyValueChangesOnServer = await server.lix.db
-		.selectFrom("change")
-		.where("schema_key", "=", "lix_key_value_table")
-		.where("entity_id", "=", "mock-key")
-		.selectAll()
-		.execute();
-
-	const keyValueChangesInLix1 = await lix1.db
-		.selectFrom("change")
-		.where("schema_key", "=", "lix_key_value_table")
-		.where("entity_id", "=", "mock-key")
-		.selectAll()
-		.execute();
-
-	expect(keyValueChangesInLix0).toEqual(keyValueChangesOnServer);
-	expect(keyValueChangesOnServer).toEqual(keyValueChangesInLix1);
-
-	// switch lix1 to the same version as lix0
-	// and expect key value to be mock
-	await switchVersion({ lix: lix1, to: version0 });
-
-	const keyValue = await lix1.db
-		.selectFrom("key_value")
-		.where("key", "=", "mock-key")
-		.selectAll()
-		.executeTakeFirst();
-
-	expect(keyValue).toMatchObject({
-		key: "mock-key",
-		value: "mock",
-	});
-});
-
-test("doesnt sync if lix_sync is not true", async () => {
-	const environment = createLsaInMemoryEnvironment();
-	const lsaHandler = await createServerApiHandler({ environment });
-	global.fetch = vi.fn((request) => lsaHandler(request));
-
-	const lix = await openLixInMemory({});
-
-	const lixId = await lix.db
-		.selectFrom("key_value")
-		.where("key", "=", "lix_id")
-		.selectAll()
-		.executeTakeFirstOrThrow();
-
-	// initialize lix on the server
-	await lsaHandler(
-		new Request("http://mock.com/lsa/new-v1", {
-			method: "POST",
-			body: await toBlob({ lix }),
-		})
-	);
-
-	await lix.db
-		.updateTable("key_value")
-		.set({ value: "false" })
-		.where("key", "=", "lix_sync")
-		.execute();
-
-	await lix.db
-		.insertInto("key_value")
-		.values({ key: "lix_server_url", value: "http://mock.com" })
-		.execute();
-
-	await lix.db
-		.insertInto("key_value")
-		.values({ key: "foo", value: "bar" })
-		.execute();
-
-	const server = await environment.openLix({ id: lixId.value });
-
-	// awaiting the polling sync
-	await new Promise((resolve) => setTimeout(resolve, 1010));
-
-	const keyValueChangesOnServer = await server.lix.db
-		.selectFrom("change")
-		.where("schema_key", "=", "lix_key_value_table")
-		.where("entity_id", "=", "foo")
-		.selectAll()
-		.execute();
-
-	expect(keyValueChangesOnServer).toEqual([]);
-
-	// turning sync on
-
-	await lix.db
-		.updateTable("key_value")
-		.set({ value: "true" })
-		.where("key", "=", "lix_sync")
-		.execute();
-
-	await new Promise((resolve) => setTimeout(resolve, 1010));
-
-	const keyValueChangesOnServerAfterSync = await server.lix.db
-		.selectFrom("change")
-		.innerJoin("snapshot", "change.snapshot_id", "snapshot.id")
-		.where("schema_key", "=", "lix_key_value_table")
-		.where("entity_id", "=", "foo")
-		.selectAll()
-		.execute();
-
-	expect(keyValueChangesOnServerAfterSync).toEqual(
-		expect.arrayContaining([
-			expect.objectContaining({
-				content: expect.objectContaining({
-					key: "foo",
-					value: "bar",
-				}),
-			}),
-		])
-	);
-});

package/node_modules/@lix-js/sdk/src/sync/sync-process.ts

@@ -1,85 +0,0 @@
-import type { Lix } from "../lix/open-lix.js";
-import { pushToServer } from "./push-to-server.js";
-import { pullFromServer } from "./pull-from-server.js";
-import { toBlob } from "../lix/to-blob.js";
-
-export async function initSyncProcess(args: {
-	lix: Pick<Lix, "db" | "plugin" | "sqlite">;
-}): Promise<void> {
-	const lixId = await args.lix.db
-		.selectFrom("key_value")
-		.where("key", "=", "lix_id")
-		.select("value")
-		.executeTakeFirstOrThrow();
-
-	const pullAndPush = async () => {
-		const shouldSync = await args.lix.db
-			.selectFrom("key_value")
-			.where("key", "=", "lix_sync")
-			.select("value")
-			.executeTakeFirst();
-
-		if (shouldSync?.value !== "true") {
-			return;
-		}
-
-		const url = await args.lix.db
-			.selectFrom("key_value")
-			// saved in key value because simpler for experimentation
-			.where("key", "=", "lix_server_url")
-			.select("value")
-			.executeTakeFirst();
-		// if you want to test sync, restart the lix app
-		// to make sure the experimental-sync-url is set
-		if (!url) {
-			return;
-		}
-
-		try {
-			// console.log("----------- PULL FROM SERVER -------------");
-			const serverState = await pullFromServer({
-				serverUrl: url.value,
-				lix: args.lix,
-				id: lixId.value,
-			});
-			// console.log(
-			// 	"----------- DONE PULL FROM SERVER ------------- New known Server state: ",
-			// 	serverState
-			// );
-			// console.log("----------- PUSH TO SERVER -------------");
-			await pushToServer({
-				serverUrl: url.value,
-				lix: args.lix,
-				id: lixId.value,
-				targetVectorClock: serverState,
-			});
-		} catch (e) {
-			// likely that lix didn't exist on the server
-			const response = await fetch(
-				new Request(url.value + "/lsa/new-v1", {
-					method: "POST",
-					body: await toBlob({ lix: args.lix }),
-				})
-			);
-			if (!response.ok && response.status !== 409) {
-				throw e;
-			}
-		}
-		// console.log("----------- DONE PUSH TO SERVER -------------");
-	};
-
-	// naive implementation that syncs every second
-
-	function schedulePullAndPush() {
-		if (args.lix.sqlite.isOpen()) {
-			pullAndPush().catch((e) => {
-				console.error("Error in sync process", e);
-			});
-		}
-		setTimeout(() => {
-			schedulePullAndPush();
-		}, 1000);
-	}
-
-	schedulePullAndPush();
-}

package/node_modules/@lix-js/sdk/src/version/create-version.test.ts

@@ -1,149 +0,0 @@
-import { test, expect } from "vitest";
-import { openLixInMemory } from "../lix/open-lix-in-memory.js";
-import { createVersion } from "./create-version.js";
-import { updateChangesInVersion } from "./update-changes-in-version.js";
-import { createChangeConflict } from "../change-conflict/create-change-conflict.js";
-
-test("it should copy the changes from the parent version", async () => {
-	const lix = await openLixInMemory({});
-
-	const version0 = await lix.db
-		.insertInto("version")
-		.values({ name: "version0" })
-		.returningAll()
-		.executeTakeFirstOrThrow();
-
-	const changes = await lix.db
-		.insertInto("change")
-		.values([
-			{
-				schema_key: "file",
-				entity_id: "value1",
-				file_id: "mock",
-				plugin_key: "mock-plugin",
-				snapshot_id: "no-content",
-			},
-			{
-				schema_key: "file",
-				entity_id: "value2",
-				file_id: "mock",
-				plugin_key: "mock-plugin",
-				snapshot_id: "no-content",
-			},
-		])
-		.returningAll()
-		.execute();
-
-	await updateChangesInVersion({
-		lix,
-		version: version0,
-		changes,
-	});
-
-	const version1 = await createVersion({
-		lix,
-		from: version0,
-	});
-
-	const changesInversion0 = await lix.db
-		.selectFrom("change")
-		.innerJoin("version_change", "change.id", "version_change.change_id")
-		.selectAll("change")
-		.where("version_id", "=", version0.id)
-		.execute();
-
-	const changesInversion1 = await lix.db
-		.selectFrom("change")
-		.innerJoin("version_change", "change.id", "version_change.change_id")
-		.selectAll("change")
-		.where("version_id", "=", version1.id)
-		.execute();
-
-	// main and feature version should have the same changes
-	expect(changesInversion0).toStrictEqual(changesInversion1);
-});
-
-// test("if a parent version is provided, a merge target should be created to activate conflict detection", async () => {
-// 	const lix = await openLixInMemory({});
-
-// 	const version0 = await createVersion({ lix, name: "version0" });
-// 	const version1 = await createVersion({ lix, parent: version0, name: "version1" });
-
-// 	const versionTarget = await lix.db
-// 		.selectFrom("version_target")
-// 		.selectAll()
-// 		.where("source_version_id", "=", version1.id)
-// 		.where("target_version_id", "=", version0.id)
-// 		.execute();
-
-// 	expect(versionTarget.length).toBe(1);
-// });
-
-test("it should copy change conflict pointers from the parent version", async () => {
-	const lix = await openLixInMemory({});
-
-	const version0 = await lix.db
-		.insertInto("version")
-		.values({ name: "version0" })
-		.returningAll()
-		.executeTakeFirstOrThrow();
-
-	const changes = await lix.db
-		.insertInto("change")
-		.values([
-			{
-				schema_key: "file",
-				entity_id: "value1",
-				file_id: "mock",
-				plugin_key: "mock-plugin",
-				snapshot_id: "no-content",
-			},
-			{
-				schema_key: "file",
-				entity_id: "value2",
-				file_id: "mock",
-				plugin_key: "mock-plugin",
-				snapshot_id: "no-content",
-			},
-		])
-		.returningAll()
-		.execute();
-
-	await updateChangesInVersion({
-		lix,
-		version: version0,
-		changes,
-	});
-
-	await createChangeConflict({
-		lix,
-		version: version0,
-		key: "mock-key",
-		conflictingChangeIds: new Set([changes[0]!.id, changes[1]!.id]),
-	});
-
-	const version0Conflicts = await lix.db
-		.selectFrom("version_change_conflict")
-		.where("version_id", "=", version0.id)
-		.selectAll()
-		.execute();
-
-	expect(version0Conflicts.length).toBe(1);
-
-	const version1 = await createVersion({
-		lix,
-		from: version0,
-		name: "version1",
-	});
-
-	const version2Conflicts = await lix.db
-		.selectFrom("version_change_conflict")
-		.where("version_id", "=", version1.id)
-		.selectAll()
-		.execute();
-
-	expect(version2Conflicts.length).toBe(1);
-	expect(version2Conflicts[0]?.change_conflict_id).toBe(
-		version0Conflicts[0]?.change_conflict_id
-	);
-});

package/node_modules/@lix-js/sdk/src/version/create-version.ts

@@ -1,88 +0,0 @@
-import type { Version } from "../database/schema.js";
-import type { Lix } from "../lix/open-lix.js";
-
-/**
- * Creates a new Version.
- *
- * If `from` is provided, the new version will be identical to the from version.
- *
- * @example
- *   _Without from_
- *
- *   ```ts
- *   const version = await createVersion({ lix });
- *   ```
- *
- * @example
- *   _With from_
- *
- *   ```ts
- *   const version = await createVersion({ lix, from: otherVersion });
- *   ```
- */
-export async function createVersion(args: {
-	lix: Pick<Lix, "db">;
-	from?: Pick<Version, "id">;
-	name?: Version["name"];
-}): Promise<Version> {
-	const executeInTransaction = async (trx: Lix["db"]) => {
-		let query = trx.insertInto("version").returningAll();
-
-		if (args.name) {
-			query = query.values({ name: args.name });
-		} else {
-			query = query.defaultValues();
-		}
-
-		const newVersion = await query.executeTakeFirstOrThrow();
-
-		// copy the change pointers from the from Version
-		if (args.from) {
-			await trx
-				.insertInto("version_change")
-				.columns([
-					"version_id",
-					"change_id",
-					"entity_id",
-					"schema_key",
-					"file_id",
-				])
-				.expression((eb) =>
-					eb
-						.selectFrom("version_change")
-						.select([
-							eb.val(newVersion.id).as("version_id"),
-							"change_id",
-							"entity_id",
-							"schema_key",
-							"file_id",
-						])
-						.where("version_id", "=", args.from!.id)
-				)
-				.execute();
-
-			// copy the change conflicts from the from Version
-			await trx
-				.insertInto("version_change_conflict")
-				.columns(["version_id", "change_conflict_id"])
-				.expression((eb) =>
-					eb
-						.selectFrom("version_change_conflict")
-						.select([
-							eb.val(newVersion.id).as("version_id"),
-							"change_conflict_id",
-						])
-						.where("version_id", "=", args.from!.id)
-				)
-				.execute();
-		}
-
-		return newVersion;
-	};
-
-	if (args.lix.db.isTransaction) {
-		return executeInTransaction(args.lix.db);
-	} else {
-		return args.lix.db.transaction().execute(executeInTransaction);
-	}
-}

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

@@ -1,8 +0,0 @@
-/**
- * Public API for the versiones.
- */
-
-export { createVersion } from "./create-version.js";
-export { switchVersion } from "./switch-version.js";
-export { updateChangesInVersion } from "./update-changes-in-version.js";
-export { mergeVersion } from "./merge-version.js";