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

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

@@ -0,0 +1,56 @@
+import type { Lix } from "../lix/open-lix.js";
+import { nanoid } from "../database/nano-id.js";
+import type { NewState, State } from "../entity-views/types.js";
+import type { ThreadComment } from "./schema.js";
+
+/**
+ * Adds a comment to an existing thread.
+ *
+ * The comment inherits the version context from the thread and can
+ * be nested by supplying a parent id.
+ *
+ * @example
+ * ```ts
+ * await createThreadComment({ lix, thread_id, body: "Thanks" })
+ * ```
+ */
+
+export async function createThreadComment(
+	args: { lix: Lix } & NewState<ThreadComment>
+): Promise<State<ThreadComment>> {
+	const executeInTransaction = async (trx: Lix["db"]) => {
+		const commentId = args.id ?? nanoid();
+
+		const existingThread = await trx
+			.selectFrom("thread_all")
+			.where("id", "=", args.thread_id)
+			// get the root thread version
+			.where("lixcol_inherited_from_version_id", "is", null)
+			.select("lixcol_version_id")
+			.executeTakeFirstOrThrow();
+
+		await trx
+			.insertInto("thread_comment_all")
+			.values({
+				id: commentId,
+				thread_id: args.thread_id,
+				body: args.body,
+				parent_id: args.parent_id,
+				lixcol_version_id: existingThread.lixcol_version_id,
+			})
+			.execute();
+
+		return await trx
+			.selectFrom("thread_comment_all")
+			.selectAll()
+			.where("id", "=", commentId)
+			.where("lixcol_version_id", "=", existingThread.lixcol_version_id)
+			.executeTakeFirstOrThrow();
+	};
+
+	if (args.lix.db.isTransaction) {
+		return await executeInTransaction(args.lix.db);
+	} else {
+		return await args.lix.db.transaction().execute(executeInTransaction);
+	}
+}

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

@@ -0,0 +1,32 @@
+import { expect, test } from "vitest";
+import { createThread } from "./create-thread.js";
+import { openLix } from "../lix/open-lix.js";
+import { fromPlainText } from "@opral/zettel-ast";
+
+test("creates a thread with sequential comments where only the first has null parent_id", async () => {
+	const lix = await openLix({});
+
+	const comments = [
+		{ body: fromPlainText("First comment") },
+		{ body: fromPlainText("Second comment") },
+		{ body: fromPlainText("Third comment") },
+	];
+
+	const threadWithComments = await createThread({ lix, comments });
+	const { comments: insertedComments } = threadWithComments;
+
+	expect(insertedComments).toHaveLength(3);
+	expect(insertedComments[0]!.parent_id).toBeNull();
+	expect(insertedComments[1]!.parent_id).toBe(insertedComments[0]!.id);
+	expect(insertedComments[2]!.parent_id).toBe(insertedComments[1]!.id);
+});
+
+test("defaults to global version if no versionId is provided", async () => {
+	const lix = await openLix({});
+
+	const comments = [{ body: fromPlainText("Global comment") }];
+
+	const threadWithComments = await createThread({ lix, comments });
+	expect(threadWithComments.lixcol_version_id).toBe("global");
+	expect(threadWithComments.comments[0]!.lixcol_version_id).toBe("global");
+});

package/src/thread/create-thread.ts

@@ -0,0 +1,83 @@
+import type { Lix } from "../lix/open-lix.js";
+import type { Thread, ThreadComment } from "./schema.js";
+import { nanoid } from "../database/nano-id.js";
+import type { NewState } from "../entity-views/types.js";
+
+/**
+ * Starts a new discussion thread.
+ *
+ * Threads allow collaborators to attach comments to a specific
+ * version or entity. Initial comments can be provided and will be
+ * inserted sequentially.
+ *
+ * @example
+ * ```ts
+ * const thread = await createThread({ lix, comments: [{ body: "Hello" }] })
+ * ```
+ */
+
+export async function createThread(args: {
+	lix: Lix;
+	id?: string;
+	comments?: Pick<NewState<ThreadComment>, "body">[];
+	/** defaults to global */
+	versionId?: string;
+}): Promise<
+	Thread & {
+		lixcol_version_id: string;
+		comments: (ThreadComment & {
+			lixcol_version_id: string;
+		})[];
+	}
+> {
+	const executeInTransaction = async (trx: Lix["db"]) => {
+		const threadId = args.id ?? nanoid();
+		const versionId = args.versionId ?? "global";
+
+		await trx
+			.insertInto("thread_all")
+			.values({ id: threadId, lixcol_version_id: versionId })
+			.execute();
+
+		const thread = await trx
+			.selectFrom("thread_all")
+			.selectAll()
+			.where("id", "=", threadId)
+			.where("lixcol_version_id", "=", versionId)
+			.executeTakeFirstOrThrow();
+
+		const insertedComments = [];
+
+		for (const [index, comment] of (args.comments ?? []).entries()) {
+			const commentId = nanoid();
+
+			await trx
+				.insertInto("thread_comment_all")
+				.values({
+					id: commentId,
+					thread_id: thread.id,
+					body: comment.body,
+					parent_id: index > 0 ? insertedComments[index - 1]!.id : null,
+					lixcol_version_id: versionId,
+				})
+				.execute();
+
+			const insertedComment = await trx
+				.selectFrom("thread_comment_all")
+				.selectAll()
+				.where("id", "=", commentId)
+				.where("lixcol_version_id", "=", versionId)
+				.executeTakeFirstOrThrow();
+
+			insertedComments.push(insertedComment);
+		}
+
+		return { ...thread, comments: insertedComments };
+	};
+
+	if (args.lix.db.isTransaction) {
+		return await executeInTransaction(args.lix.db);
+	} else {
+		return await args.lix.db.transaction().execute(executeInTransaction);
+	}
+}

