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

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

@@ -2,12 +2,12 @@ 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";
+import { nanoId } from "../deterministic/index.js";
 
 test("creates a thread comment", async () => {
 	const lix = await openLix({});
 
-	const threadId = nanoid();
+	const threadId = nanoId({ lix });
 	await lix.db.insertInto("thread").values({ id: threadId }).execute();
 
 	const thread = await lix.db
@@ -28,7 +28,7 @@ test("creates a thread comment", async () => {
 test("defaults to the version of the thread", async () => {
 	const lix = await openLix({});
 
-	const threadId = nanoid();
+	const threadId = nanoId({ lix });
 	await lix.db.insertInto("thread").values({ id: threadId }).execute();
 
 	const activeVersionScopedThread = await lix.db
@@ -61,3 +61,62 @@ test("defaults to the version of the thread", async () => {
 
 	expect(globalThreadComment).toBeDefined();
 });
+
+test("defaults parent_id to the last comment when not provided", async () => {
+	const lix = await openLix({});
+
+	const threadId = nanoId({ lix });
+	await lix.db.insertInto("thread").values({ id: threadId }).execute();
+
+	const thread = await lix.db
+		.selectFrom("thread")
+		.selectAll()
+		.where("id", "=", threadId)
+		.executeTakeFirstOrThrow();
+
+	// Create first comment (should have parent_id = null)
+	const firstComment = await createThreadComment({
+		lix,
+		thread_id: thread.id,
+		body: fromPlainText("First comment"),
+	});
+
+	expect(firstComment.parent_id).toBeNull();
+
+	// Create second comment without parent_id (should default to first comment)
+	const secondComment = await createThreadComment({
+		lix,
+		thread_id: thread.id,
+		body: fromPlainText("Second comment"),
+	});
+
+	expect(secondComment.parent_id).toBe(firstComment.id);
+
+	// Create third comment without parent_id (should default to second comment)
+	const thirdComment = await createThreadComment({
+		lix,
+		thread_id: thread.id,
+		body: fromPlainText("Third comment"),
+	});
+
+	expect(thirdComment.parent_id).toBe(secondComment.id);
+
+	// Create fourth comment with explicit parent_id (should use provided parent_id)
+	const fourthComment = await createThreadComment({
+		lix,
+		thread_id: thread.id,
+		body: fromPlainText("Fourth comment"),
+		parent_id: firstComment.id,
+	});
+
+	expect(fourthComment.parent_id).toBe(firstComment.id);
+
+	// Create fifth comment without parent_id (should default to third comment, which is still the leaf)
+	const fifthComment = await createThreadComment({
+		lix,
+		thread_id: thread.id,
+		body: fromPlainText("Fifth comment"),
+	});
+
+	expect(fifthComment.parent_id).toBe(thirdComment.id);
+});

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

@@ -1,7 +1,7 @@
 import type { Lix } from "../lix/open-lix.js";
-import { nanoid } from "../database/nano-id.js";
+import { nanoId } from "../deterministic/index.js";
 import type { NewState, State } from "../entity-views/types.js";
-import type { ThreadComment } from "./schema.js";
+import type { LixThreadComment } from "./schema.js";
 
 /**
  * Adds a comment to an existing thread.
@@ -16,10 +16,10 @@ import type { ThreadComment } from "./schema.js";
  */
 
 export async function createThreadComment(
-	args: { lix: Lix } & NewState<ThreadComment>
-): Promise<State<ThreadComment>> {
+	args: { lix: Lix } & NewState<LixThreadComment>
+): Promise<State<LixThreadComment>> {
 	const executeInTransaction = async (trx: Lix["db"]) => {
-		const commentId = args.id ?? nanoid();
+		const commentId = args.id ?? nanoId({ lix: args.lix });
 
 		const existingThread = await trx
 			.selectFrom("thread_all")
@@ -29,13 +29,41 @@ export async function createThreadComment(
 			.select("lixcol_version_id")
 			.executeTakeFirstOrThrow();
 
+		// If parent_id is not provided, find the leaf comment using SQL traversal
+		let parentId = args.parent_id;
+		if (parentId === undefined) {
+			const leafComment = await trx
+				.selectFrom("thread_comment_all as c1")
+				.where("c1.thread_id", "=", args.thread_id)
+				.where("c1.lixcol_version_id", "=", existingThread.lixcol_version_id)
+				.where((eb) =>
+					eb.not(
+						eb.exists(
+							eb
+								.selectFrom("thread_comment_all as c2")
+								.where("c2.thread_id", "=", args.thread_id)
+								.where(
+									"c2.lixcol_version_id",
+									"=",
+									existingThread.lixcol_version_id
+								)
+								.whereRef("c2.parent_id", "=", "c1.id")
+								.select("c2.id")
+						)
+					)
+				)
+				.select("c1.id")
+				.executeTakeFirst();
+			parentId = leafComment?.id ?? null;
+		}
+
 		await trx
 			.insertInto("thread_comment_all")
 			.values({
 				id: commentId,
 				thread_id: args.thread_id,
 				body: args.body,
-				parent_id: args.parent_id,
+				parent_id: parentId,
 				lixcol_version_id: existingThread.lixcol_version_id,
 			})
 			.execute();

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

@@ -2,6 +2,7 @@ import { expect, test } from "vitest";
 import { createThread } from "./create-thread.js";
 import { openLix } from "../lix/open-lix.js";
 import { fromPlainText } from "@opral/zettel-ast";
+import { ebEntity } from "../entity/eb-entity.js";
 
 test("creates a thread with sequential comments where only the first has null parent_id", async () => {
 	const lix = await openLix({});
@@ -30,3 +31,182 @@ test("defaults to global version if no versionId is provided", async () => {
 	expect(threadWithComments.lixcol_version_id).toBe("global");
 	expect(threadWithComments.comments[0]!.lixcol_version_id).toBe("global");
 });
+
+test("creates a thread with entity mapping when entity is provided", async () => {
+	const lix = await openLix({});
+
+	// Create a key-value entity
+	await lix.db
+		.insertInto("key_value_all")
+		.values({
+			key: "test-entity-config",
+			value: { setting: "entityvalue" },
+			lixcol_version_id: "global",
+		})
+		.execute();
+
+	const keyValue = await lix.db
+		.selectFrom("key_value")
+		.where("key", "=", "test-entity-config")
+		.selectAll()
+		.executeTakeFirstOrThrow();
+
+	const comments = [{ body: fromPlainText("Comment on entity") }];
+
+	// Create thread with entity
+	const threadWithComments = await createThread({
+		lix,
+		comments,
+		entity: keyValue,
+	});
+
+	// Verify thread was created
+	expect(threadWithComments.id).toBeDefined();
+	expect(threadWithComments.comments).toHaveLength(1);
+
+	// Verify entity-thread mapping was created
+	const mapping = await lix.db
+		.selectFrom("entity_thread")
+		.where("entity_id", "=", keyValue.key)
+		.where("schema_key", "=", "lix_key_value")
+		.where("file_id", "=", "lix")
+		.where("thread_id", "=", threadWithComments.id)
+		.selectAll()
+		.executeTakeFirst();
+
+	expect(mapping).toBeDefined();
+	expect(mapping?.thread_id).toBe(threadWithComments.id);
+});
+
+test("creates a thread without entity mapping when entity is not provided", async () => {
+	const lix = await openLix({});
+
+	const comments = [{ body: fromPlainText("Standalone comment") }];
+
+	// Create thread without entity
+	const threadWithComments = await createThread({ lix, comments });
+
+	// Verify thread was created
+	expect(threadWithComments.id).toBeDefined();
+
+	// Verify no entity-thread mapping exists
+	const mappings = await lix.db
+		.selectFrom("entity_thread")
+		.where("thread_id", "=", threadWithComments.id)
+		.selectAll()
+		.execute();
+
+	expect(mappings).toHaveLength(0);
+});
+
+test("can query threads for a specific entity using ebEntity", async () => {
+	const lix = await openLix({});
+
+	// Create a key-value entity
+	await lix.db
+		.insertInto("key_value_all")
+		.values({
+			key: "query-test-config",
+			value: { setting: "queryvalue" },
+			lixcol_version_id: "global",
+		})
+		.execute();
+
+	const keyValue = await lix.db
+		.selectFrom("key_value")
+		.where("key", "=", "query-test-config")
+		.selectAll()
+		.executeTakeFirstOrThrow();
+
+	// Create multiple threads for the entity
+	const thread1 = await createThread({
+		lix,
+		comments: [{ body: fromPlainText("First thread") }],
+		entity: keyValue,
+	});
+
+	const thread2 = await createThread({
+		lix,
+		comments: [{ body: fromPlainText("Second thread") }],
+		entity: keyValue,
+	});
+
+	// Create a thread for a different entity
+	await lix.db
+		.insertInto("key_value_all")
+		.values({
+			key: "other-config",
+			value: { setting: "othervalue" },
+			lixcol_version_id: "global",
+		})
+		.execute();
+
+	const otherKeyValue = await lix.db
+		.selectFrom("key_value")
+		.where("key", "=", "other-config")
+		.selectAll()
+		.executeTakeFirstOrThrow();
+
+	await createThread({
+		lix,
+		comments: [{ body: fromPlainText("Other thread") }],
+		entity: otherKeyValue,
+	});
+
+	// Query threads for the specific entity using ebEntity
+	const threads = await lix.db
+		.selectFrom("thread")
+		.innerJoin("entity_thread", "entity_thread.thread_id", "thread.id")
+		.where(ebEntity("entity_thread").equals(keyValue))
+		.select(["thread.id"])
+		.execute();
+
+	expect(threads).toHaveLength(2);
+	expect(threads.map((t) => t.id)).toContain(thread1.id);
+	expect(threads.map((t) => t.id)).toContain(thread2.id);
+});
+
+test("works with lixcol_ prefixed entity fields", async () => {
+	const lix = await openLix({});
+
+	// Create a key-value entity
+	await lix.db
+		.insertInto("key_value_all")
+		.values({
+			key: "lixcol-test-config",
+			value: { setting: "lixcolvalue" },
+			lixcol_version_id: "global",
+		})
+		.execute();
+
+	// Get the key-value from state view (which has lixcol_ prefixed fields)
+	const stateEntity = await lix.db
+		.selectFrom("state")
+		.where("entity_id", "=", "lixcol-test-config")
+		.where("schema_key", "=", "lix_key_value")
+		.where("file_id", "=", "lix")
+		.selectAll()
+		.executeTakeFirstOrThrow();
+
+	const comments = [{ body: fromPlainText("Comment with lixcol fields") }];
+
+	// Create thread with entity object from state view
+	const threadWithComments = await createThread({
+		lix,
+		comments,
+		entity: stateEntity,
+	});
+
+	// Verify entity-thread mapping was created
+	const mapping = await lix.db
+		.selectFrom("entity_thread")
+		.where("entity_id", "=", "lixcol-test-config")
+		.where("schema_key", "=", "lix_key_value")
+		.where("file_id", "=", "lix")
+		.where("thread_id", "=", threadWithComments.id)
+		.selectAll()
+		.executeTakeFirst();
+
+	expect(mapping).toBeDefined();
+	expect(mapping?.thread_id).toBe(threadWithComments.id);
+});

package/src/thread/create-thread.ts

@@ -1,7 +1,9 @@
 import type { Lix } from "../lix/open-lix.js";
-import type { Thread, ThreadComment } from "./schema.js";
-import { nanoid } from "../database/nano-id.js";
+import type { LixThread, LixThreadComment } from "./schema.js";
+import { nanoId } from "../deterministic/index.js";
 import type { NewState } from "../entity-views/types.js";
+import type { LixEntity, LixEntityCanonical } from "../entity/schema.js";
+import { createEntityThread } from "../entity/thread/create-entity-thread.js";
 
 /**
  * Starts a new discussion thread.
@@ -12,26 +14,39 @@ import type { NewState } from "../entity-views/types.js";
  *
  * @example
  * ```ts
+ * // Create a standalone thread
  * const thread = await createThread({ lix, comments: [{ body: "Hello" }] })
  * ```
+ *
+ * @example
+ * ```ts
+ * // Create a thread attached to an entity
+ * const thread = await createThread({
+ *   lix,
+ *   entity: { entity_id: "para_123", schema_key: "markdown_paragraph", file_id: "README.md" },
+ *   comments: [{ body: "This paragraph needs review" }]
+ * })
+ * ```
  */
 
 export async function createThread(args: {
 	lix: Lix;
 	id?: string;
-	comments?: Pick<NewState<ThreadComment>, "body">[];
+	comments?: Pick<NewState<LixThreadComment>, "body">[];
 	/** defaults to global */
 	versionId?: string;
+	/** Optional entity to attach the thread to */
+	entity?: LixEntity | LixEntityCanonical;
 }): Promise<
-	Thread & {
+	LixThread & {
 		lixcol_version_id: string;
-		comments: (ThreadComment & {
+		comments: (LixThreadComment & {
 			lixcol_version_id: string;
 		})[];
 	}
 > {
 	const executeInTransaction = async (trx: Lix["db"]) => {
-		const threadId = args.id ?? nanoid();
+		const threadId = args.id ?? nanoId({ lix: args.lix });
 		const versionId = args.versionId ?? "global";
 
 		await trx
@@ -49,7 +64,7 @@ export async function createThread(args: {
 		const insertedComments = [];
 
 		for (const [index, comment] of (args.comments ?? []).entries()) {
-			const commentId = nanoid();
+			const commentId = nanoId({ lix: args.lix });
 
 			await trx
 				.insertInto("thread_comment_all")
@@ -72,6 +87,16 @@ export async function createThread(args: {
 			insertedComments.push(insertedComment);
 		}
 
+		// If an entity is provided, create the entity-thread mapping
+		if (args.entity) {
+			await createEntityThread({
+				lix: { db: trx },
+				entity: args.entity,
+				thread: { id: threadId },
+				versionId: versionId,
+			});
+		}
+
 		return { ...thread, comments: insertedComments };
 	};
 

package/src/thread/index.ts

@@ -1,8 +1,9 @@
 export {
 	LixThreadSchema,
 	LixThreadCommentSchema,
-	type Thread,
-	type ThreadComment,
+	type LixThread as Thread,
+	type LixThreadComment as ThreadComment,
 } from "./schema.js";
 export { createThread } from "./create-thread.js";
 export { createThreadComment } from "./create-thread-comment.js";
+export type { LixEntityThread } from "../entity/thread/schema.js";

package/src/thread/schema.test.ts

@@ -1,6 +1,7 @@
 import { expect, test } from "vitest";
 import { openLix } from "../lix/open-lix.js";
 import { fromPlainText } from "@opral/zettel-ast";
+import { switchAccount } from "../account/switch-account.js";
 
 test("thread.id should default to nano_id", async () => {
 	const lix = await openLix({});
@@ -74,3 +75,83 @@ test("valid thread comment content should pass", async () => {
 
 	expect(comment).toBeDefined();
 });
+
+test("creating a thread should create a change author", async () => {
+	const lix = await openLix({});
+
+	// Create an account first
+	await lix.db
+		.insertInto("account")
+		.values({
+			id: "test-account",
+			name: "Test User",
+		})
+		.execute();
+
+	// Switch to the test account
+	await switchAccount({ lix, to: [{ id: "test-account", name: "Test User" }] });
+
+	await lix.db.insertInto("thread").defaultValues().execute();
+
+	const thread = await lix.db
+		.selectFrom("thread")
+		.selectAll()
+		.executeTakeFirstOrThrow();
+
+	// Check that a change author was created for the thread
+	const threadChangeAuthor = await lix.db
+		.selectFrom("change_author")
+		.where("change_author.change_id", "=", thread.lixcol_change_id)
+		.selectAll()
+		.executeTakeFirstOrThrow();
+
+	expect(threadChangeAuthor).toBeDefined();
+	expect(threadChangeAuthor.account_id).toBe("test-account");
+});
+
+test("creating a thread comment should create a change author", async () => {
+	const lix = await openLix({});
+
+	// Create an account first
+	await lix.db
+		.insertInto("account")
+		.values({
+			id: "test-account",
+			name: "Test User",
+		})
+		.execute();
+
+	// Switch to the test account
+	await switchAccount({ lix, to: [{ id: "test-account", name: "Test User" }] });
+
+	await lix.db.insertInto("thread").defaultValues().execute();
+
+	const thread = await lix.db
+		.selectFrom("thread")
+		.selectAll()
+		.executeTakeFirstOrThrow();
+
+	await lix.db
+		.insertInto("thread_comment")
+		.values({
+			thread_id: thread.id,
+			parent_id: null,
+			body: fromPlainText("Test comment"),
+		})
+		.execute();
+
+	const comment = await lix.db
+		.selectFrom("thread_comment")
+		.selectAll()
+		.executeTakeFirstOrThrow();
+
+	// Check that a change author was created for the comment
+	const commentChangeAuthor = await lix.db
+		.selectFrom("change_author")
+		.where("change_author.change_id", "=", comment.lixcol_change_id)
+		.selectAll()
+		.executeTakeFirstOrThrow();
+
+	expect(commentChangeAuthor).toBeDefined();
+	expect(commentChangeAuthor.account_id).toBe("test-account");
+});

package/src/thread/schema.ts

@@ -1,39 +1,38 @@
-import type { SqliteWasmDatabase } from "sqlite-wasm-kysely";
 import type {
 	LixSchemaDefinition,
 	FromLixSchemaDefinition,
 } from "../schema-definition/definition.js";
 import { ZettelDocJsonSchema, type ZettelDoc } from "@opral/zettel-ast";
 import { createEntityViewsIfNotExists } from "../entity-views/entity-view-builder.js";
+import { nanoId } from "../deterministic/index.js";
+import type { Lix } from "../lix/open-lix.js";
 
 export function applyThreadDatabaseSchema(
-	sqlite: SqliteWasmDatabase
-): SqliteWasmDatabase {
+	lix: Pick<Lix, "sqlite" | "db">
+): void {
 	// Create both primary and _all views for thread with default ID generation
 	createEntityViewsIfNotExists({
-		lix: { sqlite },
+		lix,
 		schema: LixThreadSchema,
 		overrideName: "thread",
 		pluginKey: "lix_own_entity",
 		hardcodedFileId: "lix",
 		defaultValues: {
-			id: () => "nano_id()",
+			id: () => nanoId({ lix }),
 		},
 	});
 
 	// Create both primary and _all views for thread_comment with default ID generation
 	createEntityViewsIfNotExists({
-		lix: { sqlite },
+		lix,
 		schema: LixThreadCommentSchema,
 		overrideName: "thread_comment",
 		pluginKey: "lix_own_entity",
 		hardcodedFileId: "lix",
 		defaultValues: {
-			id: () => "nano_id()",
+			id: () => nanoId({ lix }),
 		},
 	});
-
-	return sqlite;
 }
 
 export const LixThreadSchema = {
@@ -54,16 +53,22 @@ export const LixThreadCommentSchema = {
 	"x-lix-key": "lix_thread_comment",
 	"x-lix-version": "1.0",
 	"x-lix-primary-key": ["id"],
-	"x-lix-foreign-keys": {
-		thread_id: {
-			schemaKey: "lix_thread",
-			property: "id",
+	"x-lix-foreign-keys": [
+		{
+			properties: ["thread_id"],
+			references: {
+				schemaKey: "lix_thread",
+				properties: ["id"],
+			},
 		},
-		parent_id: {
-			schemaKey: "lix_thread_comment",
-			property: "id",
+		{
+			properties: ["parent_id"],
+			references: {
+				schemaKey: "lix_thread_comment",
+				properties: ["id"],
+			},
 		},
-	},
+	],
 	type: "object",
 	properties: {
 		id: { type: "string", "x-lix-generated": true },
@@ -77,8 +82,8 @@ export const LixThreadCommentSchema = {
 LixThreadCommentSchema satisfies LixSchemaDefinition;
 
 // Business logic types with LixGenerated markers
-export type Thread = FromLixSchemaDefinition<typeof LixThreadSchema>;
-export type ThreadComment = FromLixSchemaDefinition<
+export type LixThread = FromLixSchemaDefinition<typeof LixThreadSchema>;
+export type LixThreadComment = FromLixSchemaDefinition<
 	typeof LixThreadCommentSchema
 > & {
 	body: ZettelDoc; // Override the body type