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

package/src/account/schema.test.ts

@@ -22,6 +22,7 @@ test("insert, update, delete on the account view", async () => {
 	const viewAfterInsert = await lix.db
 		.selectFrom("account")
 		.select(["id", "name"])
+		.where("id", "in", ["account0", "account1"])
 		.orderBy("id")
 		.execute();
 
@@ -47,6 +48,7 @@ test("insert, update, delete on the account view", async () => {
 	const viewAfterUpdate = await lix.db
 		.selectFrom("account")
 		.orderBy("id")
+		.where("id", "in", ["account0", "account1"])
 		.select(["id", "name"])
 		.execute();
 
@@ -66,6 +68,7 @@ test("insert, update, delete on the account view", async () => {
 	const viewAfterDelete = await lix.db
 		.selectFrom("account")
 		.orderBy("id")
+		.where("id", "in", ["account0", "account1"])
 		.select(["id", "name"])
 		.execute();
 
@@ -134,12 +137,14 @@ test("account operations are version specific and isolated", async () => {
 	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();
 
@@ -184,12 +189,14 @@ test("account operations are version specific and isolated", async () => {
 	// 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();
@@ -202,21 +209,32 @@ test("account operations are version specific and isolated", async () => {
 test("active_account temp table operations", async () => {
 	const lix = await openLix({});
 
-	// Check if the default anonymous account was created
+	// Check if the default anonymous account was created with proper details
 	const activeAccounts = await lix.db
-		.selectFrom("active_account")
-		.selectAll()
+		.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+$/);
 
-	// Insert a new active account
+	// First create a real account in global version (where active accounts look)
 	await lix.db
-		.insertInto("active_account")
+		.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();
 
@@ -226,27 +244,42 @@ test("active_account temp table operations", async () => {
 		.execute();
 
 	expect(updatedActiveAccounts).toHaveLength(2);
-	expect(updatedActiveAccounts.some((acc) => acc.name === "Alice")).toBe(true);
-
-	// Update active account
+	// 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("active_account")
+		.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("id", "=", "user123")
+		.where("account_id", "=", "user123")
 		.selectAll()
 		.execute();
 
-	expect(afterUpdate[0]?.name).toBe("Alice Updated");
+	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("id", "=", "user123")
+		.where("account_id", "=", "user123")
 		.execute();
 
 	const afterDelete = await lix.db
@@ -255,24 +288,54 @@ test("active_account temp table operations", async () => {
 		.execute();
 
 	expect(afterDelete).toHaveLength(1);
-	expect(afterDelete.some((acc) => acc.id === "user123")).toBe(false);
+	expect(afterDelete.some((acc) => acc.account_id === "user123")).toBe(false);
 });
 
-test("account table should have no entries initially but active_account should have default", async () => {
+test("account table should have one untracked entry initially and active_account should reference it", 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")
+	// Check the anonymous account in account_all (includes untracked)
+	const allAccounts = await lix.db
+		.selectFrom("account_all")
 		.selectAll()
 		.execute();
 
-	expect(activeAccounts).toHaveLength(1);
-	expect(activeAccounts[0]?.name).toMatch(/^Anonymous \w+$/);
+	// 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 () => {
@@ -280,91 +343,28 @@ test("should generate different anonymous account names", async () => {
 	const lix1 = await openLix({});
 	const lix2 = await openLix({});
 
+	// Get active accounts with details using joins
 	const account0 = await lix0.db
-		.selectFrom("active_account")
-		.selectAll()
+		.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")
-		.selectAll()
+		.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")
-		.selectAll()
+		.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);
 });
-
-// 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

@@ -1,14 +1,16 @@
-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";
+import { nanoId } from "../deterministic/index.js";
+import type { Lix } from "../lix/open-lix.js";
 
-export function applyAccountDatabaseSchema(sqlite: SqliteWasmDatabase): void {
+export function applyAccountDatabaseSchema(
+	sqlite: SqliteWasmDatabase,
+	db: Lix["db"]
+): void {
 	// Create account view using the generalized entity view builder
 	createEntityViewsIfNotExists({
 		lix: { sqlite },
@@ -17,36 +19,70 @@ export function applyAccountDatabaseSchema(sqlite: SqliteWasmDatabase): void {
 		pluginKey: "lix_own_entity",
 		hardcodedFileId: "lix",
 		defaultValues: {
-			id: () => nanoid(),
+			id: () => nanoId({ lix: { sqlite, db } }),
 		},
 	});
 
-	// Create session-specific temp table
+	// Create active_account as an entity view (similar to active_version)
+	// Stores references to account IDs, joining with account table for details
 	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;
-	`);
+		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';
 
-	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)}`;
+		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;
 
-	// Insert default account
-	sqlite.exec(`
-		-- default to a new account
-		INSERT INTO active_account (id, name) values (nano_id(), '${anonymousAccountName}');
+		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;
 	`);
 }
 
@@ -65,12 +101,32 @@ export const LixAccountSchema = {
 LixAccountSchema satisfies LixSchemaDefinition;
 
 // Pure business logic type (inferred from schema)
-export type Account = FromLixSchemaDefinition<typeof LixAccountSchema>;
+export type LixAccount = FromLixSchemaDefinition<typeof LixAccountSchema>;
 
-// Active account table type (temp table)
-export type ActiveAccountTable = {
-	id: string;
-	name: string;
-};
+// 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;
 
-export type ActiveAccount = Selectable<ActiveAccountTable>;
+// Active account type
+export type LixActiveAccount = FromLixSchemaDefinition<
+	typeof LixActiveAccountSchema
+>;

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

@@ -33,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] });
@@ -44,7 +44,7 @@ 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 () => {
@@ -71,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] });
@@ -82,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 "./schema.js";
+import type { LixAccount } from "./schema.js";
 
 /**
  * Switch the current account to the provided account.
@@ -22,19 +22,19 @@ import type { Account } from "./schema.js";
  */
 export async function switchAccount(args: {
 	lix: Pick<Lix, "db">;
-	to: Pick<Account, "id" | "name">[];
+	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
-		// active_account table only has id and name columns
+		// active_account view only has account_id column
 		await trx
 			.insertInto("active_account")
 			.values(
 				args.to.map((account) => ({
-					id: account.id,
-					name: account.name,
+					account_id: account.id,
 				}))
 			)
 			.execute();

package/src/change/index.ts

@@ -1 +1,4 @@
-export { type Change, type NewChange } from "./schema.js";
+export {
+	type LixChange as Change,
+	type NewLixChange as NewChange,
+} from "./schema.js";

package/src/change/schema.test.ts

@@ -282,3 +282,41 @@ test("inserting a change with snapshot_content: null uses no-content snapshot",
 	expect(internalChange).toBeDefined();
 	expect(internalChange?.snapshot_id).toBe("no-content");
 });
+
+test("changes in transaction can be accessed via change view", async () => {
+	const lix = await openLix({});
+
+	await lix.db.transaction().execute(async (trx) => {
+		// Insert a key-value entity within transaction
+		await trx
+			.insertInto("key_value")
+			.values({
+				key: "test_key_in_transaction",
+				value: "test_value",
+			})
+			.execute();
+
+		// This should create a change in internal_change_in_transaction
+		// The change view should include changes from both internal_change and internal_change_in_transaction
+
+		// Try to find the change within the transaction via the change view
+		const changesInTransaction = await trx
+			.selectFrom("change")
+			.where("entity_id", "=", "test_key_in_transaction")
+			.where("schema_key", "=", "lix_key_value")
+			.selectAll()
+			.execute();
+
+		// This should find the change that was created in internal_change_in_transaction
+		expect(changesInTransaction).toHaveLength(1);
+		expect(changesInTransaction[0]).toMatchObject({
+			entity_id: "test_key_in_transaction",
+			schema_key: "lix_key_value",
+			file_id: "lix",
+			snapshot_content: {
+				key: "test_key_in_transaction",
+				value: "test_value",
+			},
+		});
+	});
+});