package/src/thread/index.ts

@@ -0,0 +1,8 @@
+export {
+	LixThreadSchema,
+	LixThreadCommentSchema,
+	type Thread,
+	type ThreadComment,
+} from "./schema.js";
+export { createThread } from "./create-thread.js";
+export { createThreadComment } from "./create-thread-comment.js";

package/src/thread/schema.test.ts

@@ -0,0 +1,76 @@
+import { expect, test } from "vitest";
+import { openLix } from "../lix/open-lix.js";
+import { fromPlainText } from "@opral/zettel-ast";
+
+test("thread.id should default to nano_id", async () => {
+	const lix = await openLix({});
+
+	await lix.db.insertInto("thread").defaultValues().execute();
+
+	const result = await lix.db
+		.selectFrom("thread")
+		.selectAll()
+		.executeTakeFirstOrThrow();
+
+	expect(result.id).toBeDefined();
+});
+
+test("an invalid thread comment content should throw an error", async () => {
+	const lix = await openLix({});
+
+	await lix.db.insertInto("thread").defaultValues().execute();
+
+	const thread = await lix.db
+		.selectFrom("thread")
+		.selectAll()
+		.executeTakeFirstOrThrow();
+
+	await expect(
+		async () =>
+			await lix.db
+				.insertInto("thread_comment")
+				.values({
+					thread_id: thread.id,
+					parent_id: null,
+					body: {
+						type: "zettel_doc",
+						content: [
+							// @ts-expect-error - missing zettel_key prop
+							{
+								type: "zettel_text_block",
+								style: "zettel_normal",
+								children: [{ type: "zettel_span", text: "Hello world" }],
+							},
+						],
+					},
+				})
+				.execute()
+	).rejects.toThrowError();
+});
+
+test("valid thread comment content should pass", async () => {
+	const lix = await openLix({});
+
+	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("Hello world"),
+		})
+		.execute();
+
+	const comment = await lix.db
+		.selectFrom("thread_comment")
+		.selectAll()
+		.executeTakeFirstOrThrow();
+
+	expect(comment).toBeDefined();
+});

package/src/thread/schema.ts

@@ -0,0 +1,85 @@
+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";
+
+export function applyThreadDatabaseSchema(
+	sqlite: SqliteWasmDatabase
+): SqliteWasmDatabase {
+	// Create both primary and _all views for thread with default ID generation
+	createEntityViewsIfNotExists({
+		lix: { sqlite },
+		schema: LixThreadSchema,
+		overrideName: "thread",
+		pluginKey: "lix_own_entity",
+		hardcodedFileId: "lix",
+		defaultValues: {
+			id: () => "nano_id()",
+		},
+	});
+
+	// Create both primary and _all views for thread_comment with default ID generation
+	createEntityViewsIfNotExists({
+		lix: { sqlite },
+		schema: LixThreadCommentSchema,
+		overrideName: "thread_comment",
+		pluginKey: "lix_own_entity",
+		hardcodedFileId: "lix",
+		defaultValues: {
+			id: () => "nano_id()",
+		},
+	});
+
+	return sqlite;
+}
+
+export const LixThreadSchema = {
+	"x-lix-key": "lix_thread",
+	"x-lix-version": "1.0",
+	"x-lix-primary-key": ["id"],
+	type: "object",
+	properties: {
+		id: { type: "string", "x-lix-generated": true },
+		metadata: { type: "object", nullable: true },
+	},
+	required: ["id"],
+	additionalProperties: false,
+} as const;
+LixThreadSchema satisfies LixSchemaDefinition;
+
+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",
+		},
+		parent_id: {
+			schemaKey: "lix_thread_comment",
+			property: "id",
+		},
+	},
+	type: "object",
+	properties: {
+		id: { type: "string", "x-lix-generated": true },
+		thread_id: { type: "string" },
+		parent_id: { type: "string", nullable: true },
+		body: ZettelDocJsonSchema as any,
+	},
+	required: ["id", "thread_id", "body"],
+	additionalProperties: false,
+} as const;
+LixThreadCommentSchema satisfies LixSchemaDefinition;
+
+// Business logic types with LixGenerated markers
+export type Thread = FromLixSchemaDefinition<typeof LixThreadSchema>;
+export type ThreadComment = FromLixSchemaDefinition<
+	typeof LixThreadCommentSchema
+> & {
+	body: ZettelDoc; // Override the body type
+};

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

