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

package/src/account/create-account.ts

@@ -1,17 +1,47 @@
+import { uuidV7 } from "../deterministic/uuid-v7.js";
 import type { Lix } from "../lix/open-lix.js";
-import type { Account } from "./database-schema.js";
+import type { LixAccount } from "./schema.js";
+
+/**
+ * Inserts a new account into the Lix database.
+ *
+ * Accounts represent different identities working with the same Lix
+ * file. Switching the active account is handled separately via
+ * {@link switchAccount}.
+ *
+ * @example
+ * ```ts
+ * const account = await createAccount({ lix, name: "Jane" })
+ * ```
+ */
 
 export async function createAccount(args: {
-	lix: Lix;
-	name: string;
-}): Promise<Account> {
+	lix: Pick<Lix, "db" | "sqlite">;
+	id?: LixAccount["id"];
+	name: LixAccount["name"];
+	lixcol_version_id?: string;
+}): Promise<LixAccount> {
 	const executeInTransaction = async (trx: Lix["db"]) => {
-		const account = await trx
-			.insertInto("account")
+		// Generate ID if not provided (views handle this, but we need it for querying back)
+		const accountId = args.id || uuidV7({ lix: args.lix });
+
+		// Insert the account (views don't support returningAll)
+		await trx
+			.insertInto("account_all")
 			.values({
+				id: accountId,
 				name: args.name,
+				lixcol_version_id:
+					args.lixcol_version_id ??
+					trx.selectFrom("active_version").select("version_id"),
 			})
-			.returningAll()
+			.execute();
+
+		// Query back the inserted account
+		const account = await trx
+			.selectFrom("account_all")
+			.selectAll()
+			.where("id", "=", accountId)
 			.executeTakeFirstOrThrow();
 
 		return account;

package/src/account/index.ts

@@ -1,3 +1,7 @@
-export * from "./database-schema.js";
 export { createAccount } from "./create-account.js";
 export { switchAccount } from "./switch-account.js";
+export {
+	LixAccountSchema,
+	type LixAccount as Account,
+	type LixActiveAccount as ActiveAccount,
+} from "./schema.js";

package/src/account/schema.test.ts

@@ -0,0 +1,370 @@
+import { test, expect } from "vitest";
+import { openLix } from "../lix/open-lix.js";
+import { createVersion } from "../version/create-version.js";
+
+test("insert, update, delete on the account view", async () => {
+	const lix = await openLix({});
+
+	await lix.db
+		.insertInto("account")
+		.values([
+			{
+				id: "account0",
+				name: "Alice",
+			},
+			{
+				id: "account1",
+				name: "Bob",
+			},
+		])
+		.execute();
+
+	const viewAfterInsert = await lix.db
+		.selectFrom("account")
+		.select(["id", "name"])
+		.where("id", "in", ["account0", "account1"])
+		.orderBy("id")
+		.execute();
+
+	expect(viewAfterInsert).toEqual([
+		{
+			id: "account0",
+			name: "Alice",
+		},
+		{
+			id: "account1",
+			name: "Bob",
+		},
+	]);
+
+	await lix.db
+		.updateTable("account")
+		.where("id", "=", "account0")
+		.set({
+			name: "Alice Updated",
+		})
+		.execute();
+
+	const viewAfterUpdate = await lix.db
+		.selectFrom("account")
+		.orderBy("id")
+		.where("id", "in", ["account0", "account1"])
+		.select(["id", "name"])
+		.execute();
+
+	expect(viewAfterUpdate).toEqual([
+		{
+			id: "account0",
+			name: "Alice Updated",
+		},
+		{
+			id: "account1",
+			name: "Bob",
+		},
+	]);
+
+	await lix.db.deleteFrom("account").where("id", "=", "account0").execute();
+
+	const viewAfterDelete = await lix.db
+		.selectFrom("account")
+		.orderBy("id")
+		.where("id", "in", ["account0", "account1"])
+		.select(["id", "name"])
+		.execute();
+
+	expect(viewAfterDelete).toEqual([
+		{
+			id: "account1",
+			name: "Bob",
+		},
+	]);
+});
+
+test("account ids should have a default", async () => {
+	const lix = await openLix({});
+
+	await lix.db
+		.insertInto("account")
+		.values({
+			name: "Test User",
+		})
+		.execute();
+
+	const account = await lix.db
+		.selectFrom("account")
+		.where("name", "=", "Test User")
+		.selectAll()
+		.executeTakeFirstOrThrow();
+
+	expect(account.id).toBeDefined();
+	expect(account.name).toBe("Test User");
+});
+
+test("account operations are version specific and isolated", async () => {
+	const lix = await openLix({});
+
+	const versionA = await createVersion({
+		lix,
+		id: "versionA",
+	});
+
+	const versionB = await createVersion({
+		lix,
+		id: "versionB",
+	});
+
+	// Insert account in version A
+	await lix.db
+		.insertInto("account_all")
+		.values({
+			id: "accountA",
+			name: "User A",
+			lixcol_version_id: versionA.id,
+		})
+		.execute();
+
+	// Insert account in version B with same id but different name
+	await lix.db
+		.insertInto("account_all")
+		.values({
+			id: "accountB",
+			name: "User B",
+			lixcol_version_id: versionB.id,
+		})
+		.execute();
+
+	// Verify both versions have their own accounts
+	const accountsInVersionA = await lix.db
+		.selectFrom("account_all")
+		.where("lixcol_version_id", "=", versionA.id)
+		.where("id", "in", ["accountA", "accountB"])
+		.selectAll()
+		.execute();
+
+	const accountsInVersionB = await lix.db
+		.selectFrom("account_all")
+		.where("lixcol_version_id", "=", versionB.id)
+		.where("id", "in", ["accountA", "accountB"])
+		.selectAll()
+		.execute();
+
+	expect(accountsInVersionA).toHaveLength(1);
+	expect(accountsInVersionB).toHaveLength(1);
+	expect(accountsInVersionA[0]?.name).toBe("User A");
+	expect(accountsInVersionB[0]?.name).toBe("User B");
+
+	// Update account in version A
+	await lix.db
+		.updateTable("account_all")
+		.where("id", "=", "accountA")
+		.where("lixcol_version_id", "=", versionA.id)
+		.set({
+			name: "User A Updated",
+		})
+		.execute();
+
+	// Verify update only affected version A
+	const updatedAccountsA = await lix.db
+		.selectFrom("account_all")
+		.where("lixcol_version_id", "=", versionA.id)
+		.selectAll()
+		.execute();
+
+	const unchangedAccountsB = await lix.db
+		.selectFrom("account_all")
+		.where("lixcol_version_id", "=", versionB.id)
+		.selectAll()
+		.execute();
+
+	expect(updatedAccountsA[0]?.name).toBe("User A Updated");
+	expect(unchangedAccountsB[0]?.name).toBe("User B");
+
+	// Delete account from version A
+	await lix.db
+		.deleteFrom("account_all")
+		.where("id", "=", "accountA")
+		.where("lixcol_version_id", "=", versionA.id)
+		.execute();
+
+	// Verify deletion only affected version A
+	const remainingAccountsA = await lix.db
+		.selectFrom("account_all")
+		.where("id", "in", ["accountA", "accountB"])
+		.where("lixcol_version_id", "=", versionA.id)
+		.selectAll()
+		.execute();
+
+	const remainingAccountsB = await lix.db
+		.selectFrom("account_all")
+		.where("id", "in", ["accountA", "accountB"])
+		.where("lixcol_version_id", "=", versionB.id)
+		.selectAll()
+		.execute();
+
+	expect(remainingAccountsA).toHaveLength(0);
+	expect(remainingAccountsB).toHaveLength(1);
+	expect(remainingAccountsB[0]?.name).toBe("User B");
+});
+
+test("active_account temp table operations", async () => {
+	const lix = await openLix({});
+
+	// Check if the default anonymous account was created with proper details
+	const activeAccounts = await lix.db
+		.selectFrom("active_account as aa")
+		.innerJoin("account_all as a", "a.id", "aa.account_id")
+		.where("a.lixcol_version_id", "=", "global")
+		.select(["aa.account_id", "a.id", "a.name"])
+		.execute();
+
+	expect(activeAccounts).toHaveLength(1);
+	expect(activeAccounts[0]?.name).toMatch(/^Anonymous \w+$/);
+
+	// First create a real account in global version (where active accounts look)
+	await lix.db
+		.insertInto("account_all")
+		.values({
+			id: "user123",
+			name: "Alice",
+			lixcol_version_id: "global",
+		})
+		.execute();
+
+	// Then make it active
+	await lix.db
+		.insertInto("active_account")
+		.values({
+			account_id: "user123",
+		})
+		.execute();
+
+	const updatedActiveAccounts = await lix.db
+		.selectFrom("active_account")
+		.selectAll()
+		.execute();
+
+	expect(updatedActiveAccounts).toHaveLength(2);
+	// The new active account might show null name if the account is not in the right version
+	// Let's check if the ID is there at least
+	const aliceActive = updatedActiveAccounts.find(
+		(acc) => acc.account_id === "user123"
+	);
+	expect(aliceActive).toBeDefined();
+	expect(aliceActive?.account_id).toBe("user123");
+
+	// Update the actual account (not the active account reference)
+	await lix.db
+		.updateTable("account_all")
+		.where("id", "=", "user123")
+		.where("lixcol_version_id", "=", "global")
+		.set({ name: "Alice Updated" })
+		.execute();
+
+	const afterUpdate = await lix.db
+		.selectFrom("active_account")
+		.where("account_id", "=", "user123")
+		.selectAll()
+		.execute();
+
+	expect(afterUpdate).toHaveLength(1);
+	// Verify the account was updated by checking the actual account
+	const updatedAccount = await lix.db
+		.selectFrom("account_all")
+		.where("id", "=", "user123")
+		.where("lixcol_version_id", "=", "global")
+		.selectAll()
+		.executeTakeFirst();
+	expect(updatedAccount?.name).toBe("Alice Updated");
+
+	// Delete active account
+	await lix.db
+		.deleteFrom("active_account")
+		.where("account_id", "=", "user123")
+		.execute();
+
+	const afterDelete = await lix.db
+		.selectFrom("active_account")
+		.selectAll()
+		.execute();
+
+	expect(afterDelete).toHaveLength(1);
+	expect(afterDelete.some((acc) => acc.account_id === "user123")).toBe(false);
+});
+
+test("account table should have one untracked entry initially and active_account should reference it", async () => {
+	const lix = await openLix({});
+
+	// Check the anonymous account in account_all (includes untracked)
+	const allAccounts = await lix.db
+		.selectFrom("account_all")
+		.selectAll()
+		.execute();
+
+	// The anonymous account exists and is initially untracked
+	expect(allAccounts.length).toBeGreaterThan(0);
+	const anonymousAccount = allAccounts.find((acc) =>
+		acc.name?.match(/^Anonymous \w+$/)
+	);
+	expect(anonymousAccount).toBeDefined();
+	expect(anonymousAccount?.lixcol_untracked).toBe(1);
+
+	// Check that active_account references the same account using a join
+	const activeAccount = await lix.db
+		.selectFrom("active_account as aa")
+		.innerJoin("account_all as a", "a.id", "aa.account_id")
+		.where("a.lixcol_version_id", "=", "global")
+		.select(["aa.account_id", "a.id", "a.name"])
+		.executeTakeFirst();
+
+	expect(activeAccount).toBeDefined();
+	expect(activeAccount?.account_id).toBe(anonymousAccount?.id);
+});
+
+test.skip("active_account should enforce foreign key constraint on account_id", async () => {
+	// TODO: Foreign key constraints are not enforced on views with INSTEAD OF triggers
+	// because the LixActiveAccountSchema is not stored in stored_schema table.
+	// This would require storing the schema and ensuring validation is called
+	// in the trigger or virtual table implementation.
+	const lix = await openLix({});
+
+	// Try to insert an active account reference to a non-existent account
+	await expect(
+		lix.db
+			.insertInto("active_account")
+			.values({
+				account_id: "non-existent-account",
+			})
+			.execute()
+	).rejects.toThrow(/foreign key/i);
+});
+
+test("should generate different anonymous account names", async () => {
+	const lix0 = await openLix({});
+	const lix1 = await openLix({});
+	const lix2 = await openLix({});
+
+	// Get active accounts with details using joins
+	const account0 = await lix0.db
+		.selectFrom("active_account as aa")
+		.innerJoin("account_all as a", "a.id", "aa.account_id")
+		.where("a.lixcol_version_id", "=", "global")
+		.select(["a.id", "a.name"])
+		.executeTakeFirst();
+
+	const account1 = await lix1.db
+		.selectFrom("active_account as aa")
+		.innerJoin("account_all as a", "a.id", "aa.account_id")
+		.where("a.lixcol_version_id", "=", "global")
+		.select(["a.id", "a.name"])
+		.executeTakeFirst();
+
+	const account2 = await lix2.db
+		.selectFrom("active_account as aa")
+		.innerJoin("account_all as a", "a.id", "aa.account_id")
+		.where("a.lixcol_version_id", "=", "global")
+		.select(["a.id", "a.name"])
+		.executeTakeFirst();
+
+	expect(account0?.name).not.toBe(account1?.name);
+	expect(account1?.name).not.toBe(account2?.name);
+});

package/src/account/schema.ts

@@ -0,0 +1,132 @@
+import type {
+	LixSchemaDefinition,
+	FromLixSchemaDefinition,
+} from "../schema-definition/definition.js";
+import { createEntityViewsIfNotExists } from "../entity-views/entity-view-builder.js";
+import type { SqliteWasmDatabase } from "sqlite-wasm-kysely";
+import { nanoId } from "../deterministic/index.js";
+import type { Lix } from "../lix/open-lix.js";
+
+export function applyAccountDatabaseSchema(
+	sqlite: SqliteWasmDatabase,
+	db: Lix["db"]
+): void {
+	// Create account view using the generalized entity view builder
+	createEntityViewsIfNotExists({
+		lix: { sqlite },
+		schema: LixAccountSchema,
+		overrideName: "account",
+		pluginKey: "lix_own_entity",
+		hardcodedFileId: "lix",
+		defaultValues: {
+			id: () => nanoId({ lix: { sqlite, db } }),
+		},
+	});
+
+	// Create active_account as an entity view (similar to active_version)
+	// Stores references to account IDs, joining with account table for details
+	sqlite.exec(`
+		CREATE VIEW IF NOT EXISTS active_account AS
+		SELECT
+			json_extract(sa.snapshot_content, '$.account_id') AS account_id,
+			sa.inherited_from_version_id AS lixcol_inherited_from_version_id,
+			sa.created_at AS lixcol_created_at,
+			sa.updated_at AS lixcol_updated_at,
+			sa.file_id AS lixcol_file_id,
+			sa.change_id AS lixcol_change_id,
+			sa.untracked AS lixcol_untracked
+		FROM state_all sa
+		WHERE sa.schema_key = 'lix_active_account' AND sa.version_id = 'global';
+
+		CREATE TRIGGER IF NOT EXISTS active_account_insert
+		INSTEAD OF INSERT ON active_account
+		BEGIN
+			INSERT OR REPLACE INTO state_all (
+				entity_id,
+				schema_key,
+				file_id,
+				plugin_key,
+				snapshot_content,
+				schema_version,
+				version_id,
+				untracked
+			) VALUES (
+				'active_' || NEW.account_id,
+				'lix_active_account',
+				'lix',
+				'lix_own_entity',
+				json_object('account_id', NEW.account_id),
+				'1.0',
+				'global',
+				1
+			);
+		END;
+
+		CREATE TRIGGER IF NOT EXISTS active_account_update
+		INSTEAD OF UPDATE ON active_account
+		BEGIN
+			UPDATE state_all
+			SET
+				snapshot_content = json_object('account_id', NEW.account_id),
+				untracked = 1
+			WHERE
+				entity_id = 'active_' || OLD.account_id
+				AND schema_key = 'lix_active_account'
+				AND version_id = 'global';
+		END;
+
+		CREATE TRIGGER IF NOT EXISTS active_account_delete
+		INSTEAD OF DELETE ON active_account
+		BEGIN
+			DELETE FROM state_all
+			WHERE entity_id = 'active_' || OLD.account_id
+			AND schema_key = 'lix_active_account'
+			AND version_id = 'global';
+		END;
+	`);
+}
+
+export const LixAccountSchema = {
+	"x-lix-key": "lix_account",
+	"x-lix-version": "1.0",
+	"x-lix-primary-key": ["id"],
+	type: "object",
+	properties: {
+		id: { type: "string", "x-lix-generated": true },
+		name: { type: "string" },
+	},
+	required: ["id", "name"],
+	additionalProperties: false,
+} as const;
+LixAccountSchema satisfies LixSchemaDefinition;
+
+// Pure business logic type (inferred from schema)
+export type LixAccount = FromLixSchemaDefinition<typeof LixAccountSchema>;
+
+// Active account schema definition
+export const LixActiveAccountSchema = {
+	"x-lix-key": "lix_active_account",
+	"x-lix-version": "1.0",
+	"x-lix-primary-key": ["account_id"],
+	"x-lix-foreign-keys": [
+		{
+			properties: ["account_id"],
+			references: {
+				schemaKey: "lix_account",
+				properties: ["id"],
+			},
+		},
+	],
+	type: "object",
+	properties: {
+		account_id: { type: "string" },
+	},
+	required: ["account_id"],
+	additionalProperties: false,
+} as const;
+LixActiveAccountSchema satisfies LixSchemaDefinition;
+
+// Active account type
+export type LixActiveAccount = FromLixSchemaDefinition<
+	typeof LixActiveAccountSchema
+>;

package/src/account/switch-account.test.ts

@@ -1,14 +1,28 @@
 import { test, expect } from "vitest";
-import { openLixInMemory } from "../lix/open-lix-in-memory.js";
+import { openLix } from "../lix/open-lix.js";
 import { createAccount } from "./create-account.js";
 import { switchAccount } from "./switch-account.js";
+import { createVersion } from "../version/create-version.js";
 
 test("should switch the current account", async () => {
-	const lix = await openLixInMemory({});
+	const lix = await openLix({});
+
+	const version = await createVersion({
+		lix,
+		id: "test-version",
+	});
 
 	// Create two accounts
-	const account1 = await createAccount({ lix, name: "account1" });
-	const account2 = await createAccount({ lix, name: "account2" });
+	const account1 = await createAccount({
+		lix,
+		name: "account1",
+		lixcol_version_id: version.id,
+	});
+	const account2 = await createAccount({
+		lix,
+		name: "account2",
+		lixcol_version_id: version.id,
+	});
 
 	// Switch to account1
 	await switchAccount({ lix, to: [account1] });
@@ -19,7 +33,7 @@ test("should switch the current account", async () => {
 		.selectAll()
 		.executeTakeFirstOrThrow();
 
-	expect(activeAccount.id).toBe(account1.id);
+	expect(activeAccount.account_id).toBe(account1.id);
 
 	// Switch to account2
 	await switchAccount({ lix, to: [account2] });
@@ -30,14 +44,23 @@ test("should switch the current account", async () => {
 		.selectAll()
 		.executeTakeFirstOrThrow();
 
-	expect(activeAccount.id).toBe(account2.id);
+	expect(activeAccount.account_id).toBe(account2.id);
 });
 
 test("should handle switching to the same account", async () => {
-	const lix = await openLixInMemory({});
+	const lix = await openLix({});
+
+	const version = await createVersion({
+		lix,
+		id: "test-version-2",
+	});
 
 	// Create an account
-	const account = await createAccount({ lix, name: "account" });
+	const account = await createAccount({
+		lix,
+		name: "account",
+		lixcol_version_id: version.id,
+	});
 
 	// Switch to the account
 	await switchAccount({ lix, to: [account] });
@@ -48,7 +71,7 @@ test("should handle switching to the same account", async () => {
 		.selectAll()
 		.executeTakeFirstOrThrow();
 
-	expect(activeAccount.id).toBe(account.id);
+	expect(activeAccount.account_id).toBe(account.id);
 
 	// Switch to the same account again
 	await switchAccount({ lix, to: [account] });
@@ -59,5 +82,5 @@ test("should handle switching to the same account", async () => {
 		.selectAll()
 		.executeTakeFirstOrThrow();
 
-	expect(activeAccount.id).toBe(account.id);
+	expect(activeAccount.account_id).toBe(account.id);
 });

package/src/account/switch-account.ts

@@ -1,5 +1,5 @@
 import type { Lix } from "../lix/open-lix.js";
-import type { Account } from "./database-schema.js";
+import type { LixAccount } from "./schema.js";
 
 /**
  * Switch the current account to the provided account.
@@ -22,13 +22,22 @@ import type { Account } from "./database-schema.js";
  */
 export async function switchAccount(args: {
 	lix: Pick<Lix, "db">;
-	to: Account[];
+	to: Pick<LixAccount, "id" | "name">[];
 }): Promise<void> {
 	const executeInTransaction = async (trx: Lix["db"]) => {
-		// delete all rows from the current_account table
+		// Delete all active account entries (both tracked and untracked)
 		await trx.deleteFrom("active_account").execute();
+
 		// insert the new account id into the current_account table
-		await trx.insertInto("active_account").values(args.to).execute();
+		// active_account view only has account_id column
+		await trx
+			.insertInto("active_account")
+			.values(
+				args.to.map((account) => ({
+					account_id: account.id,
+				}))
+			)
+			.execute();
 	};
 
 	if (args.lix.db.isTransaction) {

package/src/change/index.ts

@@ -1,2 +1,4 @@
-export { createChange } from "./create-change.js";
-export { applyChanges } from "./apply-changes.js";
+export {
+	type LixChange as Change,
+	type NewLixChange as NewChange,
+} from "./schema.js";