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

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

@@ -0,0 +1,364 @@
+import { expect, test } from "vitest";
+import { openLix } from "../lix/open-lix.js";
+import { createAccount } from "../account/create-account.js";
+
+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")
+		.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([]);
+});
+
+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")
+		.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);
+});
+
+test("should enforce foreign key constraint on change_id", async () => {
+	const lix = await openLix({});
+
+	// Create account (but NOT change)
+	const account = await createAccount({
+		lix,
+		name: "Test Author",
+	});
+
+	// 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.*lix_change_author.*\(change_id\).*lix_change\.\(id\)/i
+	);
+});
+
+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_nonexistent",
+			})
+			.execute()
+	).rejects.toThrow(
+		/Foreign key constraint violation.*lix_change_author.*\(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",
+			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,
+		},
+	]);
+});
+
+test("should allow same author for multiple changes", async () => {
+	const lix = await openLix({});
+
+	// Create account
+	const author = await createAccount({
+		lix,
+		name: "Prolific 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" },
+			},
+			{
+				id: "c2",
+				entity_id: "e2",
+				schema_key: "mock_schema",
+				schema_version: "1",
+				file_id: "f2",
+				plugin_key: "test_plugin",
+				snapshot_content: { id: "e2" },
+			},
+		])
+		.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,
+			},
+		])
+		.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,
+		},
+	]);
+});
+
+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.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();
+
+		// 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();
+
+		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("change_id", "=", changeId)
+			.selectAll()
+			.execute();
+
+		// 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

@@ -0,0 +1,54 @@
+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 applyChangeAuthorDatabaseSchema(
+	lix: Pick<Lix, "sqlite" | "db">
+): void {
+	// Create change_author view using the generalized entity view builder
+	createEntityViewsIfNotExists({
+		lix,
+		schema: LixChangeAuthorSchema,
+		overrideName: "change_author",
+		pluginKey: "lix_own_entity",
+		hardcodedFileId: "lix",
+	});
+}
+
+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": [
+		{
+			properties: ["change_id"],
+			references: {
+				schemaKey: "lix_change",
+				properties: ["id"],
+			},
+		},
+		{
+			properties: ["account_id"],
+			references: {
+				schemaKey: "lix_account",
+				properties: ["id"],
+			},
+		},
+	],
+	type: "object",
+	properties: {
+		change_id: { type: "string" },
+		account_id: { type: "string" },
+	},
+	required: ["change_id", "account_id"],
+	additionalProperties: false,
+} as const;
+LixChangeAuthorSchema satisfies LixSchemaDefinition;
+
+// Pure business logic type (inferred from schema)
+export type LixChangeAuthor = FromLixSchemaDefinition<
+	typeof LixChangeAuthorSchema
+>;

package/src/change-conflict/create-change-conflict.test.ts

@@ -1,10 +1,12 @@
+// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+// @ts-nocheck
+
 import { expect, test } from "vitest";
-import { openLixInMemory } from "../lix/open-lix-in-memory.js";
+import { openLix } from "../lix/open-lix.js";
 import { createChangeConflict } from "./create-change-conflict.js";
-import { createVersion } from "../version/create-version.js";
 
