@lix-js/sdk 0.0.1 → 0.1.0

package/src/server-api-handler/environment/create-in-memory-environment.ts

@@ -1,5 +1,8 @@
+import { fileQueueSettled } from "../../file-queue/file-queue-settled.js";
+import { closeLix } from "../../lix/close-lix.js";
 import { openLixInMemory } from "../../lix/open-lix-in-memory.js";
 import type { Lix } from "../../lix/open-lix.js";
+import { toBlob } from "../../lix/to-blob.js";
 import type { LsaEnvironment } from "./environment.js";
 
 /**
@@ -72,7 +75,7 @@ export const createLsaInMemoryEnvironment = (): LsaEnvironment => {
 				lix = await openLixInMemory({
 					blob,
 					// don't sync the server with itself
-					keyValues: [{ key: "#lix_sync", value: "false" }],
+					keyValues: [{ key: "lix_sync", value: "false" }],
 				});
 
 				lix.sqlite.exec("PRAGMA foreign_keys = OFF;");
@@ -100,8 +103,9 @@ export const createLsaInMemoryEnvironment = (): LsaEnvironment => {
 			if (connections.size === 0) {
 				// TODO no concurrency guarantees
 				const lix = openLixes.get(args.id);
-				const blob = await lix!.toBlob();
-				await lix?.close();
+				await fileQueueSettled({ lix: lix! });
+				const blob = await toBlob({ lix: lix! });
+				await closeLix({ lix: lix! });
 				openConnections.delete(args.id);
 				openLixes.delete(args.id);
 				store.set(args.id, blob);

package/src/server-api-handler/routes/get-v1.test.ts

@@ -3,6 +3,7 @@ import { createServerApiHandler } from "../create-server-api-handler.js";
 import { newLixFile } from "../../lix/new-lix.js";
 import { openLixInMemory } from "../../lix/open-lix-in-memory.js";
 import { createLsaInMemoryEnvironment } from "../environment/create-in-memory-environment.js";
+import { toBlob } from "../../lix/to-blob.js";
 
 test("it should fetch the lix file from the server", async () => {
 	const lix = await openLixInMemory({
@@ -26,7 +27,7 @@ test("it should fetch the lix file from the server", async () => {
 	await lsaHandler(
 		new Request("http://localhost:3000/lsa/new-v1", {
 			method: "POST",
-			body: await lix.toBlob(),
+			body: await toBlob({ lix }),
 		})
 	);
 
@@ -103,20 +104,20 @@ test("it should return 400 for a request without lix_id", async () => {
 	expect(responseJson.error).toBe("Missing required field 'lix_id'");
 });
 
-test("#lix_sync is set to true", async () => {
+test("lix_sync is set to true", async () => {
 	const environment = createLsaInMemoryEnvironment();
 	const lsaHandler = await createServerApiHandler({ environment });
 
 	const lix = await openLixInMemory({
 		blob: await newLixFile(),
-		keyValues: [{ key: "#lix_sync", value: "false" }],
+		keyValues: [{ key: "lix_sync", value: "false" }],
 	});
 
 	// Store the lix file
 	const response0 = await lsaHandler(
 		new Request("http://localhost:3000/lsa/new-v1", {
 			method: "POST",
-			body: await lix.toBlob(),
+			body: await toBlob({ lix }),
 		})
 	);
 
@@ -138,7 +139,7 @@ test("#lix_sync is set to true", async () => {
 
 	const lixSync = await lixFromServer.db
 		.selectFrom("key_value")
-		.where("key", "=", "#lix_sync")
+		.where("key", "=", "lix_sync")
 		.selectAll()
 		.executeTakeFirstOrThrow();
 

package/src/server-api-handler/routes/get-v1.ts

@@ -47,12 +47,10 @@ export const route: LixServerApiHandlerRoute = async (context) => {
 		content: new Uint8Array(await blob!.arrayBuffer()),
 	});
 
-	sqlite.exec("UPDATE key_value SET value = 'true' WHERE key = '#lix_sync'");
+	sqlite.exec("UPDATE key_value SET value = 'true' WHERE key = 'lix_sync'");
 
 	const blob2 = new Blob([contentFromDatabase(sqlite)]);
 
-	sqlite.close();
-
 	return new Response(blob2, {
 		status: 200,
 		headers: {

package/src/server-api-handler/routes/new-v1.test.ts

@@ -3,6 +3,7 @@ import { createServerApiHandler } from "../create-server-api-handler.js";
 import { newLixFile } from "../../lix/new-lix.js";
 import { openLixInMemory } from "../../lix/open-lix-in-memory.js";
 import { createLsaInMemoryEnvironment } from "../environment/create-in-memory-environment.js";
+import { toBlob } from "../../lix/to-blob.js";
 
 test("it should store the lix file", async () => {
 	const initLix = await openLixInMemory({
@@ -22,7 +23,7 @@ test("it should store the lix file", async () => {
 	const response = await lsaHandler(
 		new Request("http://localhost:3000/lsa/new-v1", {
 			method: "POST",
-			body: await initLix.toBlob(),
+			body: await toBlob({ lix: initLix }),
 		})
 	);
 	const json = await response.json();

package/src/server-api-handler/routes/new-v1.ts

@@ -11,7 +11,9 @@ export const route: LixServerApiHandlerRoute = async (context) => {
 		lix = await openLixInMemory({
 			blob,
 			// turn off sync for server
-			keyValues: [{ key: "#lix_sync", value: "false" }],
+			keyValues: [
+				{ key: "lix_sync", value: "false", skip_change_control: true },
+			],
 		});
 	} catch {
 		return new Response(null, {

package/src/server-api-handler/routes/pull-v1.test.ts

@@ -5,6 +5,7 @@ import { createServerApiHandler } from "../create-server-api-handler.js";
 import { mockJsonSnapshot } from "../../snapshot/mock-json-snapshot.js";
 import { mockChange } from "../../change/mock-change.js";
 import { createLsaInMemoryEnvironment } from "../environment/create-in-memory-environment.js";
+import { toBlob } from "../../lix/to-blob.js";
 
 type RequestBody =
 	LixServerApi.paths["/lsa/pull-v1"]["post"]["requestBody"]["content"]["application/json"];
@@ -27,7 +28,7 @@ test("it should pull rows successfully", async () => {
 
 	const environment = createLsaInMemoryEnvironment();
 
-	await environment.setLix({ id: id.value, blob: await lix.toBlob() });
+	await environment.setLix({ id: id.value, blob: await toBlob({ lix }) });
 
 	const lsaHandler = await createServerApiHandler({ environment });
 
@@ -79,7 +80,7 @@ test("it should specifically be able to handle snapshots which use json binary a
 		.execute();
 
 	const environment = createLsaInMemoryEnvironment();
-	await environment.setLix({ id, blob: await lix.toBlob() });
+	await environment.setLix({ id, blob: await toBlob({ lix }) });
 
 	const lsa = await createServerApiHandler({ environment });
 
@@ -172,7 +173,7 @@ test("it should handle empty tables gracefully", async () => {
 		.executeTakeFirstOrThrow();
 
 	const environment = createLsaInMemoryEnvironment();
-	await environment.setLix({ id, blob: await lix.toBlob() });
+	await environment.setLix({ id, blob: await toBlob({ lix }) });
 
 	const lsa = await createServerApiHandler({ environment });
 

package/src/server-api-handler/routes/push-v1.test.ts

@@ -9,6 +9,7 @@ import { createVersion } from "../../version/create-version.js";
 import { switchVersion } from "../../version/switch-version.js";
 import { pullFromServer } from "../../sync/pull-from-server.js";
 import { createLsaInMemoryEnvironment } from "../environment/create-in-memory-environment.js";
+import { toBlob } from "../../lix/to-blob.js";
 
 test("it should push data successfully", async () => {
 	const lix = await openLixInMemory({});
@@ -19,7 +20,7 @@ test("it should push data successfully", async () => {
 		.executeTakeFirstOrThrow();
 
 	const environment = createLsaInMemoryEnvironment();
-	await environment.setLix({ id, blob: await lix.toBlob() });
+	await environment.setLix({ id, blob: await toBlob({ lix }) });
 
 	const lsaHandler = await createServerApiHandler({ environment });
 
@@ -130,7 +131,7 @@ test("it should return 400 for a failed insert operation", async () => {
 
 	const environment = createLsaInMemoryEnvironment();
 
-	environment.setLix({ id, blob: await lix.toBlob() });
+	environment.setLix({ id, blob: await toBlob({ lix }) });
 
 	const lsa = await createServerApiHandler({ environment });
 
@@ -169,7 +170,7 @@ test.skip("it should detect conflicts", async () => {
 
 	// initialize client
 	const lixOnClient = await openLixInMemory({
-		blob: await lixOnServer.toBlob(),
+		blob: await toBlob({ lix: lixOnServer }),
 	});
 
 	const lixId = await lixOnServer.db
@@ -192,7 +193,7 @@ test.skip("it should detect conflicts", async () => {
 
 	await environment.setLix({
 		id: lixId.value,
-		blob: await lixOnServer.toBlob(),
+		blob: await toBlob({ lix: lixOnServer }),
 	});
 
 	// client has/creates value1 for mock_key

package/src/sync/pull-from-server.test.ts

@@ -4,11 +4,14 @@ import { openLixInMemory } from "../lix/open-lix-in-memory.js";
 import { pullFromServer } from "./pull-from-server.js";
 import { mockJsonSnapshot } from "../snapshot/mock-json-snapshot.js";
 import { createLsaInMemoryEnvironment } from "../server-api-handler/environment/create-in-memory-environment.js";
+import { toBlob } from "../lix/to-blob.js";
 
 test("pull rows of multiple tables from server successfully and applies them", async () => {
 	const lixOnServer = await openLixInMemory({});
 
-	const lix = await openLixInMemory({ blob: await lixOnServer.toBlob() });
+	const lix = await openLixInMemory({
+		blob: await toBlob({ lix: lixOnServer }),
+	});
 
 	const { value: id } = await lixOnServer.db
 		.selectFrom("key_value")
@@ -38,7 +41,7 @@ test("pull rows of multiple tables from server successfully and applies them", a
 	await lsaHandler(
 		new Request("http://localhost:3000/lsa/new-v1", {
 			method: "POST",
-			body: await lixOnServer.toBlob(),
+			body: await toBlob({ lix: lixOnServer }),
 			headers: {
 				"Content-Type": "application/json",
 			},
@@ -66,13 +69,15 @@ test("pull rows of multiple tables from server successfully and applies them", a
 		.executeTakeFirstOrThrow();
 
 	expect(account).toEqual({ id: "account0", name: "test account" });
-	expect(mockKey).toEqual({ key: "mock-key", value: "mock-value" });
+	expect(mockKey).toMatchObject({ key: "mock-key", value: "mock-value" });
 });
 
 test("it handles snapshot.content being json binary", async () => {
 	const lixOnServer = await openLixInMemory({});
 
-	const lix = await openLixInMemory({ blob: await lixOnServer.toBlob() });
+	const lix = await openLixInMemory({
+		blob: await toBlob({ lix: lixOnServer }),
+	});
 
 	const { value: id } = await lixOnServer.db
 		.selectFrom("key_value")
@@ -101,7 +106,7 @@ test("it handles snapshot.content being json binary", async () => {
 	await lsaHandler(
 		new Request("http://localhost:3000/lsa/new-v1", {
 			method: "POST",
-			body: await lixOnServer.toBlob(),
+			body: await toBlob({ lix: lixOnServer }),
 			headers: {
 				"Content-Type": "application/json",
 			},
@@ -141,7 +146,9 @@ test("rows changed on the client more recently should not be updated", async ()
 		})
 		.executeTakeFirstOrThrow();
 
-	const lix = await openLixInMemory({ blob: await lixOnServer.toBlob() });
+	const lix = await openLixInMemory({
+		blob: await toBlob({ lix: lixOnServer }),
+	});
 
 	const environment = createLsaInMemoryEnvironment();
 	const lsaHandler = await createServerApiHandler({ environment });
@@ -152,7 +159,7 @@ test("rows changed on the client more recently should not be updated", async ()
 	await lsaHandler(
 		new Request("http://localhost:3000/lsa/new-v1", {
 			method: "POST",
-			body: await lixOnServer.toBlob(),
+			body: await toBlob({ lix: lixOnServer }),
 			headers: {
 				"Content-Type": "application/json",
 			},
@@ -179,7 +186,10 @@ test("rows changed on the client more recently should not be updated", async ()
 		.selectAll()
 		.executeTakeFirstOrThrow();
 
-	expect(mockKey).toEqual({ key: "mock-key", value: "mock-value-updated" });
+	expect(mockKey).toMatchObject({
+		key: "mock-key",
+		value: "mock-value-updated",
+	});
 });
 
 // the change table now models "change control". no more last edit wins needed
@@ -192,7 +202,9 @@ test.skip("rows changed on the server more recently should be updated on the cli
 
 	// create a lix and clone it for the client - so they share the same lix id
 	const remoteLix = await openLixInMemory({});
-	const localLix = await openLixInMemory({ blob: await remoteLix.toBlob() });
+	const localLix = await openLixInMemory({
+		blob: await toBlob({ lix: remoteLix }),
+	});
 
 	// insert mock data into server lix
 	await remoteLix.db
@@ -234,7 +246,7 @@ test.skip("rows changed on the server more recently should be updated on the cli
 	await lsaHandler(
 		new Request("http://localhost:3000/lsa/new-v1", {
 			method: "POST",
-			body: await remoteLix.toBlob(),
+			body: await toBlob({ lix: remoteLix }),
 			headers: {
 				"Content-Type": "application/json",
 			},
@@ -347,7 +359,7 @@ test("non-conflicting changes from the server should for the same version should
 
 	global.fetch = vi.fn((request) => lsaHandler(request));
 
-	const lixOnServer = await openLixInMemory({ blob: await lix.toBlob() });
+	const lixOnServer = await openLixInMemory({ blob: await toBlob({ lix }) });
 
 	// insert data on the server that the client does not have yet
 	await lixOnServer.db
@@ -369,7 +381,10 @@ test("non-conflicting changes from the server should for the same version should
 		expect.arrayContaining([
 			expect.objectContaining({
 				version_id: currentVersion.id,
-				content: { key: "mock-key", value: "mock-value" },
+				content: expect.objectContaining({
+					key: "mock-key",
+					value: "mock-value",
+				}),
 			}),
 		])
 	);
@@ -377,7 +392,7 @@ test("non-conflicting changes from the server should for the same version should
 	await lsaHandler(
 		new Request("http://localhost:3000/lsa/new-v1", {
 			method: "POST",
-			body: await lixOnServer.toBlob(),
+			body: await toBlob({ lix: lixOnServer }),
 			headers: {
 				"Content-Type": "application/json",
 			},
@@ -405,6 +420,6 @@ test("non-conflicting changes from the server should for the same version should
 		.select("snapshot.content as content")
 		.execute();
 
-	expect(mockKey).toEqual({ key: "mock-key", value: "mock-value" });
+	expect(mockKey).toMatchObject({ key: "mock-key", value: "mock-value" });
 	expect(versionChanges).toEqual(expect.arrayContaining(serverVersionChanges));
 });

package/src/sync/pull-from-server.ts

@@ -133,8 +133,6 @@ export async function pullFromServer(args: {
 		});
 
 		if (changesToApply.length > 0) {
-			// the changes already exists hence prevent own change control
-			// from creating new changes for the applied changes
 			await applyChanges({
 				lix: { ...args.lix, db: trx },
 				changes: changesToApply,

package/src/sync/push-to-server.test.ts

@@ -5,10 +5,11 @@ import { pushToServer } from "./push-to-server.js";
 import type { LixFile } from "../database/schema.js";
 import type { Account } from "../account/database-schema.js";
 import { newLixFile } from "../lix/new-lix.js";
-import type { KeyValue } from "../key-value/database-schema.js";
+import type { NewKeyValue } from "../key-value/database-schema.js";
 import { mockJsonSnapshot } from "../snapshot/mock-json-snapshot.js";
 import { pullFromServer } from "./pull-from-server.js";
 import { createLsaInMemoryEnvironment } from "../server-api-handler/environment/create-in-memory-environment.js";
+import { toBlob } from "../lix/to-blob.js";
 
 test("push rows of multiple tables to server successfully", async () => {
 	const lixBlob = await newLixFile();
@@ -30,7 +31,7 @@ test("push rows of multiple tables to server successfully", async () => {
 	await lsaHandler(
 		new Request("http://localhost:3000/lsa/new-v1", {
 			method: "POST",
-			body: await lix.toBlob(),
+			body: await toBlob({ lix }),
 		})
 	);
 
@@ -83,11 +84,11 @@ test("push rows of multiple tables to server successfully", async () => {
 		{ id: "account0", name: "some account" } satisfies Account,
 	]);
 	expect(keyValueChangesOnServer.map((c) => c.content)).toEqual([
-		{
+		expect.objectContaining({
 			key: "mock-key",
 			value: "mock-value",
-		},
-	] satisfies KeyValue[]);
+		}),
+	] satisfies NewKeyValue[]);
 });
 
 test("push-pull-push with two clients", async () => {
@@ -111,7 +112,7 @@ test("push-pull-push with two clients", async () => {
 	await lsaHandler(
 		new Request("http://localhost:3000/lsa/new-v1", {
 			method: "POST",
-			body: await client1.toBlob(),
+			body: await toBlob({ lix: client1 }),
 		})
 	);
 
@@ -165,10 +166,10 @@ test("push-pull-push with two clients", async () => {
 
 	expect(client2KeyValueAfterPull).toEqual(
 		expect.arrayContaining([
-			{
+			expect.objectContaining({
 				key: "mock-key",
 				value: "mock-value from client 1",
-			} satisfies KeyValue,
+			} satisfies NewKeyValue),
 		])
 	);
 
@@ -260,15 +261,18 @@ test("push-pull-push with two clients", async () => {
 
 	expect(keyValueChangesOnServer.map((c) => c.content)).toEqual(
 		expect.arrayContaining([
-			{
+			expect.objectContaining({
 				key: "mock-key",
 				value: "mock-value from client 1",
-			},
-			{
+			}),
+			expect.objectContaining({
 				key: "mock-key",
 				value: "mock-value from client 1 - updated by client 2",
-			},
-			{ key: "mock-key-2", value: "mock-value from client 2" },
+			}),
+			expect.objectContaining({
+				key: "mock-key-2",
+				value: "mock-value from client 2",
+			}),
 		])
 	);
 });
@@ -291,7 +295,7 @@ test("it should handle snapshots.content json binaries", async () => {
 	await lsaHandler(
 		new Request("http://localhost:3000/lsa/new-v1", {
 			method: "POST",
-			body: await lix.toBlob(),
+			body: await toBlob({ lix }),
 		})
 	);
 
@@ -345,7 +349,7 @@ test.todo("it should handle binary values", async () => {
 	await lsaHandler(
 		new Request("http://localhost:3000/lsa/new", {
 			method: "POST",
-			body: await lix.toBlob(),
+			body: await toBlob({ lix }),
 		})
 	);
 

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

@@ -8,6 +8,7 @@ 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();
@@ -16,7 +17,7 @@ test("versions should be synced", async () => {
 	global.fetch = vi.fn((request) => lsaHandler(request));
 
 	const lix0 = await openLixInMemory({
-		keyValues: [{ key: "#lix_sync", value: "true" }],
+		keyValues: [{ key: "lix_server_url", value: "http://mock.com" }],
 	});
 
 	// @ts-expect-error - eases debugging
@@ -32,32 +33,26 @@ test("versions should be synced", async () => {
 	await lsaHandler(
 		new Request("http://mock.com/lsa/new-v1", {
 			method: "POST",
-			body: await lix0.toBlob(),
+			body: await toBlob({ lix: lix0 }),
 		})
 	);
 
 	// create a second client
 	const lix1 = await openLixInMemory({
-		blob: await lix0.toBlob(),
-		keyValues: [{ key: "#lix_sync", value: "true" }],
+		blob: await toBlob({ lix: lix0 }),
+		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();
+	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";
@@ -74,7 +69,7 @@ test("versions should be synced", async () => {
 			.executeTakeFirstOrThrow();
 		version0 = await createVersion({
 			lix: { ...lix0, db: trx },
-			parent: currentVersion,
+			from: currentVersion,
 			name: "version0",
 		});
 		await switchVersion({ lix: { ...lix0, db: trx }, to: version0 });
@@ -113,17 +108,16 @@ test("versions should be synced", async () => {
 	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();
+	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);
 });
@@ -137,7 +131,7 @@ test("switching synced versions should work", async () => {
 	global.executeSync = executeSync;
 
 	const lix0 = await openLixInMemory({
-		keyValues: [{ key: "#lix_sync", value: "true" }],
+		keyValues: [{ key: "lix_sync", value: "true" }],
 	});
 	// @ts-expect-error - eases debugging
 	lix0.db.__name = "lix0";
@@ -154,7 +148,7 @@ test("switching synced versions should work", async () => {
 	await lsaHandler(
 		new Request("http://mock.com/lsa/new-v1", {
 			method: "POST",
-			body: await lix0.toBlob(),
+			body: await toBlob({ lix: lix0 }),
 		})
 	);
 
@@ -169,8 +163,8 @@ test("switching synced versions should work", async () => {
 
 	// create a second client
 	const lix1 = await openLixInMemory({
-		blob: await lix0.toBlob(),
-		keyValues: [{ key: "#lix_sync", value: "true" }],
+		blob: await toBlob({ lix: lix0 }),
+		keyValues: [{ key: "lix_sync", value: "true" }],
 	});
 
 	// @ts-expect-error - eases debugging
@@ -187,7 +181,7 @@ test("switching synced versions should work", async () => {
 	const version0 = await createVersion({
 		lix: lix0,
 		name: "version0",
-		parent: currentVersion,
+		from: currentVersion,
 	});
 
 	await switchVersion({ lix: lix0, to: version0 });
@@ -239,13 +233,13 @@ test("switching synced versions should work", async () => {
 		.selectAll()
 		.executeTakeFirst();
 
-	expect(keyValue).toEqual({
+	expect(keyValue).toMatchObject({
 		key: "mock-key",
 		value: "mock",
 	});
 });
 
-test("doesnt sync if #lix_sync is not true", async () => {
+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));
@@ -262,14 +256,14 @@ test("doesnt sync if #lix_sync is not true", async () => {
 	await lsaHandler(
 		new Request("http://mock.com/lsa/new-v1", {
 			method: "POST",
-			body: await lix.toBlob(),
+			body: await toBlob({ lix }),
 		})
 	);
 
 	await lix.db
 		.updateTable("key_value")
 		.set({ value: "false" })
-		.where("key", "=", "#lix_sync")
+		.where("key", "=", "lix_sync")
 		.execute();
 
 	await lix.db
@@ -301,7 +295,7 @@ test("doesnt sync if #lix_sync is not true", async () => {
 	await lix.db
 		.updateTable("key_value")
 		.set({ value: "true" })
-		.where("key", "=", "#lix_sync")
+		.where("key", "=", "lix_sync")
 		.execute();
 
 	await new Promise((resolve) => setTimeout(resolve, 1010));
@@ -317,10 +311,10 @@ test("doesnt sync if #lix_sync is not true", async () => {
 	expect(keyValueChangesOnServerAfterSync).toEqual(
 		expect.arrayContaining([
 			expect.objectContaining({
-				content: {
+				content: expect.objectContaining({
 					key: "foo",
 					value: "bar",
-				},
+				}),
 			}),
 		])
 	);