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

package/src/commit/index.ts

@@ -3,9 +3,4 @@ export {
 	LixCommitEdgeSchema,
 	type LixCommit,
 	type LixCommitEdge,
-	applyCommitDatabaseSchema,
-} from "./schema.js";
-export { createMergeCommit } from "./create-merge-commit.js";
-export { createTransitionCommit } from "./create-transition-commit.js";
-export { createCheckpoint } from "./create-checkpoint.js";
-export { createUndoCommit } from "./create-undo-commit.js";
+} from "./schema-definition.js";

package/src/commit/schema-definition.ts

@@ -0,0 +1,103 @@
+import type {
+	FromLixSchemaDefinition,
+	LixSchemaDefinition,
+} from "../schema-definition/definition.js";
+
+export type LixCommit = FromLixSchemaDefinition<typeof LixCommitSchema>;
+
+export const LixCommitSchema = {
+	"x-lix-key": "lix_commit",
+	"x-lix-version": "1.0",
+	"x-lix-primary-key": ["/id"],
+	"x-lix-override-lixcols": {
+		lixcol_file_id: '"lix"',
+		lixcol_plugin_key: '"lix_sdk"',
+		lixcol_version_id: '"global"',
+	},
+	"x-lix-foreign-keys": [
+		{
+			properties: ["/change_set_id"],
+			references: {
+				schemaKey: "lix_change_set",
+				properties: ["/id"],
+			},
+			mode: "materialized",
+		},
+	],
+	type: "object",
+	properties: {
+		id: {
+			type: "string",
+			description: "Commit identifier",
+			"x-lix-default": "lix_uuid_v7()",
+		},
+		change_set_id: {
+			type: "string",
+			description:
+				"Identifier of the change set associated with this commit (materialized in cache)",
+		},
+		change_ids: {
+			type: ["array", "null"],
+			items: { type: "string" },
+			description:
+				"Domain change identifiers contained in this commit. Excludes meta changes; used to derive change_set_elements.",
+		},
+		author_account_ids: {
+			type: ["array", "null"],
+			items: { type: "string" },
+			description:
+				"Commit-level author account identifiers. Explicit per-change overrides live in lix_change_author.",
+		},
+		parent_commit_ids: {
+			type: ["array", "null"],
+			items: { type: "string" },
+			description:
+				"Direct parent commit identifiers; used to derive commit edges and ancestry.",
+		},
+		meta_change_ids: {
+			type: ["array", "null"],
+			items: { type: "string" },
+			description:
+				"Meta change identifiers (e.g., version tip) associated with this commit and kept separate from domain membership.",
+		},
+	},
+	required: ["id", "change_set_id"],
+	additionalProperties: false,
+} as const;
+LixCommitSchema satisfies LixSchemaDefinition;
+
+export type LixCommitEdge = FromLixSchemaDefinition<typeof LixCommitEdgeSchema>;
+
+export const LixCommitEdgeSchema = {
+	"x-lix-key": "lix_commit_edge",
+	"x-lix-version": "1.0",
+	"x-lix-primary-key": ["/parent_id", "/child_id"],
+	"x-lix-override-lixcols": {
+		lixcol_file_id: '"lix"',
+		lixcol_plugin_key: '"lix_sdk"',
+	},
+	"x-lix-foreign-keys": [
+		{
+			properties: ["/parent_id"],
+			references: {
+				schemaKey: "lix_commit",
+				properties: ["/id"],
+			},
+		},
+		{
+			properties: ["/child_id"],
+			references: {
+				schemaKey: "lix_commit",
+				properties: ["/id"],
+			},
+		},
+	],
+	type: "object",
+	properties: {
+		parent_id: { type: "string" },
+		child_id: { type: "string" },
+	},
+	required: ["parent_id", "child_id"],
+	additionalProperties: false,
+} as const;
+LixCommitEdgeSchema satisfies LixSchemaDefinition;

package/src/commit/schema.test.ts

@@ -1,14 +1,13 @@
 import { describe, test, expect } from "vitest";
 import { openLix } from "../lix/open-lix.js";
 
