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

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

@@ -1,16 +1,19 @@
+// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+// @ts-nocheck
+
 import { expect, test, vi } from "vitest";
 import { createServerProtocolHandler } from "../server-protocol-handler/create-server-protocol-handler.js";
-import { openLixInMemory } from "../lix/open-lix-in-memory.js";
+import { openLix } from "../lix/open-lix.js";
 import { pullFromServer } from "./pull-from-server.js";
-import { mockJsonSnapshot } from "../snapshot/mock-json-snapshot.js";
 import { createLspInMemoryEnvironment } from "../server-protocol-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({});
+// commented out for lix v0.5
+// sync needs overhaul after change set graph introduction
+test.skip("pull rows of multiple tables from server successfully and applies them", async () => {
+	const lixOnServer = await openLix({});
 
-	const lix = await openLixInMemory({
-		blob: await toBlob({ lix: lixOnServer }),
+	const lix = await openLix({
+		blob: await lixOnServer.toBlob(),
 	});
 
 	const { value: id } = await lixOnServer.db
@@ -41,7 +44,7 @@ test("pull rows of multiple tables from server successfully and applies them", a
 	await lspHandler(
 		new Request("http://localhost:3000/lsp/new-v1", {
 			method: "POST",
-			body: await toBlob({ lix: lixOnServer }),
+			body: await lixOnServer.toBlob(),
 			headers: {
 				"Content-Type": "application/json",
 			},
@@ -72,11 +75,11 @@ test("pull rows of multiple tables from server successfully and applies them", a
 	expect(mockKey).toMatchObject({ key: "mock-key", value: "mock-value" });
 });
 
-test("it handles snapshot.content being json binary", async () => {
-	const lixOnServer = await openLixInMemory({});
+test.skip("it handles snapshot.content being json binary", async () => {
+	const lixOnServer = await openLix({});
 
-	const lix = await openLixInMemory({
-		blob: await toBlob({ lix: lixOnServer }),
+	const lix = await openLix({
+		blob: await lixOnServer.toBlob(),
 	});
 
 	const { value: id } = await lixOnServer.db
@@ -106,7 +109,7 @@ test("it handles snapshot.content being json binary", async () => {
 	await lspHandler(
 		new Request("http://localhost:3000/lsp/new-v1", {
 			method: "POST",
-			body: await toBlob({ lix: lixOnServer }),
+			body: await lixOnServer.toBlob(),
 			headers: {
 				"Content-Type": "application/json",
 			},
@@ -129,8 +132,8 @@ test("it handles snapshot.content being json binary", async () => {
 	expect(snapshots).toMatchObject(mockSnapshot);
 });
 
-test("rows changed on the client more recently should not be updated", async () => {
-	const lixOnServer = await openLixInMemory({});
+test.skip("rows changed on the client more recently should not be updated", async () => {
+	const lixOnServer = await openLix({});
 
 	const lixId = await lixOnServer.db
 		.selectFrom("key_value")
@@ -146,8 +149,8 @@ test("rows changed on the client more recently should not be updated", async ()
 		})
 		.executeTakeFirstOrThrow();
 
-	const lix = await openLixInMemory({
-		blob: await toBlob({ lix: lixOnServer }),
+	const lix = await openLix({
+		blob: await lixOnServer.toBlob(),
 	});
 
 	const environment = createLspInMemoryEnvironment();
@@ -159,7 +162,7 @@ test("rows changed on the client more recently should not be updated", async ()
 	await lspHandler(
 		new Request("http://localhost:3000/lsp/new-v1", {
 			method: "POST",
-			body: await toBlob({ lix: lixOnServer }),
+			body: await lixOnServer.toBlob(),
 			headers: {
 				"Content-Type": "application/json",
 			},
@@ -201,9 +204,9 @@ test.skip("rows changed on the server more recently should be updated on the cli
 	global.fetch = vi.fn((request) => lspHandler(request));
 
 	// 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 toBlob({ lix: remoteLix }),
+	const remoteLix = await openLix({});
+	const localLix = await openLix({
+		blob: await remoteLix.toBlob(),
 	});
 
 	// insert mock data into server lix
@@ -246,7 +249,7 @@ test.skip("rows changed on the server more recently should be updated on the cli
 	await lspHandler(
 		new Request("http://localhost:3000/lsp/new-v1", {
 			method: "POST",
-			body: await toBlob({ lix: remoteLix }),
+			body: await remoteLix.toBlob(),
 			headers: {
 				"Content-Type": "application/json",
 			},
@@ -293,8 +296,8 @@ test.skip("rows changed on the server more recently should be updated on the cli
 	expect(mockKey).toEqual({ key: "mock-key", value: "mock-value" });
 });
 
-// test("it should handle files without syncing the data column", async () => {
-// 	const lix = await openLixInMemory({});
+// test.skip("it should handle files without syncing the data column", async () => {
+// 	const lix = await openLix({});
 
 // 	const { value: id } = await lix.db
 // 		.selectFrom("key_value")
@@ -340,8 +343,10 @@ test.skip("rows changed on the server more recently should be updated on the cli
 // 	]);
 // });
 
-test("non-conflicting changes from the server should for the same version should be applied", async () => {
-	const lix = await openLixInMemory({});
+// commented out for lix v0.5
+// sync needs overhaul after change set graph introduction
+test.skip("non-conflicting changes from the server should for the same version should be applied", async () => {
+	const lix = await openLix({});
 
 	const currentVersion = await lix.db
 		.selectFrom("current_version")
@@ -359,7 +364,7 @@ test("non-conflicting changes from the server should for the same version should
 
 	global.fetch = vi.fn((request) => lspHandler(request));
 
-	const lixOnServer = await openLixInMemory({ blob: await toBlob({ lix }) });
+	const lixOnServer = await openLix({ blob: await lix.toBlob() });
 
 	// insert data on the server that the client does not have yet
 	await lixOnServer.db
@@ -392,7 +397,7 @@ test("non-conflicting changes from the server should for the same version should
 	await lspHandler(
 		new Request("http://localhost:3000/lsp/new-v1", {
 			method: "POST",
-			body: await toBlob({ lix: lixOnServer }),
+			body: await lixOnServer.toBlob(),
 			headers: {
 				"Content-Type": "application/json",
 			},

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

@@ -1,7 +1,9 @@
+// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+// @ts-nocheck
+
 import type { Lix } from "../lix/open-lix.js";
-import type * as LixServerProtocol from "@lix-js/server-protocol-schema";
+import type * as LixServerProtocol from "../../../lix/server-protocol-schema/dist/schema.js";
 import { mergeTheirState, type VectorClock } from "./merge-state.js";
-import { applyChanges } from "../change/apply-changes.js";
 import type { Change } from "../database/schema.js";
 import { CompiledQuery } from "kysely";
 

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

@@ -1,20 +1,17 @@
 import { expect, test, vi } from "vitest";
 import { createServerProtocolHandler } from "../server-protocol-handler/create-server-protocol-handler.js";
-import { openLixInMemory } from "../lix/open-lix-in-memory.js";
+import { openLix } from "../lix/open-lix.js";
 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 { NewKeyValue } from "../key-value/database-schema.js";
-import { mockJsonSnapshot } from "../snapshot/mock-json-snapshot.js";
 import { pullFromServer } from "./pull-from-server.js";
 import { createLspInMemoryEnvironment } from "../server-protocol-handler/environment/create-in-memory-environment.js";
-import { toBlob } from "../lix/to-blob.js";
+import type { KeyValue } from "../key-value/schema.js";
+import type { Account } from "../account/schema.js";
 
-test("push rows of multiple tables to server successfully", async () => {
+test.skip("push rows of multiple tables to server successfully", async () => {
 	const lixBlob = await newLixFile();
 
-	const lix = await openLixInMemory({ blob: lixBlob });
+	const lix = await openLix({ blob: lixBlob });
 
 	const id = await lix.db
 		.selectFrom("key_value")
@@ -31,7 +28,7 @@ test("push rows of multiple tables to server successfully", async () => {
 	await lspHandler(
 		new Request("http://localhost:3000/lsp/new-v1", {
 			method: "POST",
-			body: await toBlob({ lix }),
+			body: await lix.toBlob(),
 		})
 	);
 
@@ -66,7 +63,6 @@ test("push rows of multiple tables to server successfully", async () => {
 
 	const keyValueChangesOnServer = await openOnServer.lix.db
 		.selectFrom("change")
-		.innerJoin("snapshot", "change.snapshot_id", "snapshot.id")
 		.where("schema_key", "=", "lix_key_value_table")
 		.where("entity_id", "=", "mock-key")
 		.selectAll()
@@ -74,28 +70,29 @@ test("push rows of multiple tables to server successfully", async () => {
 
 	const accountsChangesOnServer = await openOnServer.lix.db
 		.selectFrom("change")
-		.innerJoin("snapshot", "change.snapshot_id", "snapshot.id")
 		.where("schema_key", "=", "lix_account_table")
 		.where("entity_id", "=", "account0")
 		.selectAll()
 		.execute();
 
-	expect(accountsChangesOnServer.map((c) => c.content)).toEqual([
+	expect(accountsChangesOnServer.map((c) => c.snapshot_content)).toEqual([
 		{ id: "account0", name: "some account" } satisfies Account,
 	]);
-	expect(keyValueChangesOnServer.map((c) => c.content)).toEqual([
+	expect(keyValueChangesOnServer.map((c) => c.snapshot_content)).toEqual([
 		expect.objectContaining({
 			key: "mock-key",
 			value: "mock-value",
 		}),
-	] satisfies NewKeyValue[]);
+	] satisfies Account[]);
 });
 
-test("push-pull-push with two clients", async () => {
+// commented out for lix v0.5
+// sync needs overhaul after change set graph introduction
+test.skip("push-pull-push with two clients", async () => {
 	const lixBlob = await newLixFile();
 
-	const client1 = await openLixInMemory({ blob: lixBlob });
-	const client2 = await openLixInMemory({ blob: lixBlob });
+	const client1 = await openLix({ blob: lixBlob });
+	const client2 = await openLix({ blob: lixBlob });
 
 	const { value: lixId } = await client1.db
 		.selectFrom("key_value")
@@ -112,7 +109,7 @@ test("push-pull-push with two clients", async () => {
 	await lspHandler(
 		new Request("http://localhost:3000/lsp/new-v1", {
 			method: "POST",
-			body: await toBlob({ lix: client1 }),
+			body: await client1.toBlob(),
 		})
 	);
 
@@ -169,7 +166,7 @@ test("push-pull-push with two clients", async () => {
 			expect.objectContaining({
 				key: "mock-key",
 				value: "mock-value from client 1",
-			} satisfies NewKeyValue),
+			} satisfies KeyValue),
 		])
 	);
 
@@ -209,12 +206,11 @@ test("push-pull-push with two clients", async () => {
 
 	const accountsChangesOnServer = await openOnServer.lix.db
 		.selectFrom("change")
-		.innerJoin("snapshot", "change.snapshot_id", "snapshot.id")
 		.where("schema_key", "=", "lix_account_table")
 		.selectAll()
 		.execute();
 
-	expect(accountsChangesOnServer.map((c) => c.content)).toEqual(
+	expect(accountsChangesOnServer.map((c) => c.snapshot_content)).toEqual(
 		expect.arrayContaining([
 			{ id: "account0", name: "account from client 1" },
 			{ id: "account1", name: "account from client 2" },
@@ -229,7 +225,6 @@ test("push-pull-push with two clients", async () => {
 
 	const accountChangesOnClient1 = await client1.db
 		.selectFrom("change")
-		.innerJoin("snapshot", "change.snapshot_id", "snapshot.id")
 		.where("schema_key", "=", "lix_account_table")
 		.selectAll()
 		.execute();
@@ -245,7 +240,6 @@ test("push-pull-push with two clients", async () => {
 
 	const accountChangesOnClient2 = await client2.db
 		.selectFrom("change")
-		.innerJoin("snapshot", "change.snapshot_id", "snapshot.id")
 		.where("schema_key", "=", "lix_account_table")
 		.selectAll()
 		.execute();
@@ -254,12 +248,11 @@ test("push-pull-push with two clients", async () => {
 
 	const keyValueChangesOnServer = await openOnServer.lix.db
 		.selectFrom("change")
-		.innerJoin("snapshot", "change.snapshot_id", "snapshot.id")
 		.where("schema_key", "=", "lix_key_value_table")
 		.selectAll()
 		.execute();
 
-	expect(keyValueChangesOnServer.map((c) => c.content)).toEqual(
+	expect(keyValueChangesOnServer.map((c) => c.snapshot_content)).toEqual(
 		expect.arrayContaining([
 			expect.objectContaining({
 				key: "mock-key",
@@ -277,62 +270,65 @@ test("push-pull-push with two clients", async () => {
 	);
 });
 
-test("it should handle snapshots.content json binaries", async () => {
-	const lix = await openLixInMemory({});
-
-	const { value: id } = await lix.db
-		.selectFrom("key_value")
-		.where("key", "=", "lix_id")
-		.selectAll()
-		.executeTakeFirstOrThrow();
-
-	const environment = createLspInMemoryEnvironment();
-	const lspHandler = await createServerProtocolHandler({ environment });
-
-	global.fetch = vi.fn((request) => lspHandler(request));
-
-	// initialize the lix on the server
-	await lspHandler(
-		new Request("http://localhost:3000/lsp/new-v1", {
-			method: "POST",
-			body: await toBlob({ lix }),
-		})
-	);
-
-	const mockSnapshot = mockJsonSnapshot({
-		location: "Berlin",
-	});
-
-	// insert a snapshot
-	await lix.db
-		.insertInto("snapshot")
-		.values({
-			content: mockSnapshot.content,
-		})
-		.execute();
-
-	await pushToServer({
-		id,
-		lix,
-		serverUrl: "http://localhost:3000",
-		targetVectorClock: [],
-	});
-
-	const openOnServer = await environment.openLix({ id });
-
-	const snapshot = await openOnServer.lix.db
-		.selectFrom("snapshot")
-		.where("id", "=", mockSnapshot.id)
-		.selectAll()
-		.executeTakeFirst();
-
-	expect(snapshot).toMatchObject(mockSnapshot);
-});
+// test.skip("it should handle snapshots.content json binaries", async () => {
+// 	const lix = await openLix({});
+
+// 	const { value: id } = await lix.db
+// 		.selectFrom("key_value")
+// 		.where("key", "=", "lix_id")
+// 		.selectAll()
+// 		.executeTakeFirstOrThrow();
+
+// 	const environment = createLspInMemoryEnvironment();
+// 	const lspHandler = await createServerProtocolHandler({ environment });
+
+// 	global.fetch = vi.fn((request) => lspHandler(request));
+
+// 	// initialize the lix on the server
+// 	await lspHandler(
+// 		new Request("http://localhost:3000/lsp/new-v1", {
+// 			method: "POST",
+// 			body: await lix.toBlob(),
+// 		})
+// 	);
+
+// 	const mockSnapshot = {
+// 		id: "snapshot0",
+// 		content: {
+// 			location: "Berlin",
+// 		},
+// 	};
+
+// 	// insert a snapshot
+// 	await lix.db
+// 		.insertInto("snapshot")
+// 		.values({
+// 			content: mockSnapshot.content,
+// 		})
+// 		.execute();
+
+// 	await pushToServer({
+// 		id,
+// 		lix,
+// 		serverUrl: "http://localhost:3000",
+// 		targetVectorClock: [],
+// 	});
+
+// 	const openOnServer = await environment.openLix({ id });
+
+// 	const snapshot = await openOnServer.lix.db
+// 		.selectFrom("snapshot")
+// 		.where("id", "=", mockSnapshot.id)
+// 		.selectAll()
+// 		.executeTakeFirst();
+
+// 	expect(snapshot).toMatchObject(mockSnapshot);
+// });
 
 test.todo("it should handle binary values", async () => {
 	const lixBlob = await newLixFile();
 
-	const lix = await openLixInMemory({ blob: lixBlob });
+	const lix = await openLix({ blob: lixBlob });
 
 	const { value: id } = await lix.db
 		.selectFrom("key_value")
@@ -349,7 +345,7 @@ test.todo("it should handle binary values", async () => {
 	await lspHandler(
 		new Request("http://localhost:3000/lsp/new", {
 			method: "POST",
-			body: await toBlob({ lix }),
+			body: await lix.toBlob(),
 		})
 	);
 
@@ -370,8 +366,8 @@ test.todo("it should handle binary values", async () => {
 		targetVectorClock: [], // initial push - server has no state
 	});
 
-	const lixFromServer = await openLixInMemory({
-		blob: await environment.get(`lix-file-${id}`),
+	const lixFromServer = await openLix({
+		blob: await environment.getLix({ id }),
 	});
 
 	const filesOnServer = await lixFromServer.db
@@ -386,6 +382,6 @@ test.todo("it should handle binary values", async () => {
 			path: "/hello.txt",
 			metadata: null,
 			data: new TextEncoder().encode("Hello, World!"),
-		} satisfies LixFile,
+		},
 	]);
 });

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

@@ -1,10 +1,19 @@
-import type * as LixServerProtocol from "@lix-js/server-protocol-schema";
+import type * as LixServerProtocol from "../../../lix/server-protocol-schema/dist/schema.js";
 import type { Lix } from "../lix/open-lix.js";
 import type { VectorClock } from "./merge-state.js";
 import { getDiffingRows } from "./get-diffing-rows.js";
 
 /**
- * Pushes rows to the server.
+ * Pushes local changes to a Lix server.
+ *
+ * Only rows unknown to the server are transmitted based on the provided
+ * vector clock. An error is thrown when the server responds with a non
+ * successful status.
+ *
+ * @example
+ * ```ts
+ * await pushToServer({ id, serverUrl, lix, targetVectorClock })
+ * ```
  */
 export async function pushToServer(args: {
 	id: string;

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

@@ -1,22 +1,23 @@
+// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+// @ts-nocheck
+
 import { test, expect, vi } from "vitest";
-import { openLixInMemory } from "../lix/open-lix-in-memory.js";
+import { openLix } from "../lix/open-lix.js";
 import {
 	createLspInMemoryEnvironment,
 	createServerProtocolHandler,
 } from "../server-protocol-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 () => {
+// commented out for lix v0.5
+// sync needs overhaul after change set graph introduction
+test.skip("versions should be synced", async () => {
 	const environment = createLspInMemoryEnvironment();
 	const lspHandler = await createServerProtocolHandler({ environment });
 
 	global.fetch = vi.fn((request) => lspHandler(request));
 
-	const lix0 = await openLixInMemory({
+	const lix0 = await openLix({
 		keyValues: [{ key: "lix_server_url", value: "http://mock.com" }],
 	});
 
@@ -33,13 +34,13 @@ test("versions should be synced", async () => {
 	await lspHandler(
 		new Request("http://mock.com/lsp/new-v1", {
 			method: "POST",
-			body: await toBlob({ lix: lix0 }),
+			body: await lix0.toBlob(),
 		})
 	);
 
 	// create a second client
-	const lix1 = await openLixInMemory({
-		blob: await toBlob({ lix: lix0 }),
+	const lix1 = await openLix({
+		blob: await lix0.toBlob(),
 		keyValues: [{ key: "lix_sync", value: "true" }],
 	});
 
@@ -125,7 +126,9 @@ test("versions should be synced", async () => {
 	expect(lix0VersionChanges).toEqual(lix1VersionChanges);
 });
 
-test("switching synced versions should work", async () => {
+// commented out for lix v0.5
+// sync needs overhaul after change set graph introduction
+test.skip("switching synced versions should work", async () => {
 	const environment = createLspInMemoryEnvironment();
 	const lspHandler = await createServerProtocolHandler({ environment });
 
@@ -133,7 +136,7 @@ test("switching synced versions should work", async () => {
 	// @ts-expect-error - eases debugging
 	global.executeSync = executeSync;
 
-	const lix0 = await openLixInMemory({
+	const lix0 = await openLix({
 		keyValues: [{ key: "lix_sync", value: "true" }],
 	});
 	// @ts-expect-error - eases debugging
@@ -151,7 +154,7 @@ test("switching synced versions should work", async () => {
 	await lspHandler(
 		new Request("http://mock.com/lsp/new-v1", {
 			method: "POST",
-			body: await toBlob({ lix: lix0 }),
+			body: await lix0.toBlob(),
 		})
 	);
 
@@ -165,8 +168,8 @@ test("switching synced versions should work", async () => {
 		.execute();
 
 	// create a second client
-	const lix1 = await openLixInMemory({
-		blob: await toBlob({ lix: lix0 }),
+	const lix1 = await openLix({
+		blob: await lix0.toBlob(),
 		keyValues: [{ key: "lix_sync", value: "true" }],
 	});
 
@@ -242,12 +245,12 @@ test("switching synced versions should work", async () => {
 	});
 });
 
-test("doesnt sync if lix_sync is not true", async () => {
+test.skip("doesnt sync if lix_sync is not true", async () => {
 	const environment = createLspInMemoryEnvironment();
 	const lspHandler = await createServerProtocolHandler({ environment });
 	global.fetch = vi.fn((request) => lspHandler(request));
 
-	const lix = await openLixInMemory({});
+	const lix = await openLix({});
 
 	const lixId = await lix.db
 		.selectFrom("key_value")
@@ -259,7 +262,7 @@ test("doesnt sync if lix_sync is not true", async () => {
 	await lspHandler(
 		new Request("http://mock.com/lsp/new-v1", {
 			method: "POST",
-			body: await toBlob({ lix }),
+			body: await lix.toBlob(),
 		})
 	);
 

package/src/sync/sync-process.ts

@@ -1,10 +1,9 @@
 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">;
+	lix: Pick<Lix, "db" | "plugin" | "sqlite" | "toBlob">;
 }): Promise<void> {
 	const lixId = await args.lix.db
 		.selectFrom("key_value")
@@ -57,7 +56,7 @@ export async function initSyncProcess(args: {
 			const response = await fetch(
 				new Request(`${url.value}/lsp/new-v1`, {
 					method: "POST",
-					body: await toBlob({ lix: args.lix }),
+					body: await args.lix.toBlob(),
 				})
 			);
 			if (!response.ok && response.status !== 409) {

package/src/thread/create-thread-comment.test.ts

@@ -0,0 +1,63 @@
+import { test, expect } from "vitest";
+import { createThreadComment } from "./create-thread-comment.js";
+import { openLix } from "../lix/open-lix.js";
+import { fromPlainText } from "@opral/zettel-ast";
+import { nanoid } from "../database/nano-id.js";
+
+test("creates a thread comment", async () => {
+	const lix = await openLix({});
+
+	const threadId = nanoid();
+	await lix.db.insertInto("thread").values({ id: threadId }).execute();
+
+	const thread = await lix.db
+		.selectFrom("thread")
+		.selectAll()
+		.where("id", "=", threadId)
+		.executeTakeFirstOrThrow();
+
+	const threadComment = await createThreadComment({
+		lix,
+		thread_id: thread.id,
+		body: fromPlainText("Hello world  "),
+	});
+
+	expect(threadComment).toBeDefined();
+});
+
+test("defaults to the version of the thread", async () => {
+	const lix = await openLix({});
+
+	const threadId = nanoid();
+	await lix.db.insertInto("thread").values({ id: threadId }).execute();
+
+	const activeVersionScopedThread = await lix.db
+		.selectFrom("thread")
+		.selectAll()
+		.where("id", "=", threadId)
+		.executeTakeFirstOrThrow();
+
+	const threadComment = await createThreadComment({
+		lix,
+		thread_id: activeVersionScopedThread.id,
+		body: fromPlainText("Hello world  "),
+	});
+
+	expect(threadComment).toBeDefined();
+
+	await lix.db
+		.insertInto("thread_all")
+		.values({
+			id: "global-thread",
+			lixcol_version_id: "global",
+		})
+		.execute();
+
+	const globalThreadComment = await createThreadComment({
+		lix,
+		thread_id: "global-thread",
+		body: fromPlainText("Hello global world  "),
+	});
+
+	expect(globalThreadComment).toBeDefined();
+});