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

package/src/change-author/schema.test.ts

@@ -1,149 +1,240 @@
-import { describe, expect, test } from "vitest";
+import { expect, test } from "vitest";
 import { openLix } from "../lix/open-lix.js";
 import { createAccount } from "../account/create-account.js";
 
-describe("change_author", () => {
-	test("insert, update, delete on the change_author view", async () => {
-		const lix = await openLix({});
+test("insert, update, delete on the change_author view", async () => {
+	const lix = await openLix({});
 
-		// Create account
-		const account = await createAccount({
-			lix,
-			name: "Test Author",
-		});
-
-		// Create change
-		await lix.db
-			.insertInto("change")
-			.values({
-				id: "c0",
-				entity_id: "e0",
-				schema_key: "mock_schema",
-				schema_version: "1",
-				file_id: "f0",
-				plugin_key: "test_plugin",
-				snapshot_content: { id: "e0" },
-			})
-			.execute();
-
-		await lix.db
-			.insertInto("change_author")
-			.values([
-				{
-					change_id: "c0",
-					account_id: account.id,
-				},
-			])
-			.execute();
-
-		const viewAfterInsert = await lix.db
-			.selectFrom("change_author")
-			.orderBy("change_id", "asc")
-			.selectAll()
-			.execute();
+	// Create account
+	const account = await createAccount({
+		lix,
+		name: "Test Author",
+	});
 
-		expect(viewAfterInsert).toMatchObject([
+	// Create change
+	await lix.db
+		.insertInto("change")
+		.values({
+			id: "c0",
+			entity_id: "e0",
+			schema_key: "mock_schema",
+			schema_version: "1",
+			file_id: "f0",
+			plugin_key: "test_plugin",
+			snapshot_content: { id: "e0" },
+		})
+		.execute();
+
+	await lix.db
+		.insertInto("change_author")
+		.values([
 			{
 				change_id: "c0",
 				account_id: account.id,
 			},
-		]);
+		])
+		.execute();
+
+	const viewAfterInsert = await lix.db
+		.selectFrom("change_author")
+		.orderBy("change_id", "asc")
+		.where("change_id", "=", "c0")
+		.selectAll()
+		.execute();
+
+	expect(viewAfterInsert).toMatchObject([
+		{
+			change_id: "c0",
+			account_id: account.id,
+		},
+	]);
+
+	await lix.db
+		.deleteFrom("change_author")
+		.where("change_id", "=", "c0")
+		.execute();
+
+	const viewAfterDelete = await lix.db
+		.selectFrom("change_author")
+		.orderBy("change_id", "asc")
+		.where("change_id", "=", "c0")
+		.selectAll()
+		.execute();
+
+	expect(viewAfterDelete).toEqual([]);
+});
 
-		await lix.db
-			.deleteFrom("change_author")
-			.where("change_id", "=", "c0")
-			.execute();
+test("should enforce primary key constraint (change_id, account_id)", async () => {
+	const lix = await openLix({});
 
-		const viewAfterDelete = await lix.db
-			.selectFrom("change_author")
-			.orderBy("change_id", "asc")
-			.selectAll()
-			.execute();
+	// Create account
+	const account = await createAccount({
+		lix,
+		name: "Test Author",
+	});
 
-		expect(viewAfterDelete).toEqual([]);
+	await lix.db
+		.insertInto("change")
+		.values({
+			id: "c1",
+			entity_id: "e1",
+			schema_key: "mock_schema",
+			schema_version: "1",
+			file_id: "f1",
+			plugin_key: "test_plugin",
+			snapshot_content: { id: "e1" },
+		})
+		.execute();
+
+	// Insert first change_author
+	await lix.db
+		.insertInto("change_author")
+		.values({
+			change_id: "c1",
+			account_id: account.id,
+		})
+		.execute();
+
+	// Attempt duplicate insert with same primary key
+	await expect(
+		lix.db
+			.insertInto("change_author")
+			.values({
+				change_id: "c1",
+				account_id: account.id,
+			})
+			.execute()
+	).rejects.toThrow(/Primary key constraint violation/i);
+});
 
-		// After delete, there should be no state records for the change_author
-		const allStates = await lix.db
-			.selectFrom("state_all")
-			.where("schema_key", "=", "lix_change_author")
-			.selectAll()
-			.execute();
+test("should enforce foreign key constraint on change_id", async () => {
+	const lix = await openLix({});
 
-		expect(allStates).toHaveLength(0); // All records should be deleted
+	// Create account (but NOT change)
+	const account = await createAccount({
+		lix,
+		name: "Test Author",
 	});
 
-	test("should enforce primary key constraint (change_id, account_id)", async () => {
-		const lix = await openLix({});
-
-		// Create account
-		const account = await createAccount({
-			lix,
-			name: "Test Author",
-		});
-
-		await lix.db
-			.insertInto("change")
+	// Attempt to insert with non-existent change_id
+	await expect(
+		lix.db
+			.insertInto("change_author")
 			.values({
-				id: "c1",
-				entity_id: "e1",
-				schema_key: "mock_schema",
-				schema_version: "1",
-				file_id: "f1",
-				plugin_key: "test_plugin",
-				snapshot_content: { id: "e1" },
+				change_id: "c_nonexistent",
+				account_id: account.id,
 			})
-			.execute();
+			.execute()
+	).rejects.toThrow(
+		/Foreign key constraint violation.*lix_change_author.*\(change_id\).*lix_change\.\(id\)/i
+	);
+});
 
-		// Insert first change_author
-		await lix.db
+test("should enforce foreign key constraint on account_id", async () => {
+	const lix = await openLix({});
+
+	await lix.db
+		.insertInto("change")
+		.values({
+			id: "c1",
+			entity_id: "e1",
+			schema_key: "mock_schema",
+			schema_version: "1",
+			file_id: "f1",
+			plugin_key: "test_plugin",
+			snapshot_content: { id: "e1" },
+		})
+		.execute();
+
+	// Attempt to insert with non-existent account_id
+	await expect(
+		lix.db
 			.insertInto("change_author")
 			.values({
 				change_id: "c1",
-				account_id: account.id,
+				account_id: "account_nonexistent",
 			})
-			.execute();
+			.execute()
+	).rejects.toThrow(
+		/Foreign key constraint violation.*lix_change_author.*\(account_id\).*lix_account\.\(id\)/i
+	);
+});
 
-		// Attempt duplicate insert with same primary key
-		await expect(
-			lix.db
-				.insertInto("change_author")
-				.values({
-					change_id: "c1",
-					account_id: account.id,
-				})
-				.execute()
-		).rejects.toThrow(/Primary key constraint violation/i);
+test("should allow multiple authors for the same change", async () => {
+	const lix = await openLix({});
+
+	// Create accounts
+	const author1 = await createAccount({
+		lix,
+		name: "Author One",
 	});
 
-	test("should enforce foreign key constraint on change_id", async () => {
-		const lix = await openLix({});
+	const author2 = await createAccount({
+		lix,
+		name: "Author Two",
+	});
 
-		// Create account (but NOT change)
-		const account = await createAccount({
-			lix,
-			name: "Test Author",
-		});
+	await lix.db
+		.insertInto("change")
+		.values({
+			id: "c1",
+			entity_id: "e1",
+			schema_key: "mock_schema",
+			schema_version: "1",
+			file_id: "f1",
+			plugin_key: "test_plugin",
+			snapshot_content: { id: "e1" },
+		})
+		.execute();
+
+	// Insert multiple authors for same change
+	await lix.db
+		.insertInto("change_author")
+		.values([
+			{
+				change_id: "c1",
+				account_id: author1.id,
+			},
+			{
+				change_id: "c1",
+				account_id: author2.id,
+			},
+		])
+		.execute();
+
+	const authors = await lix.db
+		.selectFrom("change_author")
+		.where("change_id", "=", "c1")
+		.orderBy("account_id", "asc")
+		.selectAll()
+		.execute();
+
+	expect(authors).toHaveLength(2);
+	expect(authors).toMatchObject([
+		{
+			change_id: "c1",
+			account_id: author1.id,
+		},
+		{
+			change_id: "c1",
+			account_id: author2.id,
+		},
+	]);
+});
 
-		// Attempt to insert with non-existent change_id
-		await expect(
-			lix.db
-				.insertInto("change_author")
-				.values({
-					change_id: "c_nonexistent",
-					account_id: account.id,
-				})
-				.execute()
-		).rejects.toThrow(
-			/Foreign key constraint violation.*change_id.*lix_change.id/i
-		);
-	});
+test("should allow same author for multiple changes", async () => {
+	const lix = await openLix({});
 
-	test("should enforce foreign key constraint on account_id", async () => {
-		const lix = await openLix({});
+	// Create account
+	const author = await createAccount({
+		lix,
+		name: "Prolific Author",
+	});
 
-		await lix.db
-			.insertInto("change")
-			.values({
+	await lix.db
+		.insertInto("change")
+		.values([
+			{
 				id: "c1",
 				entity_id: "e1",
 				schema_key: "mock_schema",
@@ -151,150 +242,123 @@ describe("change_author", () => {
 				file_id: "f1",
 				plugin_key: "test_plugin",
 				snapshot_content: { id: "e1" },
-			})
-			.execute();
-
-		// Attempt to insert with non-existent account_id
-		await expect(
-			lix.db
-				.insertInto("change_author")
-				.values({
-					change_id: "c1",
-					account_id: "account_nonexistent",
-				})
-				.execute()
-		).rejects.toThrow(
-			/Foreign key constraint violation.*account_id.*lix_account.id/i
-		);
-	});
-
-	test("should allow multiple authors for the same change", async () => {
-		const lix = await openLix({});
-
-		// Create accounts
-		const author1 = await createAccount({
-			lix,
-			name: "Author One",
-		});
-
-		const author2 = await createAccount({
-			lix,
-			name: "Author Two",
-		});
-
-		await lix.db
-			.insertInto("change")
-			.values({
-				id: "c1",
-				entity_id: "e1",
+			},
+			{
+				id: "c2",
+				entity_id: "e2",
 				schema_key: "mock_schema",
 				schema_version: "1",
-				file_id: "f1",
+				file_id: "f2",
 				plugin_key: "test_plugin",
-				snapshot_content: { id: "e1" },
-			})
-			.execute();
-
-		// Insert multiple authors for same change
-		await lix.db
-			.insertInto("change_author")
-			.values([
-				{
-					change_id: "c1",
-					account_id: author1.id,
-				},
-				{
-					change_id: "c1",
-					account_id: author2.id,
-				},
-			])
-			.execute();
-
-		const authors = await lix.db
-			.selectFrom("change_author")
-			.where("change_id", "=", "c1")
-			.orderBy("account_id", "asc")
-			.selectAll()
-			.execute();
+				snapshot_content: { id: "e2" },
+			},
+		])
+		.execute();
 
-		expect(authors).toHaveLength(2);
-		expect(authors).toMatchObject([
+	// Insert same author for multiple changes
+	await lix.db
+		.insertInto("change_author")
+		.values([
 			{
 				change_id: "c1",
-				account_id: author1.id,
+				account_id: author.id,
 			},
 			{
-				change_id: "c1",
-				account_id: author2.id,
+				change_id: "c2",
+				account_id: author.id,
 			},
-		]);
-	});
-
-	test("should allow same author for multiple changes", async () => {
-		const lix = await openLix({});
+		])
+		.execute();
+
+	const authorChanges = await lix.db
+		.selectFrom("change_author")
+		.where("account_id", "=", author.id)
+		.orderBy("change_id", "asc")
+		.selectAll()
+		.execute();
+
+	expect(authorChanges).toHaveLength(2);
+	expect(authorChanges).toMatchObject([
+		{
+			change_id: "c1",
+			account_id: author.id,
+		},
+		{
+			change_id: "c2",
+			account_id: author.id,
+		},
+	]);
+});
 
-		// Create account
-		const author = await createAccount({
-			lix,
-			name: "Prolific Author",
-		});
+test("change authors are accessible during a transaction", async () => {
+	// Create a lix instance with an active account
+	const lix = await openLix({
+		account: {
+			id: "test-account",
+			name: "Test User",
+		},
+	});
 
-		await lix.db
-			.insertInto("change")
-			.values([
-				{
-					id: "c1",
-					entity_id: "e1",
-					schema_key: "mock_schema",
-					schema_version: "1",
-					file_id: "f1",
-					plugin_key: "test_plugin",
-					snapshot_content: { id: "e1" },
-				},
-				{
-					id: "c2",
-					entity_id: "e2",
-					schema_key: "mock_schema",
-					schema_version: "1",
-					file_id: "f2",
-					plugin_key: "test_plugin",
-					snapshot_content: { id: "e2" },
-				},
-			])
+	await lix.db.transaction().execute(async (trx) => {
+		// Insert a key-value entity within the transaction
+		await trx
+			.insertInto("key_value")
+			.values({
+				key: "transaction_test_key",
+				value: "transaction_test_value",
+			})
 			.execute();
 
-		// Insert same author for multiple changes
-		await lix.db
-			.insertInto("change_author")
-			.values([
-				{
-					change_id: "c1",
-					account_id: author.id,
-				},
-				{
-					change_id: "c2",
-					account_id: author.id,
-				},
-			])
+		// The change should be created automatically with change_author records
+		// Let's verify we can access the change and its authors within the transaction
+		const changes = await trx
+			.selectFrom("change")
+			.where("entity_id", "=", "transaction_test_key")
+			.where("schema_key", "=", "lix_key_value")
+			.selectAll()
 			.execute();
 
-		const authorChanges = await lix.db
+		expect(changes).toHaveLength(1);
+		const changeId = changes[0]!.id;
+
+		// Verify the change_author record is accessible within the transaction
+		const changeAuthors = await trx
 			.selectFrom("change_author")
-			.where("account_id", "=", author.id)
-			.orderBy("change_id", "asc")
+			.where("change_id", "=", changeId)
 			.selectAll()
 			.execute();
 
-		expect(authorChanges).toHaveLength(2);
-		expect(authorChanges).toMatchObject([
-			{
-				change_id: "c1",
-				account_id: author.id,
-			},
-			{
-				change_id: "c2",
-				account_id: author.id,
-			},
-		]);
+		// Find the test account's change author (there may be multiple active accounts)
+		const testAuthor = changeAuthors.find(
+			(a) => a.account_id === "test-account"
+		);
+		expect(testAuthor).toBeDefined();
+		expect(testAuthor).toMatchObject({
+			change_id: changeId,
+			account_id: "test-account",
+		});
+	});
+
+	// Verify the change_author records are still accessible after the transaction commits
+	const changes = await lix.db
+		.selectFrom("change")
+		.where("entity_id", "=", "transaction_test_key")
+		.where("schema_key", "=", "lix_key_value")
+		.selectAll()
+		.execute();
+
+	expect(changes).toHaveLength(1);
+	const changeId = changes[0]!.id;
+
+	const changeAuthors = await lix.db
+		.selectFrom("change_author")
+		.where("change_id", "=", changeId)
+		.selectAll()
+		.execute();
+
+	expect(changeAuthors).toHaveLength(1);
+	expect(changeAuthors[0]).toMatchObject({
+		change_id: changeId,
+		account_id: "test-account",
 	});
 });

package/src/change-author/schema.ts

@@ -2,15 +2,15 @@ import type {
 	LixSchemaDefinition,
 	FromLixSchemaDefinition,
 } from "../schema-definition/definition.js";
-import type { SqliteWasmDatabase } from "sqlite-wasm-kysely";
 import { createEntityViewsIfNotExists } from "../entity-views/entity-view-builder.js";
+import type { Lix } from "../lix/open-lix.js";
 
 export function applyChangeAuthorDatabaseSchema(
-	sqlite: SqliteWasmDatabase
+	lix: Pick<Lix, "sqlite" | "db">
 ): void {
 	// Create change_author view using the generalized entity view builder
 	createEntityViewsIfNotExists({
-		lix: { sqlite },
+		lix,
 		schema: LixChangeAuthorSchema,
 		overrideName: "change_author",
 		pluginKey: "lix_own_entity",
@@ -22,16 +22,22 @@ export const LixChangeAuthorSchema = {
 	"x-lix-key": "lix_change_author",
 	"x-lix-version": "1.0",
 	"x-lix-primary-key": ["change_id", "account_id"],
-	"x-lix-foreign-keys": {
-		change_id: {
-			schemaKey: "lix_change",
-			property: "id",
+	"x-lix-foreign-keys": [
+		{
+			properties: ["change_id"],
+			references: {
+				schemaKey: "lix_change",
+				properties: ["id"],
+			},
 		},
-		account_id: {
-			schemaKey: "lix_account",
-			property: "id",
+		{
+			properties: ["account_id"],
+			references: {
+				schemaKey: "lix_account",
+				properties: ["id"],
+			},
 		},
-	},
+	],
 	type: "object",
 	properties: {
 		change_id: { type: "string" },
@@ -43,6 +49,6 @@ export const LixChangeAuthorSchema = {
 LixChangeAuthorSchema satisfies LixSchemaDefinition;
 
 // Pure business logic type (inferred from schema)
-export type ChangeAuthor = FromLixSchemaDefinition<
+export type LixChangeAuthor = FromLixSchemaDefinition<
 	typeof LixChangeAuthorSchema
 >;

package/src/change-proposal/create-change-proposal.ts

@@ -1,7 +1,7 @@
 // eslint-disable-next-line @typescript-eslint/ban-ts-comment
 // @ts-nocheck
 
-import type { ChangeSet } from "../change-set/schema.js";
+import type { LixChangeSet } from "../change-set/schema.js";
 import type { Lix } from "../lix/open-lix.js";
 import type { ChangeProposal } from "./database-schema.js";
 import { createChangeSet } from "../change-set/create-change-set.js";
@@ -16,8 +16,8 @@ import { changeSetElementInSymmetricDifference } from "../query-filter/change-se
  */
 export async function createChangeProposal(args: {
 	lix: Lix;
-	sourceChangeSet: Pick<ChangeSet, "id">;
-	targetChangeSet: Pick<ChangeSet, "id">;
+	sourceChangeSet: Pick<LixChangeSet, "id">;
+	targetChangeSet: Pick<LixChangeSet, "id">;
 }): Promise<ChangeProposal> {
 	const executeInTransaction = async (trx: Lix["db"]) => {
 		// Get the changes that are in the symmetric difference between the two change sets

package/src/change-proposal/database-schema.ts

@@ -6,7 +6,7 @@ export function applyChangeProposalDatabaseSchema(
 ): SqliteWasmDatabase {
 	const sql = `
   CREATE TABLE IF NOT EXISTS change_proposal (
-    id TEXT PRIMARY KEY DEFAULT (uuid_v7()),
+    id TEXT PRIMARY KEY DEFAULT (lix_uuid_v7()),
 
     change_set_id TEXT NOT NULL,
     source_change_set_id TEXT,