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

package/src/lix/storage/opfs.ts

@@ -4,8 +4,9 @@ import {
 	importDatabase,
 	contentFromDatabase,
 } from "sqlite-wasm-kysely";
-import { newLixFile } from "../new-lix.js";
 import type { LixStorageAdapter } from "./lix-storage-adapter.js";
+import type { LixAccount } from "../../account/schema.js";
+import type { Lix } from "../open-lix.js";
 
 /**
  * OPFS (Origin Private File System) storage adapter for Lix.
@@ -16,11 +17,45 @@ import type { LixStorageAdapter } from "./lix-storage-adapter.js";
  * Features auto-saving functionality when integrated with the hooks system.
  */
 export class OpfsStorage implements LixStorageAdapter {
+	/**
+	 * Cleans the entire OPFS by removing all files.
+	 * Useful for debugging and testing.
+	 *
+	 * TODO refactor to only delete opfs adapter related files
+	 *      after https://github.com/opral/lix-sdk/issues/332 is implemented.
+	 *
+	 * @warning This will delete ALL files in OPFS, not just Lix files!
+	 */
+	static async clean(): Promise<void> {
+		// Check if OPFS is supported
+		if (
+			!("navigator" in globalThis) ||
+			!("storage" in navigator) ||
+			!("getDirectory" in navigator.storage)
+		) {
+			throw new Error("OPFS is not supported in this environment");
+		}
+
+		const root = await navigator.storage.getDirectory();
+
+		// List all entries in the root directory
+		// @ts-expect-error - values() is not in the TypeScript definitions yet
+		for await (const entry of root.values()) {
+			if (entry.kind === "file") {
+				await root.removeEntry(entry.name);
+			} else if (entry.kind === "directory") {
+				await root.removeEntry(entry.name, { recursive: true });
+			}
+		}
+	}
+
 	private database?: SqliteWasmDatabase;
 	private readonly path: string;
 	private opfsRoot?: FileSystemDirectoryHandle;
 	private savePromise?: Promise<void>;
 	private pendingSave = false;
+	private activeAccounts?: Pick<LixAccount, "id" | "name">[];
+	private activeAccountSubscription?: { unsubscribe(): void };
 
 	/**
 	 * Creates a new OpfsStorage instance.
@@ -46,32 +81,48 @@ export class OpfsStorage implements LixStorageAdapter {
 	 * Loads existing data from OPFS if available, otherwise creates a new lix.
 	 * Returns the same database instance on subsequent calls.
 	 */
-	async open(): Promise<SqliteWasmDatabase> {
+	async open(args: {
+		blob?: Blob;
+		createBlob: () => Promise<Blob>;
+	}): Promise<SqliteWasmDatabase> {
 		if (!this.database) {
 			this.database = await createInMemoryDatabase({ readOnly: false });
 			this.opfsRoot = await navigator.storage.getDirectory();
 
-			try {
-				// Try to load existing data from OPFS
-				const fileHandle = await this.opfsRoot.getFileHandle(this.path);
-				const file = await fileHandle.getFile();
-				const content = new Uint8Array(await file.arrayBuffer());
-
-				importDatabase({
-					db: this.database,
-					content,
-				});
-			} catch {
-				// File doesn't exist, create new empty lix
-				const blob = await newLixFile();
+			if (args.blob) {
+				// Use provided blob
 				importDatabase({
 					db: this.database,
-					content: new Uint8Array(await blob.arrayBuffer()),
+					content: new Uint8Array(await args.blob.arrayBuffer()),
 				});
-
-				// Save the initial state to OPFS
+				// Save the imported state to OPFS
 				await this.save();
+			} else {
+				try {
+					// Try to load existing data from OPFS
+					const fileHandle = await this.opfsRoot.getFileHandle(this.path);
+					const file = await fileHandle.getFile();
+					const content = new Uint8Array(await file.arrayBuffer());
+
+					importDatabase({
+						db: this.database,
+						content,
+					});
+				} catch {
+					// File doesn't exist, create new one
+					const blob = await args.createBlob();
+					importDatabase({
+						db: this.database,
+						content: new Uint8Array(await blob.arrayBuffer()),
+					});
+
+					// Save the initial state to OPFS
+					await this.save();
+				}
 			}
+
+			// Load active accounts if they exist
+			await this.loadActiveAccounts();
 		}
 
 		return this.database;
@@ -87,30 +138,23 @@ export class OpfsStorage implements LixStorageAdapter {
 			await this.save();
 			this.database = undefined;
 		}
-	}
-
-	/**
-	 * Imports data from a blob, replacing the current database content.
-	 *
-	 * Also saves the imported data to OPFS.
-	 */
-	async import(blob: Blob): Promise<void> {
-		const database = await this.open();
-		importDatabase({
-			db: database,
-			content: new Uint8Array(await blob.arrayBuffer()),
-		});
-
-		// Save the imported data to OPFS
-		await this.save();
+		// Clean up active account subscription
+		if (this.activeAccountSubscription) {
+			this.activeAccountSubscription.unsubscribe();
+			this.activeAccountSubscription = undefined;
+		}
 	}
 
 	/**
 	 * Exports the current database state as a blob.
+	 *
+	 * @throws Error if the database has not been opened yet
 	 */
 	async export(): Promise<Blob> {
-		const database = await this.open();
-		const content = contentFromDatabase(database);
+		if (!this.database) {
+			throw new Error("Database has not been opened yet");
+		}
+		const content = contentFromDatabase(this.database);
 		return new Blob([content]);
 	}
 
@@ -136,11 +180,105 @@ export class OpfsStorage implements LixStorageAdapter {
 	}
 
 	/**
-	 * Called when state commits happen.
-	 * Automatically saves the current state to OPFS.
+	 * Called after the Lix instance is fully initialized.
+	 * Sets up observers for persisting state changes.
 	 */
-	onStateCommit(): void {
-		this.batchedSave();
+	connect(args: { lix: Lix }): void {
+		// Set up hook for database persistence
+		args.lix.hooks.onStateCommit(() => {
+			this.batchedSave();
+		});
+
+		// Observe changes to the active_account table with account details
+		this.activeAccountSubscription = args.lix
+			.observe(
+				args.lix.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"])
+			)
+			.subscribe({
+				next: (accounts) => {
+					// Save accounts when they change
+					this.saveActiveAccounts(accounts).catch((error) => {
+						console.error("Failed to save active accounts:", error);
+					});
+				},
+			});
+	}
+
+	/**
+	 * Saves the current active accounts to a JSON file in OPFS.
+	 */
+	private async saveActiveAccounts(
+		accounts: Pick<LixAccount, "id" | "name">[]
+	): Promise<void> {
+		if (!this.opfsRoot) {
+			return;
+		}
+
+		try {
+			// Save to JSON file
+			const jsonContent = JSON.stringify(accounts);
+			const fileHandle = await this.opfsRoot.getFileHandle(
+				"lix_active_accounts.json",
+				{ create: true }
+			);
+			const writable = await fileHandle.createWritable();
+			await writable.write(jsonContent);
+			await writable.close();
+
+			// Update cached accounts
+			this.activeAccounts = accounts;
+		} catch (error) {
+			console.error("Error saving active accounts:", error);
+		}
+	}
+
+	/**
+	 * Loads active accounts from the JSON file in OPFS.
+	 */
+	private async loadActiveAccounts(): Promise<
+		Pick<LixAccount, "id" | "name">[] | undefined
+	> {
+		if (!this.opfsRoot) {
+			return undefined;
+		}
+
+		try {
+			const fileHandle = await this.opfsRoot.getFileHandle(
+				"lix_active_accounts.json"
+			);
+			const file = await fileHandle.getFile();
+			const content = await file.text();
+			const accounts = JSON.parse(content) as Pick<LixAccount, "id" | "name">[];
+			this.activeAccounts = accounts;
+			return accounts;
+		} catch {
+			// File doesn't exist or error reading, return undefined
+			return undefined;
+		}
+	}
+
+	/**
+	 * Returns any persisted state that should be restored.
+	 */
+	async getPersistedState(): Promise<
+		{ activeAccounts?: Pick<LixAccount, "id" | "name">[] } | undefined
+	> {
+		// Load active accounts if not already loaded
+		if (!this.activeAccounts && this.opfsRoot) {
+			await this.loadActiveAccounts();
+		}
+
+		if (!this.activeAccounts || this.activeAccounts.length === 0) {
+			return undefined;
+		}
+
+		return {
+			activeAccounts: this.activeAccounts,
+		};
 	}
 
 	/**

package/src/log/create-lix-own-log.test.ts

@@ -2,7 +2,7 @@ import { expect, test } from "vitest";
 import { openLix } from "../lix/open-lix.js";
 import type { Lix } from "../lix/open-lix.js";
 import { createLixOwnLog } from "./create-lix-own-log.js";
-import type { Log } from "./schema.js";
+import type { LixLog } from "./schema.js";
 
 test("should insert logs default log levels when lix_log_levels is not set)", async () => {
 	const lix = await openLix({
@@ -90,30 +90,34 @@ test("should insert all levels contain wildcard '*'", async () => {
 async function createLogs(lix: Lix) {
 	await createLixOwnLog({
 		lix,
-		key: "lix.test.debug",
+		key: "log_test_debug",
 		level: "debug",
 		message: "debug message",
 	});
 	await createLixOwnLog({
 		lix,
-		key: "lix.test.info",
+		key: "log_test_info",
 		level: "info",
 		message: "info message",
 	});
 	await createLixOwnLog({
 		lix,
-		key: "lix.test.warn",
+		key: "log_test_warn",
 		level: "warn",
 		message: "warn message",
 	});
 	await createLixOwnLog({
 		lix,
-		key: "lix.test.error",
+		key: "log_test_error",
 		level: "error",
 		message: "error message",
 	});
 }
 
-async function getLogs(lix: Lix): Promise<Log[]> {
-	return lix.db.selectFrom("log").selectAll().execute();
+async function getLogs(lix: Lix): Promise<LixLog[]> {
+	return lix.db
+		.selectFrom("log")
+		.where("key", "like", "log_test%")
+		.selectAll()
+		.execute();
 }

package/src/log/create-lix-own-log.ts

@@ -3,6 +3,24 @@ import type { Lix } from "../lix/open-lix.js";
 
 const DEFAULT_LOG_LEVELS = ["info", "warn", "error"];
 
+/**
+ * Determines if a log entry should be created based on the configured log levels.
+ *
+ * @param logLevelsValue - The configured log levels (e.g., ["info", "warn", "error"] or ["*"])
+ * @param level - The level of the log entry to check
+ * @returns true if the log should be created, false otherwise
+ */
+export function shouldLog(
+	logLevelsValue: string[] | undefined,
+	level: string
+): boolean {
+	return (
+		(logLevelsValue === undefined && DEFAULT_LOG_LEVELS.includes(level)) ||
+		(logLevelsValue && logLevelsValue.includes("*")) ||
+		(logLevelsValue?.includes(level) ?? false)
+	);
+}
+
 /**
  * Creates a log entry in the Lix database, applying log level filtering.
  *
@@ -70,12 +88,7 @@ export function createLixOwnLogSync(args: {
 	})[0];
 
 	// Check if the level is allowed
-	const shouldLog =
-		(logLevels === undefined && DEFAULT_LOG_LEVELS.includes(args.level)) ||
-		(logLevels?.value && logLevels.value.includes("*")) ||
-		logLevels?.value.includes(args.level);
-
-	if (!shouldLog) {
+	if (!shouldLog(logLevels?.value, args.level)) {
 		return undefined; // Filtered out
 	}
 
@@ -91,34 +104,10 @@ export function createLixOwnLogSync(args: {
 }
 
 export async function createLixOwnLog(args: {
-	lix: Pick<Lix, "db">;
+	lix: Pick<Lix, "sqlite" | "db">;
 	message: string;
 	level: string;
 	key: string;
 }): Promise<void> {
-	const logLevels = await args.lix.db
-		.selectFrom("key_value")
-		.select("value")
-		.where("key", "=", "lix_log_levels")
-		.executeTakeFirst();
-
-	// Check if the level is allowed
-	const shouldLog =
-		(logLevels === undefined && DEFAULT_LOG_LEVELS.includes(args.level)) ||
-		(logLevels?.value && (logLevels.value as string[]).includes("*")) ||
-		(logLevels?.value as string[] | undefined)?.includes(args.level);
-
-	if (!shouldLog) {
-		return undefined; // Filtered out
-	}
-
-	// Insert the log
-	await args.lix.db
-		.insertInto("log")
-		.values({
-			key: args.key,
-			message: args.message,
-			level: args.level,
-		})
-		.execute();
+	return createLixOwnLogSync(args);
 }

package/src/log/create-log.ts

@@ -1,7 +1,7 @@
-import { nanoid } from "../database/nano-id.js";
+import { nanoId } from "../deterministic/index.js";
 import type { State } from "../entity-views/types.js";
 import type { Lix } from "../lix/open-lix.js";
-import type { Log } from "./schema.js";
+import type { LixLog } from "./schema.js";
 
 /**
  * Directly creates a log entry in the Lix database without applying any filters.
@@ -30,9 +30,9 @@ export async function createLog(args: {
 	message: string;
 	level: string;
 	key: string;
-}): Promise<State<Log>> {
+}): Promise<State<LixLog>> {
 	// Insert the log entry
-	const id = nanoid();
+	const id = nanoId({ lix: args.lix });
 	await args.lix.db
 		.insertInto("log")
 		.values({

package/src/log/index.ts

@@ -1,2 +1,2 @@
-export { LixLogSchema, type Log } from "./schema.js";
+export { LixLogSchema, type LixLog as Log } from "./schema.js";
 export { createLog } from "./create-log.js";

package/src/log/schema.ts

@@ -1,25 +1,21 @@
-import type { SqliteWasmDatabase } from "sqlite-wasm-kysely";
 import type {
 	LixSchemaDefinition,
 	FromLixSchemaDefinition,
 } from "../schema-definition/definition.js";
 import { createEntityViewsIfNotExists } from "../entity-views/entity-view-builder.js";
-import { nanoid } from "../database/nano-id.js";
+import { nanoId } from "../deterministic/index.js";
+import type { Lix } from "../lix/open-lix.js";
 
-export function applyLogDatabaseSchema(
-	sqlite: SqliteWasmDatabase
-): SqliteWasmDatabase {
+export function applyLogDatabaseSchema(lix: Pick<Lix, "sqlite" | "db">): void {
 	// Create both primary and _all views for log
 	createEntityViewsIfNotExists({
-		lix: { sqlite },
+		lix,
 		schema: LixLogSchema,
 		overrideName: "log",
 		pluginKey: "lix_own_entity",
 		hardcodedFileId: "lix",
-		defaultValues: { id: () => nanoid() },
+		defaultValues: { id: () => nanoId({ lix }) },
 	});
-
-	return sqlite;
 }
 
 export const LixLogSchema = {
@@ -52,4 +48,4 @@ export const LixLogSchema = {
 LixLogSchema satisfies LixSchemaDefinition;
 
 // Pure business logic type (runtime/selectable type)
-export type Log = FromLixSchemaDefinition<typeof LixLogSchema>;
+export type LixLog = FromLixSchemaDefinition<typeof LixLogSchema>;