@@ -1,149 +1,102 @@
 import { test, expect } from "vitest";
-import { openLixInMemory } from "../lix/open-lix-in-memory.js";
+import { openLix } from "../lix/open-lix.js";
 import { createVersion } from "./create-version.js";
-import { updateChangesInVersion } from "./update-changes-in-version.js";
-import { createChangeConflict } from "../change-conflict/create-change-conflict.js";
+import type { ChangeSet } from "../change-set/schema.js";
+import { createChangeSet } from "../change-set/create-change-set.js";
 
-test("it should copy the changes from the parent version", async () => {
-	const lix = await openLixInMemory({});
+test("should create a version linked to the provided change_set_id", async () => {
+	const lix = await openLix({});
+	// Setup: Create a change_set to link to (must be in global version for version graph)
+	const changeSet = await createChangeSet({ lix, lixcol_version_id: "global" });
 
-	const version0 = await lix.db
-		.insertInto("version")
-		.values({ name: "version0" })
-		.returningAll()
-		.executeTakeFirstOrThrow();
+	const newVersion = await createVersion({ lix, changeSet });
 
-	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,
-	});
+	expect(newVersion.change_set_id).toBe(changeSet.id);
+	expect(newVersion.id).toBeDefined();
+	// Check if default name is assigned (assuming schema has a default or generated name)
+	expect(newVersion.name).toBeDefined();
+});
+
+test("should create a version with the specified name", async () => {
+	const lix = await openLix({});
+	const changeSet = await createChangeSet({ lix, lixcol_version_id: "global" });
+	const versionName = "My Test Version";
 
-	const version1 = await createVersion({
+	const newVersion = await createVersion({
 		lix,
-		from: version0,
+		changeSet,
+		name: versionName,
 	});
 
-	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);
+	expect(newVersion.change_set_id).toBe(changeSet.id);
+	expect(newVersion.name).toBe(versionName);
+	expect(newVersion.id).toBeDefined();
 });
 
-// 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();
+test("should create a version with the specified id", async () => {
+	const lix = await openLix({});
+	const changeSet = await createChangeSet({ lix, lixcol_version_id: "global" });
 
-	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({
+	const newVersion = await createVersion({
 		lix,
-		version: version0,
-		changes,
+		changeSet,
+		id: "hello world",
 	});
 
-	await createChangeConflict({
-		lix,
-		version: version0,
-		key: "mock-key",
-		conflictingChangeIds: new Set([changes[0]!.id, changes[1]!.id]),
+	expect(newVersion.change_set_id).toBe(changeSet.id);
+	expect(newVersion.id).toBe("hello world");
+	// Check default name assignment
+	expect(newVersion.name).toBeDefined();
+});
+
+test("should work within an existing transaction", async () => {
+	const lix = await openLix({});
+	const changeSet = await createChangeSet({ lix, lixcol_version_id: "global" });
+	const versionName = "Transaction Test Version";
+
+	const newVersion = await lix.db.transaction().execute(async (trx) => {
+		return createVersion({
+			lix: { ...lix, db: trx }, // Pass the transaction object
+			changeSet,
+			name: versionName,
+		});
 	});
 
-	const version0Conflicts = await lix.db
-		.selectFrom("version_change_conflict")
-		.where("version_id", "=", version0.id)
+	expect(newVersion.change_set_id).toBe(changeSet.id);
+	expect(newVersion.name).toBe(versionName);
+	expect(newVersion.id).toBeDefined();
+
+	// Verify it's actually in the database outside the transaction
+	const dbVersion = await lix.db
+		.selectFrom("version")
 		.selectAll()
-		.execute();
+		.where("id", "=", newVersion.id)
+		.executeTakeFirstOrThrow();
+	expect(dbVersion.name).toBe(versionName);
+});
+
+test("should fail if the 'from' change_set_id does not exist", async () => {
+	const lix = await openLix({});
+	const nonExistentChangeSet: Pick<ChangeSet, "id"> = {
+		id: "hello world" as ChangeSet["id"], // ID that won't exist
+	};
+
+	await expect(
+		createVersion({ lix, changeSet: nonExistentChangeSet })
+		// Check for foreign key constraint error
+		// The specific error message might vary based on the db driver
+	).rejects.toThrow(/Foreign key constraint violation/i);
+});
 
-	expect(version0Conflicts.length).toBe(1);
+test("should automatically create inheritance from global version", async () => {
+	const lix = await openLix({});
 
-	const version1 = await createVersion({
+	// Create a new version (should automatically inherit from global)
+	const newVersion = await createVersion({
 		lix,
-		from: version0,
-		name: "version1",
+		name: "test-version",
 	});
 
-	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
-	);
+	// Check that inheritance column was set correctly
+	expect(newVersion.inherits_from_version_id).toBe("global");
 });