-test("conflicts should be de-duplicated based on the change_conflict.key and version", async () => {
-	const lix = await openLixInMemory({});
+test.skip("conflicts should be de-duplicated based on the change_conflict.key and version", async () => {
+	const lix = await openLix({});
 
 	const version0 = await createVersion({ lix, name: "version0" });
 
@@ -17,7 +19,7 @@ test("conflicts should be de-duplicated based on the change_conflict.key and ver
 				schema_key: "mock",
 				file_id: "mock",
 				entity_id: "value0",
-				snapshot_id: "no-content",
+				snapshot_content: null,
 			},
 			{
 				id: "change1",
@@ -25,7 +27,7 @@ test("conflicts should be de-duplicated based on the change_conflict.key and ver
 				file_id: "mock",
 				entity_id: "value1",
 				schema_key: "mock",
-				snapshot_id: "no-content",
+				snapshot_content: null,
 			},
 		])
 		.execute();
@@ -68,8 +70,9 @@ test("conflicts should be de-duplicated based on the change_conflict.key and ver
 	expect(conflictsAfter2Creation[0]?.key).toBe("mock-conflict");
 });
 
-test("if a conflict contains the same changes for a given key and version, no new conflict should be created", async () => {
-	const lix = await openLixInMemory({});
+// commented out because of https://github.com/opral/lix-sdk/issues/285#issuecomment-2755409022
+test.skip("if a conflict contains the same changes for a given key and version, no new conflict should be created", async () => {
+	const lix = await openLix({});
 
 	const version0 = await createVersion({ lix, name: "version0" });
 
@@ -82,7 +85,7 @@ test("if a conflict contains the same changes for a given key and version, no ne
 				schema_key: "mock",
 				file_id: "mock",
 				entity_id: "value0",
-				snapshot_id: "no-content",
+				snapshot_content: null,
 			},
 			{
 				id: "change1",
@@ -90,7 +93,7 @@ test("if a conflict contains the same changes for a given key and version, no ne
 				file_id: "mock",
 				entity_id: "value1",
 				schema_key: "mock",
-				snapshot_id: "no-content",
+				snapshot_content: null,
 			},
 			{
 				id: "change2",
@@ -98,7 +101,7 @@ test("if a conflict contains the same changes for a given key and version, no ne
 				file_id: "mock",
 				entity_id: "value1",
 				schema_key: "mock",
-				snapshot_id: "no-content",
+				snapshot_content: null,
 			},
 		])
 		.execute();

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

@@ -1,3 +1,6 @@
+// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+// @ts-nocheck
+
 import type { Version, Change, ChangeConflict } from "../database/schema.js";
 import type { Lix } from "../lix/open-lix.js";
 
@@ -75,16 +78,36 @@ export async function createChangeConflict(args: {
 			.returningAll()
 			.executeTakeFirstOrThrow();
 
+		// Insert elements linking the new conflict change set to the conflicting changes
+		// Fetch the change records to get entity_id, schema_key, file_id
+		const conflictingChanges = await trx
+			.selectFrom("change")
+			.where("id", "in", [...args.conflictingChangeIds])
+			.select(["id", "entity_id", "schema_key", "file_id"])
+			.execute();
+
+		const conflictingChangeMap = new Map(
+			conflictingChanges.map((c) => [c.id, c])
+		);
+
 		await trx
 			.insertInto("change_set_element")
 			.values(
-				Array.from(args.conflictingChangeIds).map((id) => ({
-					change_id: id,
-					change_set_id: newConflict.change_set_id,
-				}))
+				Array.from(args.conflictingChangeIds).map((id) => {
+					const change = conflictingChangeMap.get(id);
+					if (!change) {
+						// Should not happen if FK constraints work
+						throw new Error(`Conflicting change record not found: ${id}`);
+					}
+					return {
+						change_id: id,
+						change_set_id: newConflict.change_set_id,
+						entity_id: change.entity_id,
+						schema_key: change.schema_key,
+						file_id: change.file_id,
+					};
+				})
 			)
-			// Ignore if the conflict element already exists
-			.onConflict((oc) => oc.doNothing())
 			.execute();
 
 		await trx

package/src/change-conflict/detect-change-conflicts.test.ts

@@ -1,11 +1,14 @@
+// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+// @ts-nocheck
+
 import { test, expect, vi } from "vitest";
-import { openLixInMemory } from "../lix/open-lix-in-memory.js";
-import type { Change } from "../database/schema.js";
-import { detectChangeConflicts } from "./detect-change-conflicts.js";
-import type { LixPlugin } from "../plugin/lix-plugin.js";
+// import { openLix } from "../lix/open-lix.js";
+// import type { Change } from "../database/schema.js";
+// import { detectChangeConflicts } from "./detect-change-conflicts.js";
+// import type { LixPlugin } from "../plugin/lix-plugin.js";
 
-test("should detect conflicts using plugins", async () => {
-	const lix = await openLixInMemory({});
+test.skip("should detect conflicts using plugins", async () => {
+	const lix = await openLix({});
 
 	const mockPlugin: LixPlugin = {
 		key: "mock-plugin",
@@ -51,8 +54,8 @@ test("should detect conflicts using plugins", async () => {
 	});
 });
 
-test("should handle no conflicts detected by plugins", async () => {
-	const lix = await openLixInMemory({});
+test.skip("should handle no conflicts detected by plugins", async () => {
+	const lix = await openLix({});
 
 	const mockPlugin: LixPlugin = {
 		key: "mock-plugin",
@@ -89,8 +92,8 @@ test("should handle no conflicts detected by plugins", async () => {
 	});
 });
 
-test("should handle multiple plugins detecting conflicts", async () => {
-	const lix = await openLixInMemory({});
+test.skip("should handle multiple plugins detecting conflicts", async () => {
+	const lix = await openLix({});
 
 	const mockPlugin1: LixPlugin = {
 		key: "mock-plugin1",
@@ -160,8 +163,8 @@ test("should handle multiple plugins detecting conflicts", async () => {
 	});
 });
 
-test("it should auto detect diverging entity conflicts", async () => {
-	const lix = await openLixInMemory({});
+test.skip("it should auto detect diverging entity conflicts", async () => {
+	const lix = await openLix({});
 
 	const changes = await lix.db
 		.insertInto("change")
@@ -172,7 +175,7 @@ test("it should auto detect diverging entity conflicts", async () => {
 				schema_key: "mock",
 				file_id: "file0",
 				entity_id: "entity0",
-				snapshot_id: "no-content",
+				snapshot_content: null,
 			},
 			{
 				id: "change1",
@@ -180,7 +183,7 @@ test("it should auto detect diverging entity conflicts", async () => {
 				schema_key: "mock",
 				file_id: "file0",
 				entity_id: "entity0",
-				snapshot_id: "no-content",
+				snapshot_content: null,
 			},
 			{
 				id: "change2",
@@ -188,7 +191,7 @@ test("it should auto detect diverging entity conflicts", async () => {
 				file_id: "file0",
 				entity_id: "entity0",
 				schema_key: "mock",
-				snapshot_id: "no-content",
+				snapshot_content: null,
 			},
 		])
 		.returningAll()

package/src/change-conflict/detect-change-conflicts.ts

@@ -1,3 +1,6 @@
+// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+// @ts-nocheck
+
 import type { Change } from "../database/schema.js";
 import type { DetectedConflict, LixReadonly } from "../plugin/lix-plugin.js";
 import { detectDivergingEntityConflict } from "./detect-diverging-entity-conflict.js";