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

package/src/entity/thread/query-threads.test.ts

@@ -0,0 +1,394 @@
+import { test, expect } from "vitest";
+import { openLix } from "../../lix/open-lix.js";
+import { createEntityThread } from "./create-entity-thread.js";
+import { createThread } from "../../thread/create-thread.js";
+import { ebEntity } from "../eb-entity.js";
+import { fromPlainText } from "@opral/zettel-ast";
+
+test("query all threads for a specific entity", async () => {
+	const lix = await openLix({});
+
+	// Create a label 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") }],
+	});
+	const thread2 = await createThread({
+		lix,
+		comments: [{ body: fromPlainText("Second thread") }],
+	});
+	const thread3 = await createThread({
+		lix,
+		comments: [{ body: fromPlainText("Third thread") }],
+	});
+
+	// Create mappings
+	await createEntityThread({
+		lix,
+		entity: keyValue,
+		thread: { id: thread1.id },
+	});
+	await createEntityThread({
+		lix,
+		entity: keyValue,
+		thread: { id: thread2.id },
+	});
+	await createEntityThread({
+		lix,
+		entity: keyValue,
+		thread: { id: thread3.id },
+	});
+
+	// Query threads for the entity
+	const threads = await lix.db
+		.selectFrom("thread")
+		.innerJoin("entity_thread", "entity_thread.thread_id", "thread.id")
+		.where("entity_thread.entity_id", "=", keyValue.key)
+		.where("entity_thread.schema_key", "=", "lix_key_value")
+		.where("entity_thread.file_id", "=", "lix")
+		.select(["thread.id", "thread.metadata"])
+		.execute();
+
+	expect(threads).toHaveLength(3);
+	expect(threads.map((t) => t.id).sort()).toEqual(
+		[thread1.id, thread2.id, thread3.id].sort()
+	);
+});
+
+test("query threads using ebEntity helper", async () => {
+	const lix = await openLix({});
+
+	// Create two different key-value entities
+	await lix.db
+		.insertInto("key_value_all")
+		.values({
+			key: "entity-config-1",
+			value: { setting: "entity1" },
+			lixcol_version_id: "global",
+		})
+		.execute();
+
+	await lix.db
+		.insertInto("key_value_all")
+		.values({
+			key: "entity-config-2",
+			value: { setting: "entity2" },
+			lixcol_version_id: "global",
+		})
+		.execute();
+
+	const keyValue1 = await lix.db
+		.selectFrom("key_value")
+		.where("key", "=", "entity-config-1")
+		.selectAll()
+		.executeTakeFirstOrThrow();
+
+	const keyValue2 = await lix.db
+		.selectFrom("key_value")
+		.where("key", "=", "entity-config-2")
+		.selectAll()
+		.executeTakeFirstOrThrow();
+
+	// Create threads for each entity
+	const thread1 = await createThread({
+		lix,
+		comments: [{ body: fromPlainText("Thread for entity 1") }],
+	});
+	const thread2 = await createThread({
+		lix,
+		comments: [{ body: fromPlainText("Another thread for entity 1") }],
+	});
+	const thread3 = await createThread({
+		lix,
+		comments: [{ body: fromPlainText("Thread for entity 2") }],
+	});
+
+	// Create mappings
+	await createEntityThread({
+		lix,
+		entity: keyValue1,
+		thread: { id: thread1.id },
+	});
+	await createEntityThread({
+		lix,
+		entity: keyValue1,
+		thread: { id: thread2.id },
+	});
+	await createEntityThread({
+		lix,
+		entity: keyValue2,
+		thread: { id: thread3.id },
+	});
+
+	// Query threads for entity 1 using ebEntity
+	const threadsForEntity1 = await lix.db
+		.selectFrom("thread_all")
+		.innerJoin(
+			"entity_thread_all",
+			"entity_thread_all.thread_id",
+			"thread_all.id"
+		)
+		.where("thread_all.lixcol_version_id", "=", "global")
+		.where("entity_thread_all.lixcol_version_id", "=", "global")
+		.where(
+			ebEntity("entity_thread_all").equals({
+				entity_id: keyValue1.key,
+				schema_key: "lix_key_value",
+				file_id: "lix",
+			})
+		)
+		.select(["thread_all.id"])
+		.execute();
+
+	expect(threadsForEntity1).toHaveLength(2);
+	expect(threadsForEntity1.map((t) => t.id).sort()).toEqual(
+		[thread1.id, thread2.id].sort()
+	);
+
+	// Query threads for entity 2 using ebEntity
+	const threadsForEntity2 = await lix.db
+		.selectFrom("thread_all")
+		.innerJoin(
+			"entity_thread_all",
+			"entity_thread_all.thread_id",
+			"thread_all.id"
+		)
+		.where("thread_all.lixcol_version_id", "=", "global")
+		.where("entity_thread_all.lixcol_version_id", "=", "global")
+		.where(
+			ebEntity("entity_thread_all").equals({
+				entity_id: keyValue2.key,
+				schema_key: "lix_key_value",
+				file_id: "lix",
+			})
+		)
+		.select(["thread_all.id"])
+		.execute();
+
+	expect(threadsForEntity2).toHaveLength(1);
+	expect(threadsForEntity2[0]?.id).toBe(thread3.id);
+});
+
+test("query entities with threads and comment counts", async () => {
+	const lix = await openLix({});
+
+	// Create multiple key-value entities
+	await lix.db
+		.insertInto("key_value_all")
+		.values({
+			key: "with-threads",
+			value: { threads: true },
+			lixcol_version_id: "global",
+		})
+		.execute();
+	await lix.db
+		.insertInto("key_value_all")
+		.values({
+			key: "without-threads",
+			value: { threads: false },
+			lixcol_version_id: "global",
+		})
+		.execute();
+	await lix.db
+		.insertInto("key_value_all")
+		.values({
+			key: "one-thread",
+			value: { threads: "one" },
+			lixcol_version_id: "global",
+		})
+		.execute();
+
+	const keyValue1 = await lix.db
+		.selectFrom("key_value")
+		.where("key", "=", "with-threads")
+		.selectAll()
+		.executeTakeFirstOrThrow();
+	const keyValue2 = await lix.db
+		.selectFrom("key_value")
+		.where("key", "=", "without-threads")
+		.selectAll()
+		.executeTakeFirstOrThrow();
+	const keyValue3 = await lix.db
+		.selectFrom("key_value")
+		.where("key", "=", "one-thread")
+		.selectAll()
+		.executeTakeFirstOrThrow();
+
+	// Create threads with different comment counts
+	const thread1 = await createThread({
+		lix,
+		comments: [
+			{ body: fromPlainText("Comment 1") },
+			{ body: fromPlainText("Comment 2") },
+			{ body: fromPlainText("Comment 3") },
+		],
+	});
+	const thread2 = await createThread({
+		lix,
+		comments: [{ body: fromPlainText("Single comment") }],
+	});
+	const thread3 = await createThread({
+		lix,
+		comments: [
+			{ body: fromPlainText("Comment A") },
+			{ body: fromPlainText("Comment B") },
+		],
+	});
+
+	// Create mappings
+	await createEntityThread({
+		lix,
+		entity: keyValue1,
+		thread: { id: thread1.id },
+	});
+	await createEntityThread({
+		lix,
+		entity: keyValue1,
+		thread: { id: thread2.id },
+	});
+	await createEntityThread({
+		lix,
+		entity: keyValue3,
+		thread: { id: thread3.id },
+	});
+
+	// Query entities with their thread and comment counts
+	const entitiesWithThreads = await lix.db
+		.selectFrom("entity_thread")
+		.innerJoin("thread", "thread.id", "entity_thread.thread_id")
+		.leftJoin("thread_comment", "thread_comment.thread_id", "thread.id")
+		.where("entity_thread.file_id", "=", "lix")
+		.where("entity_thread.schema_key", "=", "lix_key_value")
+		.select([
+			"entity_thread.entity_id",
+			"entity_thread.schema_key",
+			"thread.id as thread_id",
+			(eb) => eb.fn.count("thread_comment.id").as("comment_count"),
+		])
+		.groupBy([
+			"entity_thread.entity_id",
+			"entity_thread.schema_key",
+			"thread.id",
+		])
+		.execute();
+
+	// Verify results
+	const keyValue1Threads = entitiesWithThreads.filter(
+		(e) => e.entity_id === keyValue1.key
+	);
+	expect(keyValue1Threads).toHaveLength(2);
+
+	const thread1Result = keyValue1Threads.find(
+		(t) => t.thread_id === thread1.id
+	);
+	expect(thread1Result?.comment_count).toBe(3);
+
+	const thread2Result = keyValue1Threads.find(
+		(t) => t.thread_id === thread2.id
+	);
+	expect(thread2Result?.comment_count).toBe(1);
+
+	const keyValue3Threads = entitiesWithThreads.filter(
+		(e) => e.entity_id === keyValue3.key
+	);
+	expect(keyValue3Threads).toHaveLength(1);
+	expect(keyValue3Threads[0]?.comment_count).toBe(2);
+
+	// Verify keyValue2 has no threads
+	const keyValue2Threads = entitiesWithThreads.filter(
+		(e) => e.entity_id === keyValue2.key
+	);
+	expect(keyValue2Threads).toHaveLength(0);
+});
+
+test("query threads across different entity types", async () => {
+	const lix = await openLix({});
+
+	// Create different types of entities
+	await lix.db
+		.insertInto("key_value_all")
+		.values({
+			key: "test-config",
+			value: { test: true },
+			lixcol_version_id: "global",
+		})
+		.execute();
+
+	const keyValue = await lix.db
+		.selectFrom("key_value")
+		.where("key", "=", "test-config")
+		.selectAll()
+		.executeTakeFirstOrThrow();
+
+	// Create a change set entity (which is also stored as state)
+	await lix.db
+		.insertInto("change_set_all")
+		.values({
+			id: "test-change-set",
+			lixcol_version_id: "global",
+		})
+		.execute();
+
+	// Create threads
+	const labelThread = await createThread({
+		lix,
+		comments: [{ body: fromPlainText("Thread on label") }],
+	});
+	const changeSetThread = await createThread({
+		lix,
+		comments: [{ body: fromPlainText("Thread on change set") }],
+	});
+
+	// Get the change set entity
+	const changeSet = await lix.db
+		.selectFrom("change_set")
+		.where("id", "=", "test-change-set")
+		.selectAll()
+		.executeTakeFirstOrThrow();
+
+	// Create mappings
+	await createEntityThread({
+		lix,
+		entity: keyValue,
+		thread: { id: labelThread.id },
+	});
+	await createEntityThread({
+		lix,
+		entity: changeSet,
+		thread: { id: changeSetThread.id },
+	});
+
+	// Query all threads regardless of entity type
+	const allThreadMappings = await lix.db
+		.selectFrom("entity_thread")
+		.innerJoin("thread", "thread.id", "entity_thread.thread_id")
+		.select([
+			"entity_thread.entity_id",
+			"entity_thread.schema_key",
+			"thread.id as thread_id",
+		])
+		.execute();
+
+	expect(allThreadMappings).toHaveLength(2);
+
+	// Verify we have threads on different entity types
+	const schemaKeys = [...new Set(allThreadMappings.map((m) => m.schema_key))];
+	expect(schemaKeys).toContain("lix_key_value");
+	expect(schemaKeys).toContain("lix_change_set");
+});

