@lix-js/sdk 0.0.1

package/src/sync/sync-process.test.ts

@@ -0,0 +1,327 @@
+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";
+
+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_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();
+
+	// initialize lix on the server
+	await lsaHandler(
+		new Request("http://mock.com/lsa/new-v1", {
+			method: "POST",
+			body: await lix0.toBlob(),
+		})
+	);
+
+	// create a second client
+	const lix1 = await openLixInMemory({
+		blob: await lix0.toBlob(),
+		keyValues: [{ key: "#lix_sync", value: "true" }],
+	});
+
+	// start syncing
+	await lix0.db
+		.insertInto("key_value")
+		.values({
+			key: "lix_server_url",
+			value: "http://mock.com",
+		})
+		.execute();
+
+	await lix1.db
+		.insertInto("key_value")
+		.values({
+			key: "lix_server_url",
+			value: "http://mock.com",
+		})
+		.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 },
+			parent: 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 = await lix0.db
+		.selectFrom("version_change")
+		.orderBy("change_id", "desc")
+		.selectAll()
+		.execute();
+
+	const lix1VersionChanges = await lix1.db
+		.selectFrom("version_change")
+		.orderBy("change_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 lix0.toBlob(),
+		})
+	);
+
+	// 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 lix0.toBlob(),
+		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",
+		parent: 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).toEqual({
+		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 lix.toBlob(),
+		})
+	);
+
+	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: {
+					key: "foo",
+					value: "bar",
+				},
+			}),
+		])
+	);
+});

package/src/sync/sync-process.ts

@@ -0,0 +1,97 @@
+import type { Lix } from "../lix/open-lix.js";
+import { pushToServer } from "./push-to-server.js";
+import { pullFromServer } from "./pull-from-server.js";
+
+export async function initSyncProcess(args: {
+	lix: Pick<Lix, "db" | "plugin" | "toBlob">;
+}): Promise<
+	| {
+			stop: () => void;
+	  }
+	| undefined
+> {
+	const lixId = await args.lix.db
+		.selectFrom("key_value")
+		.where("key", "=", "lix_id")
+		.select("value")
+		.executeTakeFirstOrThrow();
+
+	let stoped = false;
+
+	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 args.lix.toBlob(),
+				})
+			);
+			if (!response.ok && response.status !== 409) {
+				throw e;
+			}
+		}
+		// console.log("----------- DONE PUSH TO SERVER -------------");
+	};
+
+	// naive implementation that syncs every second
+
+	function schedulePullAndPush() {
+		if (!stoped) {
+			pullAndPush().catch((e) => {
+				console.error("Error in sync process", e);
+			});
+		}
+		setTimeout(() => {
+			schedulePullAndPush();
+		}, 1000);
+	}
+
+	schedulePullAndPush();
+
+	return {
+		stop: () => {
+			stoped = true;
+		},
+	};
+}

package/src/version/create-version.test.ts

@@ -0,0 +1,149 @@
+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,
+		parent: 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,
+		parent: 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/src/version/create-version.ts

@@ -0,0 +1,76 @@
+import type { Version } from "../database/schema.js";
+import type { Lix } from "../lix/open-lix.js";
+
+/**
+ * Creates a new Version.
+ *
+ * If parent is provided, the new Version will copy the change pointers from the parent version.
+ *
+ * @example
+ *   _Without parent_
+ *
+ *   ```ts
+ *   const version = await createVersion({ lix });
+ *   ```
+ *
+ * @example
+ *   _With parent_
+ *
+ *   ```ts
+ *   const version = await createVersion({ lix, parent: otherVersion });
+ *   ```
+ */
+export async function createVersion(args: {
+	lix: Pick<Lix, "db">;
+	parent?: 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 parent Version
+		if (args.parent) {
+			await trx
+				.insertInto("version_change")
+				.columns(["version_id", "change_id"])
+				.expression((eb) =>
+					eb
+						.selectFrom("version_change")
+						.select([eb.val(newVersion.id).as("version_id"), "change_id"])
+						.where("version_id", "=", args.parent!.id)
+				)
+				.execute();
+
+			// copy the change conflicts from the parent 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.parent!.id)
+				)
+				.execute();
+		}
+
+		return newVersion;
+	};
+
+	if (args.lix.db.isTransaction) {
+		return executeInTransaction(args.lix.db);
+	} else {
+		return args.lix.db.transaction().execute(executeInTransaction);
+	}
+}

package/src/version/index.ts

@@ -0,0 +1,8 @@
+/**
+ * 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";