-describe("commit_edge", () => {
-	test("insert, delete on the commit edge view", async () => {
+describe("commit_edge (derived)", () => {
+	test("reflects parent_commit_ids and updates on change", async () => {
 		const lix = await openLix({});
 
-		// Create the referenced commits first
-		// Need to create change sets and then commits
+		// Create change sets and commits
 		await lix.db
-			.insertInto("change_set_all")
+			.insertInto("change_set_by_version")
 			.values([
 				{ id: "cs0", lixcol_version_id: "global" },
 				{ id: "cs1", lixcol_version_id: "global" },
@@ -16,51 +15,48 @@ describe("commit_edge", () => {
 			.execute();
 
 		await lix.db
-			.insertInto("commit_all")
+			.insertInto("commit_by_version")
 			.values([
 				{ id: "commit0", change_set_id: "cs0", lixcol_version_id: "global" },
 				{ id: "commit1", change_set_id: "cs1", lixcol_version_id: "global" },
 			])
 			.execute();
 
+		// Link commit1 to commit0 via parent_commit_ids
 		await lix.db
-			.insertInto("commit_edge_all")
-			.values([
-				{
-					parent_id: "commit0",
-					child_id: "commit1",
-					lixcol_version_id: "global",
-				},
-			])
+			.updateTable("commit_by_version")
+			.set({ parent_commit_ids: ["commit0"] as any })
+			.where("id", "=", "commit1")
+			.where("lixcol_version_id", "=", "global")
 			.execute();
 
-		const viewAfterInsert = await lix.db
+		const viewAfterLink = await lix.db
 			.selectFrom("commit_edge")
 			.orderBy("parent_id", "asc")
 			.where("parent_id", "=", "commit0")
 			.selectAll()
 			.execute();
 
-		expect(viewAfterInsert).toMatchObject([
-			{
-				parent_id: "commit0",
-				child_id: "commit1",
-			},
+		expect(viewAfterLink).toMatchObject([
+			{ parent_id: "commit0", child_id: "commit1" },
 		]);
 
+		// Remove parent linkage
 		await lix.db
-			.deleteFrom("commit_edge")
-			.where("parent_id", "=", "commit0")
+			.updateTable("commit_by_version")
+			.set({ parent_commit_ids: [] as any })
+			.where("id", "=", "commit1")
+			.where("lixcol_version_id", "=", "global")
 			.execute();
 
-		const viewAfterDelete = await lix.db
+		const viewAfterUnlink = await lix.db
 			.selectFrom("commit_edge")
 			.orderBy("parent_id", "asc")
 			.where("parent_id", "=", "commit0")
 			.selectAll()
 			.execute();
 
-		expect(viewAfterDelete).toEqual([]);
+		expect(viewAfterUnlink).toEqual([]);
 	});
 
 	test("should enforce primary key constraint (parent_id, child_id)", async () => {
@@ -68,7 +64,7 @@ describe("commit_edge", () => {
 
 		// Create the referenced change sets and commits first
 		await lix.db
-			.insertInto("change_set_all")
+			.insertInto("change_set_by_version")
 			.values([
 				{ id: "cs0", lixcol_version_id: "global" },
 				{ id: "cs1", lixcol_version_id: "global" },
@@ -76,7 +72,7 @@ describe("commit_edge", () => {
 			.execute();
 
 		await lix.db
-			.insertInto("commit_all")
+			.insertInto("commit_by_version")
 			.values([
 				{ id: "commit0", change_set_id: "cs0", lixcol_version_id: "global" },
 				{ id: "commit1", change_set_id: "cs1", lixcol_version_id: "global" },
@@ -85,7 +81,7 @@ describe("commit_edge", () => {
 
 		// Insert first edge
 		await lix.db
-			.insertInto("commit_edge_all")
+			.insertInto("commit_edge_by_version")
 			.values({
 				parent_id: "commit0",
 				child_id: "commit1",
@@ -96,7 +92,7 @@ describe("commit_edge", () => {
 		// Attempt duplicate insert with same primary key
 		await expect(
 			lix.db
-				.insertInto("commit_edge_all")
+				.insertInto("commit_edge_by_version")
 				.values({
 					parent_id: "commit0",
 					child_id: "commit1",
@@ -111,12 +107,12 @@ describe("commit_edge", () => {
 
 		// Create only child commit (not parent)
 		await lix.db
-			.insertInto("change_set_all")
+			.insertInto("change_set_by_version")
 			.values({ id: "cs1", lixcol_version_id: "global" })
 			.execute();
 
 		await lix.db
-			.insertInto("commit_all")
+			.insertInto("commit_by_version")
 			.values({
 				id: "commit1",
 				change_set_id: "cs1",
@@ -127,7 +123,7 @@ describe("commit_edge", () => {
 		// Attempt to insert edge with non-existent parent_id
 		await expect(
 			lix.db
-				.insertInto("commit_edge_all")
+				.insertInto("commit_edge_by_version")
 				.values({
 					parent_id: "commit_nonexistent",
 					child_id: "commit1",
@@ -142,12 +138,12 @@ describe("commit_edge", () => {
 
 		// Create only parent commit (not child)
 		await lix.db
-			.insertInto("change_set_all")
+			.insertInto("change_set_by_version")
 			.values({ id: "cs0", lixcol_version_id: "global" })
 			.execute();
 
 		await lix.db
-			.insertInto("commit_all")
+			.insertInto("commit_by_version")
 			.values({
 				id: "commit0",
 				change_set_id: "cs0",
@@ -158,7 +154,7 @@ describe("commit_edge", () => {
 		// Attempt to insert edge with non-existent child_id
 		await expect(
 			lix.db
-				.insertInto("commit_edge_all")
+				.insertInto("commit_edge_by_version")
 				.values({
 					parent_id: "commit0",
 					child_id: "commit_nonexistent",
@@ -173,12 +169,12 @@ describe("commit_edge", () => {
 
 		// Create a commit
 		await lix.db
-			.insertInto("change_set_all")
+			.insertInto("change_set_by_version")
 			.values({ id: "cs1", lixcol_version_id: "global" })
 			.execute();
 
 		await lix.db
-			.insertInto("commit_all")
+			.insertInto("commit_by_version")
 			.values({
 				id: "commit1",
 				change_set_id: "cs1",
@@ -189,7 +185,7 @@ describe("commit_edge", () => {
 		// Attempt to create self-referencing edge
 		await expect(
 			lix.db
-				.insertInto("commit_edge_all")
+				.insertInto("commit_edge_by_version")
 				.values({
 					parent_id: "commit1",
 					child_id: "commit1", // Same as parent_id
@@ -255,3 +251,103 @@ describe("commit_edge", () => {
 		]);
 	});
 });
+
+describe("commit", () => {
+	test("allows inserting commit_by_version without pre-creating change_set", async () => {
+		const lix = await openLix({});
+
+		// Insert commit directly with a new change_set_id that doesn't exist yet
+		await lix.db
+			.insertInto("commit_by_version")
+			.values({
+				id: "commit_no_fk",
+				change_set_id: "cs_no_fk",
+				lixcol_version_id: "global",
+			})
+			.execute();
+
+		// Verify commit exists
+		const c = await lix.db
+			.selectFrom("commit_by_version")
+			.selectAll()
+			.where("id", "=", "commit_no_fk")
+			.where("lixcol_version_id", "=", "global")
+			.executeTakeFirstOrThrow();
+
+		expect(c).toMatchObject({ id: "commit_no_fk", change_set_id: "cs_no_fk" });
+	});
+
+	test("commit_by_version insertion derives change_set in cache (global)", async () => {
+		const lix = await openLix({});
+
+		await lix.db
+			.insertInto("commit_by_version")
+			.values({
+				id: "commit_cs_only",
+				change_set_id: "cs_only",
+				lixcol_version_id: "global",
+			})
+			.execute();
+
+		// change_set is materialized from commit snapshot into cache
+		const cs = await lix.db
+			.selectFrom("change_set_by_version")
+			.where("id", "=", "cs_only")
+			.where("lixcol_version_id", "=", "global")
+			.selectAll()
+			.executeTakeFirstOrThrow();
+
+		expect(cs).toMatchObject({ id: "cs_only", lixcol_version_id: "global" });
+	});
+
+	test("commit_by_version with parent_commit_ids produces edges joined to real commit change", async () => {
+		const lix = await openLix({});
+
+		// Insert parent and child commits directly (no pre-created change_set)
+		await lix.db
+			.insertInto("commit_by_version")
+			.values({
+				id: "parentA",
+				change_set_id: "csA",
+				lixcol_version_id: "global",
+			})
+			.execute();
+
+		await lix.db
+			.insertInto("commit_by_version")
+			.values({
+				id: "childB",
+				change_set_id: "csB",
+				parent_commit_ids: ["parentA"] as any,
+				lixcol_version_id: "global",
+			})
+			.execute();
+
+		const row = await lix.db
+			.selectFrom("commit_edge_by_version")
+			.innerJoin(
+				"change",
+				"change.id",
+				"commit_edge_by_version.lixcol_change_id"
+			)
+			.where("commit_edge_by_version.lixcol_version_id", "=", "global")
+			.where("commit_edge_by_version.parent_id", "=", "parentA")
+			.where("commit_edge_by_version.child_id", "=", "childB")
+			.select([
+				"commit_edge_by_version.parent_id as parent_id",
+				"commit_edge_by_version.child_id as child_id",
+				"change.entity_id as change_entity_id",
+				"change.snapshot_content as snap",
+			])
+			.executeTakeFirstOrThrow();
+
+		expect(row.parent_id).toBe("parentA");
+		expect(row.child_id).toBe("childB");
+		expect(row.change_entity_id).toBe("childB");
+		expect(row.snap).toMatchObject({
+			id: "childB",
+			change_set_id: "csB",
+			parent_commit_ids: ["parentA"],
+		});
+	});
+});

package/src/conversation/create-conversation-message.test.ts

@@ -0,0 +1,118 @@
+import { test, expect } from "vitest";
+import { createConversationMessage } from "./create-conversation-message.js";
+import { openLix } from "../lix/open-lix.js";
+import { fromPlainText } from "@opral/zettel-ast";
+import { nanoId } from "../engine/functions/nano-id.js";
+
+test("creates a conversation message", async () => {
+	const lix = await openLix({});
+
+	const conversationId = await nanoId({ lix });
+	await lix.db
+		.insertInto("conversation")
+		.values({ id: conversationId })
+		.execute();
+
+	const conversation = await lix.db
+		.selectFrom("conversation")
+		.selectAll()
+		.where("id", "=", conversationId)
+		.executeTakeFirstOrThrow();
+
+	const msg = await createConversationMessage({
+		lix,
+		conversation_id: conversation.id,
+		body: fromPlainText("Hello world  "),
+	});
+
+	expect(msg).toBeDefined();
+});
+
+test("defaults to the version of the conversation", async () => {
+	const lix = await openLix({});
+
+	const conversationId = await nanoId({ lix });
+	await lix.db
+		.insertInto("conversation")
+		.values({ id: conversationId })
+		.execute();
+
+	const activeVersionScoped = await lix.db
+		.selectFrom("conversation")
+		.selectAll()
+		.where("id", "=", conversationId)
+		.executeTakeFirstOrThrow();
+
+	const m1 = await createConversationMessage({
+		lix,
+		conversation_id: activeVersionScoped.id,
+		body: fromPlainText("Hello world  "),
+	});
+
+	expect(m1).toBeDefined();
+
+	await lix.db
+		.insertInto("conversation_by_version")
+		.values({ id: "global-conv", lixcol_version_id: "global" })
+		.execute();
+
+	const globalMsg = await createConversationMessage({
+		lix,
+		conversation_id: "global-conv",
+		body: fromPlainText("Hello global world  "),
+	});
+
+	expect(globalMsg).toBeDefined();
+});
+
+test("defaults parent_id to the last message when not provided (most recent leaf)", async () => {
+	const lix = await openLix({});
+
+	const conversationId = await nanoId({ lix });
+	await lix.db
+		.insertInto("conversation")
+		.values({ id: conversationId })
+		.execute();
+
+	const conv = await lix.db
+		.selectFrom("conversation")
+		.selectAll()
+		.where("id", "=", conversationId)
+		.executeTakeFirstOrThrow();
+
+	const first = await createConversationMessage({
+		lix,
+		conversation_id: conv.id,
+		body: fromPlainText("First message"),
+	});
+	expect(first.parent_id).toBeNull();
+
+	const second = await createConversationMessage({
+		lix,
+		conversation_id: conv.id,
+		body: fromPlainText("Second message"),
+	});
+	expect(second.parent_id).toBe(first.id);
+
+	const third = await createConversationMessage({
+		lix,
+		conversation_id: conv.id,
+		body: fromPlainText("Third message"),
+	});
+	expect(third.parent_id).toBe(second.id);
+
+	const fourth = await createConversationMessage({
+		lix,
+		conversation_id: conv.id,
+		body: fromPlainText("Fourth message"),
+		parent_id: first.id,
+	});
+	expect(fourth.parent_id).toBe(first.id);
+
+	const fifth = await createConversationMessage({
+		lix,
+		conversation_id: conv.id,
+		body: fromPlainText("Fifth message"),
+	});
+	expect(fifth.parent_id).toBe(fourth.id);
+});

package/src/conversation/create-conversation-message.ts

@@ -0,0 +1,82 @@
+import type { Lix } from "../lix/open-lix.js";
+import type { NewState, State } from "../engine/entity-views/types.js";
+import type { LixConversationMessage } from "./schema-definition.js";
+import { nanoId } from "../engine/functions/nano-id.js";
+
+/**
+ * Adds a message to an existing conversation.
+ * In DB terms: inserts a row into `conversation_message[_all]`.
+ */
+export async function createConversationMessage(
+	args: { lix: Lix } & NewState<LixConversationMessage>
+): Promise<State<LixConversationMessage>> {
+	const executeInTransaction = async (trx: Lix["db"]) => {
+		const messageId = args.id ?? (await nanoId({ lix: args.lix }));
+
+		const existingConversation = await trx
+			.selectFrom("conversation_by_version")
+			.where("id", "=", args.conversation_id)
+			.where("lixcol_inherited_from_version_id", "is", null)
+			.select("lixcol_version_id")
+			.executeTakeFirstOrThrow();
+
+		// Default parent to most recent leaf
+		let parentId = args.parent_id as string | null | undefined;
+		if (parentId === undefined) {
+			const leaf = await trx
+				.selectFrom("conversation_message_by_version as m1")
+				.where("m1.conversation_id", "=", args.conversation_id)
+				.where(
+					"m1.lixcol_version_id",
+					"=",
+					existingConversation.lixcol_version_id
+				)
+				.where((eb) =>
+					eb.not(
+						eb.exists(
+							eb
+								.selectFrom("conversation_message_by_version as m2")
+								.where("m2.conversation_id", "=", args.conversation_id)
+								.where(
+									"m2.lixcol_version_id",
+									"=",
+									existingConversation.lixcol_version_id
+								)
+								.whereRef("m2.parent_id", "=", "m1.id")
+								.select("m2.id")
+						)
+					)
+				)
+				.select(["m1.id", "m1.lixcol_created_at"])
+				.orderBy("m1.lixcol_created_at", "desc")
+				.orderBy("m1.id", "desc")
+				.executeTakeFirst();
+			parentId = leaf?.id ?? null;
+		}
+
+		await trx
+			.insertInto("conversation_message_by_version")
+			.values({
+				id: messageId,
+				conversation_id: args.conversation_id,
+				body: args.body,
+				lixcol_metadata: args.lixcol_metadata ?? undefined,
+				parent_id: parentId,
+				lixcol_version_id: existingConversation.lixcol_version_id,
+			})
+			.execute();
+
+		return await trx
+			.selectFrom("conversation_message_by_version")
+			.selectAll()
+			.where("id", "=", messageId)
+			.where("lixcol_version_id", "=", existingConversation.lixcol_version_id)
+			.executeTakeFirstOrThrow();
+	};
+
+	if (args.lix.db.isTransaction) {
+		return await executeInTransaction(args.lix.db);
+	} else {
+		return await args.lix.db.transaction().execute(executeInTransaction);
+	}
+}