package/src/entity/thread/schema.test.ts

@@ -0,0 +1,170 @@
+import { test, expect } from "vitest";
+import { openLix } from "../../lix/open-lix.js";
+import { LixEntityThreadSchema } from "./schema.js";
+import { createEntityThread } from "./create-entity-thread.js";
+import { createThread } from "../../thread/create-thread.js";
+import { fromPlainText } from "@opral/zettel-ast";
+
+test("entity_thread schema should be properly defined", () => {
+	// Verify schema structure
+	expect(LixEntityThreadSchema["x-lix-key"]).toBe("lix_entity_thread");
+	expect(LixEntityThreadSchema["x-lix-version"]).toBe("1.0");
+	expect(LixEntityThreadSchema["x-lix-primary-key"]).toEqual([
+		"entity_id",
+		"schema_key",
+		"file_id",
+		"thread_id",
+	]);
+
+	// Verify foreign keys
+	expect(LixEntityThreadSchema["x-lix-foreign-keys"]).toHaveLength(2);
+	expect(LixEntityThreadSchema["x-lix-foreign-keys"]![0]).toEqual({
+		properties: ["entity_id", "schema_key", "file_id"],
+		references: {
+			schemaKey: "state",
+			properties: ["entity_id", "schema_key", "file_id"],
+		},
+	});
+	expect(LixEntityThreadSchema["x-lix-foreign-keys"]![1]).toEqual({
+		properties: ["thread_id"],
+		references: {
+			schemaKey: "lix_thread",
+			properties: ["id"],
+		},
+	});
+
+	// Verify properties
+	expect(LixEntityThreadSchema.properties).toEqual({
+		entity_id: { type: "string" },
+		schema_key: { type: "string" },
+		file_id: { type: "string" },
+		thread_id: { type: "string" },
+	});
+
+	// Verify required fields
+	expect(LixEntityThreadSchema.required).toEqual([
+		"entity_id",
+		"schema_key",
+		"file_id",
+		"thread_id",
+	]);
+});
+
+test("entity_thread foreign key to state table should be enforced", async () => {
+	const lix = await openLix({});
+
+	// Create a thread
+	const thread = await createThread({
+		lix,
+		comments: [{ body: fromPlainText("Test") }],
+	});
+
+	// Try to create mapping with non-existent entity
+	await expect(
+		createEntityThread({
+			lix,
+			entity: {
+				entity_id: "non-existent-id",
+				schema_key: "lix_key_value",
+				file_id: "lix",
+			},
+			thread: { id: thread.id },
+		})
+	).rejects.toThrow(/Foreign key constraint violation/);
+});
+
+test("entity_thread foreign key to thread table should be enforced", async () => {
+	const lix = await openLix({});
+
+	// Create a key-value entity
+	await lix.db
+		.insertInto("key_value_all")
+		.values({
+			key: "test-config",
+			value: { setting: "testvalue" },
+			lixcol_version_id: "global",
+		})
+		.execute();
+
+	const keyValue = await lix.db
+		.selectFrom("key_value")
+		.where("key", "=", "test-config")
+		.selectAll()
+		.executeTakeFirstOrThrow();
+
+	// Try to create mapping with non-existent thread
+	await expect(
+		createEntityThread({
+			lix,
+			entity: keyValue,
+			thread: { id: "non-existent-thread-id" },
+		})
+	).rejects.toThrow(/Foreign key constraint violation/);
+});
+
+test("entity_thread compound foreign key to state table should validate all parts", async () => {
+	const lix = await openLix({});
+
+	// Create a key-value entity and thread
+	await lix.db
+		.insertInto("key_value_all")
+		.values({
+			key: "fk-test-config",
+			value: { setting: "fkvalue" },
+			lixcol_version_id: "global",
+		})
+		.execute();
+
+	const keyValue = await lix.db
+		.selectFrom("key_value")
+		.where("key", "=", "fk-test-config")
+		.selectAll()
+		.executeTakeFirstOrThrow();
+	const thread = await createThread({
+		lix,
+		comments: [{ body: fromPlainText("FK test") }],
+	});
+
+	// Create valid mapping
+	await createEntityThread({
+		lix,
+		entity: keyValue,
+		thread: { id: thread.id },
+	});
+
+	// Verify mapping exists
+	const mapping = await lix.db
+		.selectFrom("entity_thread")
+		.where("entity_id", "=", keyValue.key)
+		.where("thread_id", "=", thread.id)
+		.selectAll()
+		.executeTakeFirst();
+
+	expect(mapping).toBeDefined();
+
+	// Try to create mapping with wrong schema_key for existing entity_id
+	await expect(
+		createEntityThread({
+			lix,
+			entity: {
+				entity_id: keyValue.key,
+				schema_key: "wrong_schema_key", // This combination doesn't exist in state
+				file_id: "lix",
+			},
+			thread: { id: thread.id },
+		})
+	).rejects.toThrow(/Foreign key constraint violation/);
+
+	// Try to create mapping with wrong file_id for existing entity
+	await expect(
+		createEntityThread({
+			lix,
+			entity: {
+				entity_id: keyValue.key,
+				schema_key: "lix_key_value",
+				file_id: "wrong_file.json", // This combination doesn't exist in state
+			},
+			thread: { id: thread.id },
+		})
+	).rejects.toThrow(/Foreign key constraint violation/);
+});

