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

package/src/account/create-account.ts

@@ -1,17 +1,47 @@
 import type { Lix } from "../lix/open-lix.js";
-import type { Account } from "./database-schema.js";
+import type { Account } from "./schema.js";
+import { v7 as uuid_v7 } from "uuid";
+
+/**
+ * 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;
+	lix: Pick<Lix, "db">;
+	id?: Account["id"];
+	name: Account["name"];
+	lixcol_version_id?: string;
 }): Promise<Account> {
 	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 || uuid_v7();
+
+		// 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 Account,
+	type 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"])
+		.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")
+		.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")
+		.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)
+		.selectAll()
+		.execute();
+
+	const accountsInVersionB = await lix.db
+		.selectFrom("account_all")
+		.where("lixcol_version_id", "=", versionB.id)
+		.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("lixcol_version_id", "=", versionA.id)
+		.selectAll()
+		.execute();
+
+	const remainingAccountsB = await lix.db
+		.selectFrom("account_all")
+		.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
+	const activeAccounts = await lix.db
+		.selectFrom("active_account")
+		.selectAll()
+		.execute();
+
+	expect(activeAccounts).toHaveLength(1);
+	expect(activeAccounts[0]?.name).toMatch(/^Anonymous \w+$/);
+
+	// Insert a new active account
+	await lix.db
+		.insertInto("active_account")
+		.values({
+			id: "user123",
+			name: "Alice",
+		})
+		.execute();
+
+	const updatedActiveAccounts = await lix.db
+		.selectFrom("active_account")
+		.selectAll()
+		.execute();
+
+	expect(updatedActiveAccounts).toHaveLength(2);
+	expect(updatedActiveAccounts.some((acc) => acc.name === "Alice")).toBe(true);
+
+	// Update active account
+	await lix.db
+		.updateTable("active_account")
+		.where("id", "=", "user123")
+		.set({ name: "Alice Updated" })
+		.execute();
+
+	const afterUpdate = await lix.db
+		.selectFrom("active_account")
+		.where("id", "=", "user123")
+		.selectAll()
+		.execute();
+
+	expect(afterUpdate[0]?.name).toBe("Alice Updated");
+
+	// Delete active account
+	await lix.db
+		.deleteFrom("active_account")
+		.where("id", "=", "user123")
+		.execute();
+
+	const afterDelete = await lix.db
+		.selectFrom("active_account")
+		.selectAll()
+		.execute();
+
+	expect(afterDelete).toHaveLength(1);
+	expect(afterDelete.some((acc) => acc.id === "user123")).toBe(false);
+});
+
+test("account table should have no entries initially but active_account should have default", async () => {
+	const lix = await openLix({});
+
+	// Check that account table is empty
+	const accounts = await lix.db.selectFrom("account").selectAll().execute();
+	expect(accounts).toHaveLength(0);
+
+	// Check that active_account has a default entry
+	const activeAccounts = await lix.db
+		.selectFrom("active_account")
+		.selectAll()
+		.execute();
+
+	expect(activeAccounts).toHaveLength(1);
+	expect(activeAccounts[0]?.name).toMatch(/^Anonymous \w+$/);
+});
+
+test("should generate different anonymous account names", async () => {
+	const lix0 = await openLix({});
+	const lix1 = await openLix({});
+	const lix2 = await openLix({});
+
+	const account0 = await lix0.db
+		.selectFrom("active_account")
+		.selectAll()
+		.executeTakeFirst();
+
+	const account1 = await lix1.db
+		.selectFrom("active_account")
+		.selectAll()
+		.executeTakeFirst();
+
+	const account2 = await lix2.db
+		.selectFrom("active_account")
+		.selectAll()
+		.executeTakeFirst();
+
+	expect(account0?.name).not.toBe(account1?.name);
+	expect(account1?.name).not.toBe(account2?.name);
+});
+
+// TODO reopening a lix leads to "no tables specified"
+test.todo(
+	'it should drop the temp "active_account" table on reboot to not persist the current account',
+	async () => {
+		const lix = await openLix({});
+
+		const version = await createVersion({
+			lix,
+			id: "version1",
+		});
+
+		// Insert a regular account
+		await lix.db
+			.insertInto("account_all")
+			.values({
+				id: "test-account",
+				name: "Test User",
+				lixcol_version_id: version.id,
+			})
+			.execute();
+
+		// Clear the active_account and set it to our test account
+		await lix.db.deleteFrom("active_account").execute();
+		await lix.db
+			.insertInto("active_account")
+			.values({
+				id: "test-account",
+				name: "Test User",
+			})
+			.execute();
+
+		// Verify the active account is set
+		const currentAccount = await lix.db
+			.selectFrom("active_account")
+			.selectAll()
+			.executeTakeFirst();
+
+		expect(currentAccount).toMatchObject({
+			id: "test-account",
+			name: "Test User",
+		});
+
+		// Serialize and reload the database (simulating restart)
+		const blob = await lix.toBlob();
+		const lix2 = await openLix({ blob });
+
+		// Verify that active_account got reset to a new anonymous account
+		const reloadedActiveAccount = await lix2.db
+			.selectFrom("active_account")
+			.selectAll()
+			.executeTakeFirst();
+
+		expect(reloadedActiveAccount?.id).not.toBe("test-account");
+		expect(reloadedActiveAccount?.name).toMatch(/^Anonymous \w+$/);
+		expect(reloadedActiveAccount?.name).not.toBe("Test User");
+
+		// But the regular account should still exist
+		const persistedAccount = await lix2.db
+			.selectFrom("account")
+			.where("id", "=", "test-account")
+			.selectAll()
+			.executeTakeFirst();
+
+		expect(persistedAccount).toMatchObject({
+			id: "test-account",
+			name: "Test User",
+		});
+	}
+);

package/src/account/schema.ts

@@ -0,0 +1,76 @@
+import type { Selectable } from "kysely";
+import type {
+	LixSchemaDefinition,
+	FromLixSchemaDefinition,
+} from "../schema-definition/definition.js";
+import { humanId } from "human-id";
+import { nanoid } from "../database/nano-id.js";
+import { createEntityViewsIfNotExists } from "../entity-views/entity-view-builder.js";
+import type { SqliteWasmDatabase } from "sqlite-wasm-kysely";
+
+export function applyAccountDatabaseSchema(sqlite: SqliteWasmDatabase): 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(),
+		},
+	});
+
+	// Create session-specific temp table
+	sqlite.exec(`
+		-- current account(s)
+		-- temp table because current accounts are session
+		-- specific and should not be persisted
+		CREATE TEMP TABLE IF NOT EXISTS active_account (
+			id TEXT PRIMARY KEY,
+			name TEXT NOT NULL
+			-- can't use foreign keys in temp tables... :(
+		) STRICT;
+	`);
+
+	const anonymousAccountName = `Anonymous ${humanId({
+		capitalize: true,
+		adjectiveCount: 0,
+		separator: "_",
+	})
+		// Human ID has two words, remove the last one
+		.split("_")[0]!
+		// Human ID uses plural, remove the last character to make it singular
+		.slice(0, -1)}`;
+
+	// Insert default account
+	sqlite.exec(`
+		-- default to a new account
+		INSERT INTO active_account (id, name) values (nano_id(), '${anonymousAccountName}');
+	`);
+}
+
+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 Account = FromLixSchemaDefinition<typeof LixAccountSchema>;
+
+// Active account table type (temp table)
+export type ActiveAccountTable = {
+	id: string;
+	name: string;
+};
+
+export type ActiveAccount = Selectable<ActiveAccountTable>;

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] });
@@ -34,10 +48,19 @@ test("should switch the current account", async () => {
 });
 
 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] });

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 { Account } 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<Account, "id" | "name">[];
 }): Promise<void> {
 	const executeInTransaction = async (trx: Lix["db"]) => {
 		// delete all rows from the current_account table
 		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 table only has id and name columns
+		await trx
+			.insertInto("active_account")
+			.values(
+				args.to.map((account) => ({
+					id: account.id,
+					name: account.name,
+				}))
+			)
+			.execute();
 	};
 
 	if (args.lix.db.isTransaction) {

package/src/change/index.ts

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