@xnetjs/sqlite 0.0.2 → 0.0.3

package/dist/chunk-DCY4LAUD.js

@@ -0,0 +1,494 @@
+import {
+  isSQLiteCorruptionError
+} from "./chunk-CBU263LI.js";
+import {
+  SCHEMA_DDL,
+  SCHEMA_VERSION
+} from "./chunk-NVD7G7DZ.js";
+
+// src/adapters/opfs-retry.ts
+function isOpfsLockError(err) {
+  const e = err;
+  if (!e) return false;
+  if (e.name === "NoModificationAllowedError") return true;
+  return /Access Handles cannot be created|createSyncAccessHandle/i.test(e.message ?? "");
+}
+async function withOpfsLockRetry(fn, options = {}) {
+  const attempts = options.attempts ?? 5;
+  const baseDelayMs = options.baseDelayMs ?? 150;
+  const sleep = options.sleep ?? ((ms) => new Promise((r) => setTimeout(r, ms)));
+  let lastErr;
+  for (let attempt = 1; attempt <= attempts; attempt++) {
+    try {
+      return await fn();
+    } catch (err) {
+      lastErr = err;
+      if (!isOpfsLockError(err) || attempt === attempts) throw err;
+      options.onRetry?.(attempt, err);
+      await sleep(baseDelayMs * attempt);
+    }
+  }
+  throw lastErr;
+}
+
+// src/adapters/web.ts
+var WEB_SQLITE_VFS_NAME = "opfs-sahpool";
+var WEB_SQLITE_VFS_DIRECTORY = ".xnet-sqlite";
+var WEB_SQLITE_INITIAL_CAPACITY = 10;
+function isDebugEnabled() {
+  return typeof self !== "undefined" && typeof localStorage !== "undefined" && localStorage.getItem("xnet:sqlite:debug") === "true";
+}
+function log(...args) {
+  if (isDebugEnabled()) {
+    console.log(...args);
+  }
+}
+function getDatabasePath(config) {
+  return config.path.startsWith("/") ? config.path : `/${config.path}`;
+}
+async function removeOPFSDirectory(directory) {
+  const storage = globalThis.navigator?.storage;
+  if (typeof storage?.getDirectory !== "function") {
+    return;
+  }
+  try {
+    const root = await storage.getDirectory();
+    await root.removeEntry(directory.replace(/^\/+/, ""), { recursive: true });
+  } catch (err) {
+    if (err instanceof DOMException && err.name === "NotFoundError") {
+      return;
+    }
+    throw err;
+  }
+}
+async function resetWebSQLiteOpfsStorage(config) {
+  const sqlite3InitModule = (await import("@sqlite.org/sqlite-wasm")).default;
+  const sqlite3 = await sqlite3InitModule();
+  const dbPath = getDatabasePath(config);
+  try {
+    const poolUtil = await sqlite3.installOpfsSAHPoolVfs({
+      name: WEB_SQLITE_VFS_NAME,
+      directory: WEB_SQLITE_VFS_DIRECTORY,
+      initialCapacity: WEB_SQLITE_INITIAL_CAPACITY,
+      clearOnInit: false
+    });
+    try {
+      poolUtil.unlink(dbPath);
+    } catch {
+    }
+    await poolUtil.wipeFiles();
+    await poolUtil.removeVfs();
+  } catch (err) {
+    console.warn("[WebSQLiteAdapter] SAH-pool reset failed, removing OPFS directory:", err);
+    await removeOPFSDirectory(WEB_SQLITE_VFS_DIRECTORY);
+  }
+}
+var WebSQLiteAdapter = class {
+  sqlite3 = null;
+  db = null;
+  poolUtil = null;
+  _config = null;
+  inTransaction = false;
+  storageMode = "memory";
+  async open(config) {
+    if (this.db !== null) {
+      throw new Error("Database already open. Call close() first.");
+    }
+    log("[WebSQLiteAdapter] Starting open()...");
+    log("[WebSQLiteAdapter] Importing sqlite-wasm...");
+    const sqlite3InitModule = (await import("@sqlite.org/sqlite-wasm")).default;
+    log("[WebSQLiteAdapter] sqlite-wasm imported");
+    log("[WebSQLiteAdapter] Initializing sqlite3 module...");
+    this.sqlite3 = await sqlite3InitModule();
+    log("[WebSQLiteAdapter] sqlite3 module initialized");
+    try {
+      await withOpfsLockRetry(
+        async () => {
+          log("[WebSQLiteAdapter] Installing OPFS-SAHPool VFS...");
+          this.poolUtil = await this.sqlite3.installOpfsSAHPoolVfs({
+            name: WEB_SQLITE_VFS_NAME,
+            directory: WEB_SQLITE_VFS_DIRECTORY,
+            initialCapacity: WEB_SQLITE_INITIAL_CAPACITY,
+            // Support ~3-4 databases with journals
+            clearOnInit: false
+          });
+          log("[WebSQLiteAdapter] OPFS-SAHPool VFS installed");
+          log("[WebSQLiteAdapter] Reserving capacity...");
+          await this.poolUtil.reserveMinimumCapacity(10);
+          log("[WebSQLiteAdapter] Capacity reserved");
+          const dbPath = getDatabasePath(config);
+          log("[WebSQLiteAdapter] Opening database at", dbPath);
+          this.db = new this.poolUtil.OpfsSAHPoolDb(dbPath, "c");
+          this.storageMode = "opfs";
+          log("[WebSQLiteAdapter] Database opened with OPFS-SAHPool");
+        },
+        {
+          onRetry: (attempt, retryErr) => {
+            console.warn(
+              `[WebSQLiteAdapter] OPFS access handles are busy (attempt ${attempt}) \u2014 a previous tab/worker is likely still releasing them; retrying before any in-memory fallback.`,
+              retryErr
+            );
+          }
+        }
+      );
+    } catch (err) {
+      console.warn("[WebSQLiteAdapter] OPFS-SAHPool not available, trying OPFS direct mode:", err);
+      const dbPath = getDatabasePath(config);
+      const opfsDbCtor = this.sqlite3?.oo1?.OpfsDb;
+      if (typeof opfsDbCtor === "function") {
+        try {
+          this.db = new opfsDbCtor(dbPath, "c");
+          this.storageMode = "opfs";
+          log("[WebSQLiteAdapter] Database opened with OPFS direct mode");
+        } catch (opfsErr) {
+          log("[WebSQLiteAdapter] OPFS direct mode not available:", opfsErr);
+          this.db = new this.sqlite3.oo1.DB(":memory:", "c");
+          this.storageMode = "memory";
+        }
+      } else {
+        this.db = new this.sqlite3.oo1.DB(":memory:", "c");
+        this.storageMode = "memory";
+      }
+      if (this.storageMode === "memory") {
+        const cause = isOpfsLockError(err) ? "another xNet tab/worker is holding the local database" : "OPFS is unavailable in this browser context";
+        console.error(
+          `[WebSQLiteAdapter] Using an IN-MEMORY database (${cause}). Local data will NOT persist across reloads and the workspace will appear empty until it re-syncs from the hub. Close other xNet tabs and reload to restore persistent storage.`
+        );
+      }
+    }
+    this._config = config;
+    if (config.foreignKeys !== false) {
+      this.execSync("PRAGMA foreign_keys = ON");
+    }
+    if (config.busyTimeout) {
+      this.execSync(`PRAGMA busy_timeout = ${config.busyTimeout}`);
+    } else {
+      this.execSync("PRAGMA busy_timeout = 5000");
+    }
+    try {
+      this.execSync("PRAGMA page_size = 8192");
+    } catch (err) {
+      log("[WebSQLiteAdapter] page_size pragma not applied:", err);
+    }
+    this.execSync("PRAGMA synchronous = NORMAL");
+    this.execSync("PRAGMA cache_size = -262144");
+    this.execSync("PRAGMA temp_store = MEMORY");
+    try {
+      this.execSync("PRAGMA journal_mode = TRUNCATE");
+    } catch (err) {
+      log("[WebSQLiteAdapter] journal_mode pragma not applied:", err);
+    }
+  }
+  async close() {
+    if (this.db) {
+      try {
+        this.execSync("PRAGMA optimize");
+      } catch (err) {
+        log("[WebSQLiteAdapter] optimize on close skipped:", err);
+      }
+      this.db.close();
+      this.db = null;
+    }
+    this.sqlite3 = null;
+    this.poolUtil = null;
+    this._config = null;
+  }
+  isOpen() {
+    return this.db !== null;
+  }
+  getStorageMode() {
+    return this.storageMode;
+  }
+  async query(sql, params) {
+    this.ensureOpen();
+    const rows = [];
+    this.db.exec({
+      sql,
+      bind: params,
+      rowMode: "object",
+      callback: (row) => {
+        rows.push(row);
+      }
+    });
+    return rows;
+  }
+  async queryOne(sql, params) {
+    const rows = await this.query(sql, params);
+    return rows[0] ?? null;
+  }
+  async run(sql, params) {
+    this.ensureOpen();
+    this.db.exec({
+      sql,
+      bind: params
+    });
+    return {
+      changes: this.sqlite3.capi.sqlite3_changes(this.db.pointer),
+      lastInsertRowid: this.sqlite3.capi.sqlite3_last_insert_rowid(this.db.pointer)
+    };
+  }
+  async exec(sql) {
+    this.ensureOpen();
+    this.execSync(sql);
+  }
+  execSync(sql) {
+    this.db.exec({ sql });
+  }
+  async transaction(fn) {
+    await this.beginTransaction();
+    try {
+      const result = await fn();
+      await this.commit();
+      return result;
+    } catch (err) {
+      if (this.inTransaction) {
+        try {
+          await this.rollback();
+        } catch (rollbackErr) {
+          if (isSQLiteCorruptionError(rollbackErr) && !isSQLiteCorruptionError(err)) {
+            throw rollbackErr;
+          }
+        }
+      }
+      throw err;
+    }
+  }
+  async applyNodeBatch(input) {
+    await this.transaction(async () => {
+      for (const node of input.nodes) {
+        await this.run(
+          `INSERT INTO nodes (id, schema_id, created_at, updated_at, created_by, deleted_at)
+           VALUES (?, ?, ?, ?, ?, ?)
+           ON CONFLICT(id) DO UPDATE SET
+             schema_id = excluded.schema_id,
+             updated_at = excluded.updated_at,
+             deleted_at = excluded.deleted_at`,
+          [node.id, node.schemaId, node.createdAt, node.updatedAt, node.createdBy, node.deletedAt]
+        );
+        if (node.propertyKeys.length === 0) {
+          await this.run("DELETE FROM node_properties WHERE node_id = ?", [node.id]);
+        } else {
+          await this.run(
+            `DELETE FROM node_properties
+             WHERE node_id = ? AND property_key NOT IN (${node.propertyKeys.map(() => "?").join(", ")})`,
+            [node.id, ...node.propertyKeys]
+          );
+        }
+      }
+      for (const property of input.properties) {
+        await this.run(
+          `INSERT INTO node_properties
+              (node_id, property_key, value, lamport_time, updated_by, updated_at)
+            VALUES (?, ?, ?, ?, ?, ?)
+            ON CONFLICT(node_id, property_key) DO UPDATE SET
+              value = excluded.value,
+              lamport_time = excluded.lamport_time,
+              updated_by = excluded.updated_by,
+              updated_at = excluded.updated_at
+            WHERE excluded.lamport_time > node_properties.lamport_time`,
+          [
+            property.nodeId,
+            property.propertyKey,
+            property.value,
+            property.lamportTime,
+            property.updatedBy,
+            property.updatedAt
+          ]
+        );
+      }
+      if (input.indexMode !== "defer-schema") {
+        for (const node of input.nodes) {
+          await this.run("DELETE FROM node_property_scalars WHERE node_id = ?", [node.id]);
+        }
+        for (const row of input.scalarIndexRows) {
+          await this.run(
+            `INSERT INTO node_property_scalars
+                (
+                  node_id,
+                  schema_id,
+                  property_key,
+                  value_type,
+                  value_text,
+                  value_number,
+                  value_boolean,
+                  value_hash,
+                  updated_at,
+                  lamport_time
+                )
+              VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+            [
+              row.nodeId,
+              row.schemaId,
+              row.propertyKey,
+              row.valueType,
+              row.valueText,
+              row.valueNumber,
+              row.valueBoolean,
+              row.valueHash,
+              row.updatedAt,
+              row.lamportTime
+            ]
+          );
+        }
+        for (const nodeId of input.ftsNodeIds) {
+          await this.run("DELETE FROM nodes_fts WHERE node_id = ?", [nodeId]);
+        }
+        for (const row of input.ftsRows) {
+          await this.run("INSERT INTO nodes_fts (node_id, title, content) VALUES (?, ?, ?)", [
+            row.nodeId,
+            row.title,
+            row.content
+          ]);
+        }
+      }
+      for (const change of input.changes) {
+        await this.run(
+          `INSERT OR IGNORE INTO changes
+            (hash, node_id, payload, lamport_time, lamport_peer, wall_time, author, parent_hash, batch_id, signature)
+           VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+          [
+            change.hash,
+            change.nodeId,
+            change.payload,
+            change.lamportTime,
+            change.lamportPeer,
+            change.wallTime,
+            change.author,
+            change.parentHash,
+            change.batchId,
+            change.signature
+          ]
+        );
+      }
+      await this.run(
+        `INSERT INTO sync_state (key, value) VALUES ('lastLamportTime', ?)
+         ON CONFLICT(key) DO UPDATE SET value = excluded.value`,
+        [String(input.lastLamportTime)]
+      );
+      if (input.indexMode !== "defer-schema") {
+        const invalidatedAt = Date.now();
+        for (const schemaId of input.affectedSchemaIds) {
+          await this.run(
+            `UPDATE node_query_materializations
+             SET invalidated_at = ?
+             WHERE schema_id = ? AND invalidated_at IS NULL`,
+            [invalidatedAt, schemaId]
+          );
+        }
+      }
+    });
+    return {
+      nodeRowsWritten: input.nodes.length,
+      propertyRowsWritten: input.properties.length,
+      changeRowsWritten: input.changes.length,
+      scalarRowsWritten: input.scalarIndexRows.length,
+      ftsRowsWritten: input.ftsRows.length
+    };
+  }
+  async beginTransaction() {
+    if (this.inTransaction) {
+      throw new Error("Transaction already in progress");
+    }
+    this.execSync("BEGIN IMMEDIATE");
+    this.inTransaction = true;
+  }
+  async commit() {
+    if (!this.inTransaction) {
+      throw new Error("No transaction in progress");
+    }
+    try {
+      this.execSync("COMMIT");
+      this.inTransaction = false;
+    } catch (err) {
+      if (isSQLiteCorruptionError(err)) {
+        this.inTransaction = false;
+      }
+      throw err;
+    }
+  }
+  async rollback() {
+    if (!this.inTransaction) {
+      return;
+    }
+    try {
+      this.execSync("ROLLBACK");
+    } finally {
+      this.inTransaction = false;
+    }
+  }
+  async prepare(sql) {
+    return {
+      query: async (params) => {
+        return this.query(sql, params);
+      },
+      queryOne: async (params) => {
+        return this.queryOne(sql, params);
+      },
+      run: async (params) => {
+        return this.run(sql, params);
+      },
+      finalize: async () => {
+      }
+    };
+  }
+  async getSchemaVersion() {
+    try {
+      const row = await this.queryOne(
+        "SELECT version FROM _schema_version ORDER BY version DESC LIMIT 1"
+      );
+      return row?.version ?? 0;
+    } catch {
+      return 0;
+    }
+  }
+  async setSchemaVersion(version) {
+    await this.run("INSERT INTO _schema_version (version, applied_at) VALUES (?, ?)", [
+      version,
+      Date.now()
+    ]);
+  }
+  async applySchema(version, sql) {
+    const currentVersion = await this.getSchemaVersion();
+    if (currentVersion >= version) {
+      return false;
+    }
+    await this.transaction(async () => {
+      await this.exec(sql);
+      await this.setSchemaVersion(version);
+    });
+    return true;
+  }
+  async getDatabaseSize() {
+    try {
+      const row = await this.queryOne(
+        "SELECT page_count * page_size as size FROM pragma_page_count(), pragma_page_size()"
+      );
+      return row?.size ?? 0;
+    } catch {
+      return 0;
+    }
+  }
+  async vacuum() {
+    await this.exec("VACUUM");
+  }
+  async checkpoint() {
+    return 0;
+  }
+  ensureOpen() {
+    if (!this.db || !this.sqlite3) {
+      throw new Error("Database not open. Call open() first.");
+    }
+  }
+};
+async function createWebSQLiteAdapter(config) {
+  const adapter = new WebSQLiteAdapter();
+  await adapter.open(config);
+  await adapter.applySchema(SCHEMA_VERSION, SCHEMA_DDL);
+  return adapter;
+}
+
+export {
+  resetWebSQLiteOpfsStorage,
+  WebSQLiteAdapter,
+  createWebSQLiteAdapter
+};