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

package/src/account/schema.test.ts

@@ -1,6 +1,9 @@
+import { sql } from "kysely";
+import { LixActiveAccountSchema } from "./schema-definition.js";
 import { test, expect } from "vitest";
 import { openLix } from "../lix/open-lix.js";
 import { createVersion } from "../version/create-version.js";
+import { createPreprocessor } from "../engine/preprocessor/create-preprocessor.js";
 
 test("insert, update, delete on the account view", async () => {
 	const lix = await openLix({});
@@ -22,6 +25,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 +51,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 +71,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();
 
@@ -112,7 +118,7 @@ test("account operations are version specific and isolated", async () => {
 
 	// Insert account in version A
 	await lix.db
-		.insertInto("account_all")
+		.insertInto("account_by_version")
 		.values({
 			id: "accountA",
 			name: "User A",
@@ -122,7 +128,7 @@ test("account operations are version specific and isolated", async () => {
 
 	// Insert account in version B with same id but different name
 	await lix.db
-		.insertInto("account_all")
+		.insertInto("account_by_version")
 		.values({
 			id: "accountB",
 			name: "User B",
@@ -132,14 +138,16 @@ test("account operations are version specific and isolated", async () => {
 
 	// Verify both versions have their own accounts
 	const accountsInVersionA = await lix.db
-		.selectFrom("account_all")
+		.selectFrom("account_by_version")
 		.where("lixcol_version_id", "=", versionA.id)
+		.where("id", "in", ["accountA", "accountB"])
 		.selectAll()
 		.execute();
 
 	const accountsInVersionB = await lix.db
-		.selectFrom("account_all")
+		.selectFrom("account_by_version")
 		.where("lixcol_version_id", "=", versionB.id)
+		.where("id", "in", ["accountA", "accountB"])
 		.selectAll()
 		.execute();
 
@@ -150,7 +158,7 @@ test("account operations are version specific and isolated", async () => {
 
 	// Update account in version A
 	await lix.db
-		.updateTable("account_all")
+		.updateTable("account_by_version")
 		.where("id", "=", "accountA")
 		.where("lixcol_version_id", "=", versionA.id)
 		.set({
@@ -160,14 +168,16 @@ test("account operations are version specific and isolated", async () => {
 
 	// Verify update only affected version A
 	const updatedAccountsA = await lix.db
-		.selectFrom("account_all")
+		.selectFrom("account_by_version")
 		.where("lixcol_version_id", "=", versionA.id)
+		.where("id", "=", "accountA")
 		.selectAll()
 		.execute();
 
 	const unchangedAccountsB = await lix.db
-		.selectFrom("account_all")
+		.selectFrom("account_by_version")
 		.where("lixcol_version_id", "=", versionB.id)
+		.where("id", "=", "accountB")
 		.selectAll()
 		.execute();
 
@@ -176,20 +186,22 @@ test("account operations are version specific and isolated", async () => {
 
 	// Delete account from version A
 	await lix.db
-		.deleteFrom("account_all")
+		.deleteFrom("account_by_version")
 		.where("id", "=", "accountA")
 		.where("lixcol_version_id", "=", versionA.id)
 		.execute();
 
 	// Verify deletion only affected version A
 	const remainingAccountsA = await lix.db
-		.selectFrom("account_all")
+		.selectFrom("account_by_version")
+		.where("id", "in", ["accountA", "accountB"])
 		.where("lixcol_version_id", "=", versionA.id)
 		.selectAll()
 		.execute();
 
 	const remainingAccountsB = await lix.db
-		.selectFrom("account_all")
+		.selectFrom("account_by_version")
+		.where("id", "in", ["accountA", "accountB"])
 		.where("lixcol_version_id", "=", versionB.id)
 		.selectAll()
 		.execute();
@@ -202,21 +214,31 @@ 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
+	// No accounts should exist by default
 	const activeAccounts = await lix.db
-		.selectFrom("active_account")
-		.selectAll()
+		.selectFrom("active_account as aa")
+		.innerJoin("account_by_version 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+$/);
+	expect(activeAccounts).toHaveLength(0);
 
-	// 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_by_version")
 		.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();
 
@@ -225,28 +247,41 @@ test("active_account temp table operations", async () => {
 		.selectAll()
 		.execute();
 
-	expect(updatedActiveAccounts).toHaveLength(2);
-	expect(updatedActiveAccounts.some((acc) => acc.name === "Alice")).toBe(true);
+	expect(updatedActiveAccounts).toHaveLength(1);
+	const aliceActive = updatedActiveAccounts.find(
+		(acc) => acc.account_id === "user123"
+	);
+	expect(aliceActive).toBeDefined();
+	expect(aliceActive?.account_id).toBe("user123");
 
-	// Update active account
+	// Update the actual account (not the active account reference)
 	await lix.db
-		.updateTable("active_account")
+		.updateTable("account_by_version")
 		.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_by_version")
+		.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
@@ -254,117 +289,121 @@ test("active_account temp table operations", async () => {
 		.selectAll()
 		.execute();
 
-	expect(afterDelete).toHaveLength(1);
-	expect(afterDelete.some((acc) => acc.id === "user123")).toBe(false);
+	expect(afterDelete).toHaveLength(0);
 });
 
-test("account table should have no entries initially but active_account should have default", async () => {
+test("account tables start empty until an account is created", 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")
+	const allAccounts = await lix.db
+		.selectFrom("account_by_version")
 		.selectAll()
 		.execute();
 
-	expect(activeAccounts).toHaveLength(1);
-	expect(activeAccounts[0]?.name).toMatch(/^Anonymous \w+$/);
+	expect(allAccounts.length).toBe(0);
+
+	const activeAccount = await lix.db
+		.selectFrom("active_account as aa")
+		.innerJoin("account_by_version as a", "a.id", "aa.account_id")
+		.where("a.lixcol_version_id", "=", "global")
+		.select(["aa.account_id", "a.id", "a.name"])
+		.executeTakeFirst();
+
+	expect(activeAccount).toBeUndefined();
 });
 
-test("should generate different anonymous account names", async () => {
-	const lix0 = await openLix({});
-	const lix1 = await openLix({});
-	const lix2 = await openLix({});
+test("active_account should enforce foreign key constraint on account_id", async () => {
+	const lix = await openLix({});
 
-	const account0 = await lix0.db
-		.selectFrom("active_account")
-		.selectAll()
-		.executeTakeFirst();
+	// 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);
+});
 
-	const account1 = await lix1.db
-		.selectFrom("active_account")
-		.selectAll()
-		.executeTakeFirst();
+test("active_account view injects global version defaults", async () => {
+	const lix = await openLix({});
 
-	const account2 = await lix2.db
-		.selectFrom("active_account")
-		.selectAll()
-		.executeTakeFirst();
+	await lix.db
+		.insertInto("account_by_version")
+		.values({
+			id: "acct-1",
+			name: "Global User",
+			lixcol_version_id: "global",
+		})
+		.execute();
+
+	await lix.db
+		.insertInto("active_account")
+		.values({ account_id: "acct-1" })
+		.execute();
+
+	const row = await lix.db
+		.selectFrom("state_by_version")
+		.select([
+			"schema_key",
+			"file_id",
+			"plugin_key",
+			"version_id",
+			"untracked",
+			"inherited_from_version_id",
+		])
+		.where("schema_key", "=", "lix_active_account")
+		.where("inherited_from_version_id", "is", "global")
+		.where("entity_id", "=", "acct-1")
+		.executeTakeFirstOrThrow();
+
+	expect(row).toMatchObject({
+		schema_key: "lix_active_account",
+		file_id: "lix",
+		plugin_key: "lix_sdk",
+		untracked: 1,
+	});
+	expect(row.version_id).toBeDefined();
 
-	expect(account0?.name).not.toBe(account1?.name);
-	expect(account1?.name).not.toBe(account2?.name);
+	const activeVersion = await lix.db
+		.selectFrom("active_version")
+		.select(["lixcol_inherited_from_version_id" as any])
+		.executeTakeFirstOrThrow();
+
+	expect(activeVersion.lixcol_inherited_from_version_id).toBe("global");
+
+	await lix.close();
 });
 
-// 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({});
+test("active_account schema exposes only the base view", async () => {
+	const lix = await openLix({});
 
-		const version = await createVersion({
-			lix,
-			id: "version1",
-		});
+	const storedSchema = {
+		...LixActiveAccountSchema,
+		"x-lix-version": "1.1",
+	} as const;
+	await lix.db
+		.insertInto("stored_schema")
+		.values({ value: storedSchema })
+		.execute();
 
-		// Insert a regular account
-		await lix.db
-			.insertInto("account_all")
-			.values({
-				id: "test-account",
-				name: "Test User",
-				lixcol_version_id: version.id,
-			})
-			.execute();
+	const preprocess = createPreprocessor({ engine: lix.engine! });
+	const rewritten = preprocess({
+		sql: "SELECT * FROM active_account_by_version",
+		parameters: [],
+	});
 
-		// 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();
+	expect(rewritten.sql).toContain("active_account_by_version");
+	expect(rewritten.sql).not.toContain("schema_key = 'lix_active_account'");
 
-		// Verify the active account is set
-		const currentAccount = await lix.db
-			.selectFrom("active_account")
-			.selectAll()
-			.executeTakeFirst();
+	await expect(
+		sql`SELECT * FROM active_account_by_version`.execute(lix.db)
+	).rejects.toThrow(/no such table/i);
 
-		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",
-		});
-	}
-);
+	await expect(
+		sql`SELECT * FROM active_account_history`.execute(lix.db)
+	).rejects.toThrow(/no such table/i);
+
+	await lix.close();
+});

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

@@ -2,26 +2,20 @@ import { test, expect } from "vitest";
 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 () => {
+test("should switch the active account", async () => {
 	const lix = await openLix({});
 
-	const version = await createVersion({
-		lix,
-		id: "test-version",
-	});
-
 	// Create two accounts
 	const account1 = await createAccount({
 		lix,
-		name: "account1",
-		lixcol_version_id: version.id,
+		id: "account1",
+		name: "Account One",
 	});
 	const account2 = await createAccount({
 		lix,
-		name: "account2",
-		lixcol_version_id: version.id,
+		id: "account2",
+		name: "Account Two",
 	});
 
 	// Switch to account1
@@ -33,7 +27,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,22 +38,16 @@ 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 openLix({});
 
-	const version = await createVersion({
-		lix,
-		id: "test-version-2",
-	});
-
 	// Create an account
 	const account = await createAccount({
 		lix,
 		name: "account",
-		lixcol_version_id: version.id,
 	});
 
 	// Switch to the account
@@ -71,7 +59,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 +70,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-definition.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-definition.js";

package/src/change/schema-definition.ts

@@ -0,0 +1,84 @@
+import type { Insertable, Selectable, Generated } from "kysely";
+import type {
+	LixSchemaDefinition,
+	FromLixSchemaDefinition,
+} from "../schema-definition/definition.js";
+
+export type ChangeView = {
+	id: Generated<string>;
+	entity_id: string;
+	schema_key: string;
+	schema_version: string;
+	file_id: string;
+	plugin_key: string;
+	metadata?: Record<string, any> | null;
+	created_at: Generated<string>;
+	snapshot_content: Record<string, any> | null;
+};
+
+export type LixChange = Selectable<ChangeView>;
+export type NewLixChange = Insertable<ChangeView>;
+
+export type InternalChangeTable = {
+	id: Generated<string>;
+	entity_id: string;
+	schema_key: string;
+	schema_version: string;
+	file_id: string;
+	plugin_key: string;
+	snapshot_id: string;
+	metadata?: Record<string, any> | null;
+	created_at: Generated<string>;
+};
+
+export type InternalChange = Selectable<InternalChangeTable>;
+export type NewInternalChange = Insertable<InternalChangeTable>;
+
+/**
+ * Raw change payload where `snapshot_content` remains as serialized JSON.
+ *
+ * Useful when piping changes between SQLite and the cache layer without
+ * incurring double parse/serialize overhead.
+ */
+export type LixChangeRaw = Omit<LixChange, "snapshot_content" | "metadata"> & {
+	snapshot_content: string | null;
+	metadata?: string | null;
+};
+
+export const LixChangeSchema = {
+	"x-lix-key": "lix_change",
+	"x-lix-version": "1.0",
+	"x-lix-primary-key": ["/id"],
+	"x-lix-override-lixcols": {
+		lixcol_file_id: '"lix"',
+		lixcol_plugin_key: '"lix_sdk"',
+	},
+	type: "object",
+	properties: {
+		id: {
+			type: "string",
+			"x-lix-default": "lix_uuid_v7()",
+		},
+		entity_id: { type: "string" },
+		schema_key: { type: "string" },
+		schema_version: { type: "string" },
+		file_id: { type: "string" },
+		plugin_key: { type: "string" },
+		metadata: { type: ["object", "null"] },
+		created_at: { type: "string" },
+		snapshot_content: { type: ["object", "null"] },
+	},
+	required: [
+		"id",
+		"entity_id",
+		"schema_key",
+		"schema_version",
+		"file_id",
+		"plugin_key",
+		"created_at",
+	],
+	additionalProperties: false,
+} as const;
+LixChangeSchema satisfies LixSchemaDefinition;
+
+export type LixChangeSnapshot = FromLixSchemaDefinition<typeof LixChangeSchema>;