@xnetjs/sqlite 0.0.2

package/dist/chunk-BXYZU3OL.js

@@ -0,0 +1,245 @@
+import {
+  SCHEMA_DDL,
+  SCHEMA_VERSION
+} from "./chunk-HIREU5S5.js";
+
+// src/adapters/web.ts
+function isDebugEnabled() {
+  return typeof self !== "undefined" && typeof localStorage !== "undefined" && localStorage.getItem("xnet:sqlite:debug") === "true";
+}
+function log(...args) {
+  if (isDebugEnabled()) {
+    console.log(...args);
+  }
+}
+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 {
+      log("[WebSQLiteAdapter] Installing OPFS-SAHPool VFS...");
+      this.poolUtil = await this.sqlite3.installOpfsSAHPoolVfs({
+        name: "opfs-sahpool",
+        directory: ".xnet-sqlite",
+        initialCapacity: 10,
+        // 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 = config.path.startsWith("/") ? config.path : `/${config.path}`;
+      log("[WebSQLiteAdapter] Opening database at", dbPath);
+      this.db = new this.poolUtil.OpfsSAHPoolDb(dbPath, "c");
+      this.storageMode = "opfs";
+      log("[WebSQLiteAdapter] Database opened with OPFS-SAHPool");
+    } catch (err) {
+      console.warn("[WebSQLiteAdapter] OPFS-SAHPool not available, trying OPFS direct mode:", err);
+      const dbPath = config.path.startsWith("/") ? config.path : `/${config.path}`;
+      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) {
+          console.warn(
+            "[WebSQLiteAdapter] OPFS direct mode not available, using in-memory database:",
+            opfsErr
+          );
+          this.db = new this.sqlite3.oo1.DB(":memory:", "c");
+          this.storageMode = "memory";
+          log("[WebSQLiteAdapter] In-memory database opened");
+        }
+      } else {
+        console.warn("[WebSQLiteAdapter] OPFS direct mode unavailable, using in-memory database");
+        this.db = new this.sqlite3.oo1.DB(":memory:", "c");
+        this.storageMode = "memory";
+        log("[WebSQLiteAdapter] In-memory database opened");
+      }
+    }
+    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");
+    }
+    this.execSync("PRAGMA synchronous = NORMAL");
+    this.execSync("PRAGMA cache_size = -64000");
+    this.execSync("PRAGMA temp_store = MEMORY");
+  }
+  async close() {
+    if (this.db) {
+      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) {
+      await this.rollback();
+      throw err;
+    }
+  }
+  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");
+    }
+    this.execSync("COMMIT");
+    this.inTransaction = false;
+  }
+  async rollback() {
+    if (!this.inTransaction) {
+      return;
+    }
+    this.execSync("ROLLBACK");
+    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 {
+  WebSQLiteAdapter,
+  createWebSQLiteAdapter
+};

package/dist/chunk-HIREU5S5.js

@@ -0,0 +1,193 @@
+// src/schema.ts
+var SCHEMA_VERSION = 1;
+var SCHEMA_DDL_CORE = `
+-- ============================================
+-- Schema Version Tracking
+-- ============================================
+
+CREATE TABLE IF NOT EXISTS _schema_version (
+    version INTEGER PRIMARY KEY,
+    applied_at INTEGER NOT NULL
+);
+
+-- ============================================
+-- Core Tables
+-- ============================================
+
+-- All nodes (Pages, Databases, Rows, Comments, etc.)
+CREATE TABLE IF NOT EXISTS nodes (
+    id TEXT PRIMARY KEY,
+    schema_id TEXT NOT NULL,
+    created_at INTEGER NOT NULL,
+    updated_at INTEGER NOT NULL,
+    created_by TEXT NOT NULL,
+    deleted_at INTEGER
+);
+
+-- Node properties (LWW per-property)
+CREATE TABLE IF NOT EXISTS node_properties (
+    node_id TEXT NOT NULL,
+    property_key TEXT NOT NULL,
+    value BLOB,
+    lamport_time INTEGER NOT NULL,
+    updated_by TEXT NOT NULL,
+    updated_at INTEGER NOT NULL,
+
+    PRIMARY KEY (node_id, property_key),
+    FOREIGN KEY (node_id) REFERENCES nodes(id) ON DELETE CASCADE
+);
+
+-- Change log (event sourcing)
+CREATE TABLE IF NOT EXISTS changes (
+    hash TEXT PRIMARY KEY,
+    node_id TEXT NOT NULL,
+    payload BLOB NOT NULL,
+    lamport_time INTEGER NOT NULL,
+    lamport_peer TEXT NOT NULL,
+    wall_time INTEGER NOT NULL,
+    author TEXT NOT NULL,
+    parent_hash TEXT,
+    batch_id TEXT,
+    signature BLOB NOT NULL,
+
+    FOREIGN KEY (node_id) REFERENCES nodes(id) ON DELETE CASCADE
+);
+
+-- Y.Doc binary state (for nodes with collaborative content)
+CREATE TABLE IF NOT EXISTS yjs_state (
+    node_id TEXT PRIMARY KEY,
+    state BLOB NOT NULL,
+    updated_at INTEGER NOT NULL,
+
+    FOREIGN KEY (node_id) REFERENCES nodes(id) ON DELETE CASCADE
+);
+
+-- Y.Doc incremental updates (for sync)
+CREATE TABLE IF NOT EXISTS yjs_updates (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    node_id TEXT NOT NULL,
+    update_data BLOB NOT NULL,
+    timestamp INTEGER NOT NULL,
+    origin TEXT,
+
+    FOREIGN KEY (node_id) REFERENCES nodes(id) ON DELETE CASCADE
+);
+
+-- Yjs snapshots (for document time travel)
+CREATE TABLE IF NOT EXISTS yjs_snapshots (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    node_id TEXT NOT NULL,
+    timestamp INTEGER NOT NULL,
+    snapshot BLOB NOT NULL,
+    doc_state BLOB NOT NULL,
+    byte_size INTEGER NOT NULL,
+
+    FOREIGN KEY (node_id) REFERENCES nodes(id) ON DELETE CASCADE
+);
+
+-- Blobs (content-addressed)
+CREATE TABLE IF NOT EXISTS blobs (
+    cid TEXT PRIMARY KEY,
+    data BLOB NOT NULL,
+    mime_type TEXT,
+    size INTEGER NOT NULL,
+    created_at INTEGER NOT NULL,
+    reference_count INTEGER DEFAULT 1
+);
+
+-- Documents (for @xnetjs/storage compatibility)
+CREATE TABLE IF NOT EXISTS documents (
+    id TEXT PRIMARY KEY,
+    content BLOB NOT NULL,
+    metadata TEXT NOT NULL,
+    version INTEGER NOT NULL DEFAULT 1
+);
+
+-- Signed updates (for @xnetjs/storage compatibility)
+CREATE TABLE IF NOT EXISTS updates (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    doc_id TEXT NOT NULL,
+    update_hash TEXT NOT NULL,
+    update_data TEXT NOT NULL,
+    created_at INTEGER DEFAULT (strftime('%s', 'now') * 1000),
+    UNIQUE(doc_id, update_hash)
+);
+
+-- Snapshots (for @xnetjs/storage compatibility)
+CREATE TABLE IF NOT EXISTS snapshots (
+    doc_id TEXT PRIMARY KEY,
+    snapshot_data TEXT NOT NULL,
+    created_at INTEGER DEFAULT (strftime('%s', 'now') * 1000)
+);
+
+-- Sync metadata
+CREATE TABLE IF NOT EXISTS sync_state (
+    key TEXT PRIMARY KEY,
+    value TEXT NOT NULL
+);
+
+-- ============================================
+-- Indexes
+-- ============================================
+
+CREATE INDEX IF NOT EXISTS idx_nodes_schema ON nodes(schema_id);
+CREATE INDEX IF NOT EXISTS idx_nodes_updated ON nodes(updated_at);
+CREATE INDEX IF NOT EXISTS idx_nodes_created_by ON nodes(created_by);
+CREATE INDEX IF NOT EXISTS idx_nodes_deleted ON nodes(deleted_at);
+
+CREATE INDEX IF NOT EXISTS idx_properties_node ON node_properties(node_id);
+CREATE INDEX IF NOT EXISTS idx_properties_lamport ON node_properties(lamport_time);
+
+CREATE INDEX IF NOT EXISTS idx_changes_node ON changes(node_id);
+CREATE INDEX IF NOT EXISTS idx_changes_lamport ON changes(lamport_time);
+CREATE INDEX IF NOT EXISTS idx_changes_wall_time ON changes(wall_time);
+CREATE INDEX IF NOT EXISTS idx_changes_batch ON changes(batch_id);
+
+CREATE INDEX IF NOT EXISTS idx_yjs_state_updated ON yjs_state(updated_at);
+CREATE INDEX IF NOT EXISTS idx_yjs_updates_node ON yjs_updates(node_id);
+CREATE INDEX IF NOT EXISTS idx_yjs_snapshots_node ON yjs_snapshots(node_id);
+CREATE INDEX IF NOT EXISTS idx_yjs_snapshots_timestamp ON yjs_snapshots(node_id, timestamp);
+
+CREATE INDEX IF NOT EXISTS idx_updates_doc ON updates(doc_id);
+CREATE INDEX IF NOT EXISTS idx_updates_created ON updates(created_at);
+`;
+var SCHEMA_DDL_FTS = `
+-- ============================================
+-- Full-Text Search (FTS5)
+-- ============================================
+
+-- FTS index for searchable node content
+CREATE VIRTUAL TABLE IF NOT EXISTS nodes_fts USING fts5(
+    node_id,
+    title,
+    content,
+    tokenize='porter unicode61'
+);
+
+-- Triggers to keep FTS in sync will be managed by application layer
+-- since the searchable content is derived from node properties
+`;
+var SCHEMA_DDL = SCHEMA_DDL_CORE + SCHEMA_DDL_FTS;
+var SCHEMA_MIGRATIONS = {
+  // Version 2 migrations would go here
+  // 2: `ALTER TABLE nodes ADD COLUMN ...`
+};
+function getMigrationSQL(fromVersion, toVersion) {
+  const statements = [];
+  for (let v = fromVersion + 1; v <= toVersion; v++) {
+    const migration = SCHEMA_MIGRATIONS[v];
+    if (migration) {
+      statements.push(migration);
+    }
+  }
+  return statements.join("\n");
+}
+
+export {
+  SCHEMA_VERSION,
+  SCHEMA_DDL_CORE,
+  SCHEMA_DDL_FTS,
+  SCHEMA_DDL,
+  SCHEMA_MIGRATIONS,
+  getMigrationSQL
+};

package/dist/chunk-ZRR5D2OD.js

@@ -0,0 +1,140 @@
+// src/browser-support.ts
+function withTimeout(promise, timeoutMs, errorMessage) {
+  return Promise.race([
+    promise,
+    new Promise((_, reject) => setTimeout(() => reject(new Error(errorMessage)), timeoutMs))
+  ]);
+}
+function isSafariPrivateBrowsing() {
+  const isSafari = /^((?!chrome|android).)*safari/i.test(navigator.userAgent);
+  if (!isSafari) return false;
+  try {
+    localStorage.setItem("_test", "1");
+    localStorage.removeItem("_test");
+    return false;
+  } catch {
+    return true;
+  }
+}
+async function checkBrowserSupport() {
+  const result = {
+    opfs: false,
+    worker: true,
+    supported: false
+  };
+  if (typeof Worker === "undefined") {
+    result.worker = false;
+    result.reason = "Web Workers not supported in this browser.";
+    return result;
+  }
+  if (typeof navigator === "undefined" || !navigator.storage?.getDirectory) {
+    result.reason = "Origin Private File System (OPFS) not supported. Please use a modern browser (Chrome 102+, Firefox 111+, Safari 16.4+).";
+    return result;
+  }
+  try {
+    const testOPFS = async () => {
+      await navigator.storage.getDirectory();
+    };
+    await withTimeout(testOPFS(), 5e3, "OPFS access timeout");
+    result.opfs = true;
+    result.supported = true;
+  } catch (err) {
+    const errorMessage = err instanceof Error ? err.message : String(err);
+    const normalized = errorMessage.toLowerCase();
+    const safariStorageContextError = normalized.includes("object can not be found here") || normalized.includes("object cannot be found here") || normalized.includes("operation is insecure");
+    if (isSafariPrivateBrowsing()) {
+      result.warning = "Safari Private Browsing detected. Storage may be limited. For full functionality, switch to normal mode or use the xNet Desktop App.";
+      result.supported = true;
+    } else if (/^((?!chrome|android).)*safari/i.test(navigator.userAgent) && safariStorageContextError) {
+      result.warning = "Safari storage APIs are restricted in this context. xNet will continue, but persistence may be limited between sessions.";
+      result.supported = true;
+    } else {
+      result.warning = `Storage access limited (${errorMessage}). Data persistence may be limited between sessions. For full functionality, use the xNet Desktop App.`;
+      result.supported = true;
+    }
+  }
+  return result;
+}
+function showUnsupportedBrowserMessage(reason) {
+  const container = document.getElementById("app") ?? document.body;
+  container.innerHTML = `
+    <div style="
+      display: flex;
+      flex-direction: column;
+      align-items: center;
+      justify-content: center;
+      min-height: 100vh;
+      padding: 2rem;
+      text-align: center;
+      font-family: system-ui, -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
+      background: #fafafa;
+      color: #333;
+    ">
+      <div style="
+        background: white;
+        padding: 2rem 2.5rem;
+        border-radius: 12px;
+        box-shadow: 0 4px 12px rgba(0,0,0,0.08);
+        max-width: 480px;
+        width: 100%;
+      ">
+        <h1 style="
+          font-size: 1.5rem;
+          margin: 0 0 1rem 0;
+          color: #111;
+          font-weight: 600;
+        ">
+          Browser Not Supported
+        </h1>
+        <p style="
+          color: #555;
+          margin: 0 0 1.5rem 0;
+          line-height: 1.6;
+          font-size: 1rem;
+        ">
+          ${escapeHtml(reason)}
+        </p>
+        <div style="
+          background: #f5f5f5;
+          padding: 1rem;
+          border-radius: 8px;
+          text-align: left;
+          font-size: 0.9rem;
+        ">
+          <p style="margin: 0 0 0.5rem 0; font-weight: 500;">Supported browsers:</p>
+          <ul style="margin: 0; padding-left: 1.5rem; color: #666;">
+            <li>Chrome 102+ (March 2022)</li>
+            <li>Edge 102+ (March 2022)</li>
+            <li>Firefox 111+ (March 2023)</li>
+            <li>Safari 16.4+ (March 2023)</li>
+          </ul>
+        </div>
+        <p style="
+          color: #888;
+          font-size: 0.875rem;
+          margin: 1.5rem 0 0 0;
+        ">
+          For the best experience, please use the 
+          <a href="https://xnet.app/download" style="
+            color: #0066cc;
+            text-decoration: none;
+            font-weight: 500;
+          ">
+            xNet Desktop App
+          </a>
+          or update your browser.
+        </p>
+      </div>
+    </div>
+  `;
+}
+function escapeHtml(text) {
+  const div = document.createElement("div");
+  div.textContent = text;
+  return div.innerHTML;
+}
+
+export {
+  checkBrowserSupport,
+  showUnsupportedBrowserMessage
+};