package/src/entity/thread/schema.ts

@@ -0,0 +1,55 @@
+import type {
+	LixSchemaDefinition,
+	FromLixSchemaDefinition,
+} from "../../schema-definition/definition.js";
+import { createEntityViewsIfNotExists } from "../../entity-views/entity-view-builder.js";
+import type { Lix } from "../../lix/open-lix.js";
+
+export function applyEntityThreadDatabaseSchema(
+	lix: Pick<Lix, "sqlite" | "db">
+): void {
+	createEntityViewsIfNotExists({
+		lix,
+		schema: LixEntityThreadSchema,
+		overrideName: "entity_thread",
+		pluginKey: "lix_own_entity",
+		hardcodedFileId: "lix",
+	});
+}
+
+export const LixEntityThreadSchema = {
+	"x-lix-key": "lix_entity_thread",
+	"x-lix-version": "1.0",
+	"x-lix-primary-key": ["entity_id", "schema_key", "file_id", "thread_id"],
+	"x-lix-foreign-keys": [
+		{
+			properties: ["entity_id", "schema_key", "file_id"],
+			references: {
+				schemaKey: "state",
+				properties: ["entity_id", "schema_key", "file_id"],
+			},
+		},
+		{
+			properties: ["thread_id"],
+			references: {
+				schemaKey: "lix_thread",
+				properties: ["id"],
+			},
+		},
+	],
+	type: "object",
+	properties: {
+		entity_id: { type: "string" },
+		schema_key: { type: "string" },
+		file_id: { type: "string" },
+		thread_id: { type: "string" },
+	},
+	required: ["entity_id", "schema_key", "file_id", "thread_id"],
+	additionalProperties: false,
+} as const;
+LixEntityThreadSchema satisfies LixSchemaDefinition;
+
+// Pure business logic type (inferred from schema)
+export type LixEntityThread = FromLixSchemaDefinition<
+	typeof LixEntityThreadSchema
+>;