@xnetjs/sqlite 0.0.2

package/dist/adapters/memory.js

@@ -0,0 +1,176 @@
+import {
+  SCHEMA_DDL_CORE,
+  SCHEMA_VERSION
+} from "../chunk-HIREU5S5.js";
+
+// src/adapters/memory.ts
+var MemorySQLiteAdapter = class {
+  db = null;
+  opened = false;
+  inTransaction = false;
+  async open(_config) {
+    const initSqlJs = await import("sql.js").then((m) => m.default);
+    const SQL = await initSqlJs();
+    this.db = new SQL.Database();
+    this.opened = true;
+    this.db.run("PRAGMA foreign_keys = ON");
+  }
+  async close() {
+    if (this.db) {
+      this.db.close();
+      this.db = null;
+    }
+    this.opened = false;
+  }
+  isOpen() {
+    return this.opened;
+  }
+  async query(sql, params) {
+    this.ensureOpen();
+    try {
+      const stmt = this.db.prepare(sql);
+      if (params && params.length > 0) {
+        stmt.bind(params);
+      }
+      const rows = [];
+      while (stmt.step()) {
+        rows.push(stmt.getAsObject());
+      }
+      stmt.free();
+      return rows;
+    } catch (err) {
+      throw new Error(`Query failed: ${err.message}
+SQL: ${sql}`);
+    }
+  }
+  async queryOne(sql, params) {
+    const rows = await this.query(sql, params);
+    return rows[0] ?? null;
+  }
+  async run(sql, params) {
+    this.ensureOpen();
+    try {
+      const stmt = this.db.prepare(sql);
+      if (params && params.length > 0) {
+        stmt.run(params);
+      } else {
+        stmt.run();
+      }
+      stmt.free();
+      const lastIdResult = this.db.exec("SELECT last_insert_rowid() as id");
+      const lastId = lastIdResult.length > 0 && lastIdResult[0].values.length > 0 ? BigInt(lastIdResult[0].values[0][0]) : BigInt(0);
+      return {
+        changes: this.db.getRowsModified(),
+        lastInsertRowid: lastId
+      };
+    } catch (err) {
+      throw new Error(`Run failed: ${err.message}
+SQL: ${sql}`);
+    }
+  }
+  async exec(sql) {
+    this.ensureOpen();
+    try {
+      this.db.run(sql);
+    } catch (err) {
+      throw new Error(`Exec failed: ${err.message}
+SQL: ${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");
+    }
+    await this.exec("BEGIN TRANSACTION");
+    this.inTransaction = true;
+  }
+  async commit() {
+    if (!this.inTransaction) {
+      throw new Error("No transaction in progress");
+    }
+    await this.exec("COMMIT");
+    this.inTransaction = false;
+  }
+  async rollback() {
+    if (!this.inTransaction) {
+      throw new Error("No transaction in progress");
+    }
+    await this.exec("ROLLBACK");
+    this.inTransaction = false;
+  }
+  async prepare(sql) {
+    this.ensureOpen();
+    return {
+      query: async (params) => this.query(sql, params),
+      queryOne: async (params) => this.queryOne(sql, params),
+      run: async (params) => 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() {
+    return 0;
+  }
+  async vacuum() {
+    await this.exec("VACUUM");
+  }
+  async checkpoint() {
+    return 0;
+  }
+  getStorageMode() {
+    return "memory";
+  }
+  ensureOpen() {
+    if (!this.opened || !this.db) {
+      throw new Error("Database not open. Call open() first.");
+    }
+  }
+};
+async function createMemorySQLiteAdapter() {
+  const adapter = new MemorySQLiteAdapter();
+  await adapter.open({ path: ":memory:" });
+  await adapter.applySchema(SCHEMA_VERSION, SCHEMA_DDL_CORE);
+  return adapter;
+}
+export {
+  MemorySQLiteAdapter,
+  createMemorySQLiteAdapter
+};

package/dist/adapters/web-proxy.d.ts

@@ -0,0 +1,75 @@
+import { S as SQLiteAdapter, P as PreparedStatement } from '../adapter-I7yAV6iu.js';
+import { b as SQLiteConfig, a as SQLRow, S as SQLValue, R as RunResult } from '../types-C_aHfRDF.js';
+
+/**
+ * @xnetjs/sqlite - Main thread proxy for SQLite Web Worker
+ *
+ * This provides a SQLiteAdapter-compatible interface that communicates
+ * with the SQLite worker via postMessage/Comlink.
+ */
+
+/**
+ * SQLite proxy for the main thread.
+ *
+ * This wraps the Web Worker and provides the SQLiteAdapter interface
+ * for use in the main thread React components.
+ *
+ * @example
+ * ```typescript
+ * const proxy = await createWebSQLiteProxy({ path: '/xnet.db' })
+ * const nodes = await proxy.query('SELECT * FROM nodes')
+ * ```
+ */
+declare class WebSQLiteProxy implements SQLiteAdapter {
+    private worker;
+    private proxy;
+    private _config;
+    open(config: SQLiteConfig): Promise<void>;
+    close(): Promise<void>;
+    isOpen(): boolean;
+    query<T extends SQLRow = SQLRow>(sql: string, params?: SQLValue[]): Promise<T[]>;
+    queryOne<T extends SQLRow = SQLRow>(sql: string, params?: SQLValue[]): Promise<T | null>;
+    run(sql: string, params?: SQLValue[]): Promise<RunResult>;
+    exec(sql: string): Promise<void>;
+    transaction<T>(_fn: () => Promise<T>): Promise<T>;
+    /**
+     * Execute multiple operations in a single transaction.
+     * This is the recommended way to do transactions across the worker boundary.
+     *
+     * @example
+     * ```typescript
+     * await proxy.transactionBatch([
+     *   { sql: 'INSERT INTO nodes ...', params: [...] },
+     *   { sql: 'UPDATE nodes ...', params: [...] }
+     * ])
+     * ```
+     */
+    transactionBatch(operations: Array<{
+        sql: string;
+        params?: SQLValue[];
+    }>): Promise<void>;
+    beginTransaction(): Promise<void>;
+    commit(): Promise<void>;
+    rollback(): Promise<void>;
+    prepare(_sql: string): Promise<PreparedStatement>;
+    getSchemaVersion(): Promise<number>;
+    setSchemaVersion(version: number): Promise<void>;
+    applySchema(version: number, sql: string): Promise<boolean>;
+    getDatabaseSize(): Promise<number>;
+    vacuum(): Promise<void>;
+    checkpoint(): Promise<number>;
+    getStorageMode(): Promise<'opfs' | 'memory'>;
+}
+/**
+ * Create a WebSQLiteProxy ready for use.
+ *
+ * @example
+ * ```typescript
+ * const db = await createWebSQLiteProxy({ path: '/xnet.db' })
+ * const nodes = await db.query('SELECT * FROM nodes')
+ * await db.close()
+ * ```
+ */
+declare function createWebSQLiteProxy(config: SQLiteConfig): Promise<WebSQLiteProxy>;
+
+export { WebSQLiteProxy, createWebSQLiteProxy };

package/dist/adapters/web-proxy.js

@@ -0,0 +1,154 @@
+// src/adapters/web-proxy.ts
+import * as Comlink from "comlink";
+function isDebugEnabled() {
+  return typeof localStorage !== "undefined" && localStorage.getItem("xnet:sqlite:debug") === "true";
+}
+function log(...args) {
+  if (isDebugEnabled()) {
+    console.log(...args);
+  }
+}
+var WebSQLiteProxy = class {
+  worker = null;
+  proxy = null;
+  _config = null;
+  async open(config) {
+    if (this.worker) {
+      throw new Error("Already open. Call close() first.");
+    }
+    log("[WebSQLiteProxy] Creating worker...");
+    this.worker = new Worker(new URL("./web-worker.js", import.meta.url), { type: "module" });
+    this.worker.onerror = (event) => {
+      console.error("[WebSQLiteProxy] Worker error:", event);
+    };
+    this.worker.onmessageerror = (event) => {
+      console.error("[WebSQLiteProxy] Worker message error:", event);
+    };
+    log("[WebSQLiteProxy] Worker created, wrapping with Comlink...");
+    this.proxy = Comlink.wrap(this.worker);
+    log("[WebSQLiteProxy] Calling proxy.open()...");
+    const openPromise = this.proxy.open(config);
+    const timeoutPromise = new Promise(
+      (_, reject) => setTimeout(() => reject(new Error("Worker initialization timeout after 15s")), 15e3)
+    );
+    await Promise.race([openPromise, timeoutPromise]);
+    log("[WebSQLiteProxy] proxy.open() completed");
+    this._config = config;
+  }
+  async close() {
+    if (this.proxy) {
+      await this.proxy.close();
+      this.proxy = null;
+    }
+    if (this.worker) {
+      this.worker.terminate();
+      this.worker = null;
+    }
+    this._config = null;
+  }
+  isOpen() {
+    return this.proxy !== null;
+  }
+  async query(sql, params) {
+    if (!this.proxy) throw new Error("Database not open");
+    const result = await this.proxy.query(sql, params);
+    return result;
+  }
+  async queryOne(sql, params) {
+    if (!this.proxy) throw new Error("Database not open");
+    const result = await this.proxy.queryOne(sql, params);
+    return result;
+  }
+  async run(sql, params) {
+    if (!this.proxy) throw new Error("Database not open");
+    return this.proxy.run(sql, params);
+  }
+  async exec(sql) {
+    if (!this.proxy) throw new Error("Database not open");
+    return this.proxy.exec(sql);
+  }
+  async transaction(_fn) {
+    throw new Error("Complex transactions not supported in proxy. Use transactionBatch() instead.");
+  }
+  /**
+   * Execute multiple operations in a single transaction.
+   * This is the recommended way to do transactions across the worker boundary.
+   *
+   * @example
+   * ```typescript
+   * await proxy.transactionBatch([
+   *   { sql: 'INSERT INTO nodes ...', params: [...] },
+   *   { sql: 'UPDATE nodes ...', params: [...] }
+   * ])
+   * ```
+   */
+  async transactionBatch(operations) {
+    if (!this.proxy) throw new Error("Database not open");
+    await this.proxy.transaction(operations);
+  }
+  async beginTransaction() {
+    if (!this.proxy) throw new Error("Database not open");
+    await this.proxy.exec("BEGIN IMMEDIATE");
+  }
+  async commit() {
+    if (!this.proxy) throw new Error("Database not open");
+    await this.proxy.exec("COMMIT");
+  }
+  async rollback() {
+    if (!this.proxy) throw new Error("Database not open");
+    await this.proxy.exec("ROLLBACK");
+  }
+  async prepare(_sql) {
+    throw new Error("Prepared statements not supported in proxy. Use query() or run() directly.");
+  }
+  async getSchemaVersion() {
+    if (!this.proxy) throw new Error("Database not open");
+    return this.proxy.getSchemaVersion();
+  }
+  async setSchemaVersion(version) {
+    if (!this.proxy) throw new Error("Database not open");
+    await this.proxy.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.exec(sql);
+    await this.setSchemaVersion(version);
+    return true;
+  }
+  async getDatabaseSize() {
+    if (!this.proxy) throw new Error("Database not open");
+    return this.proxy.getDatabaseSize();
+  }
+  async vacuum() {
+    if (!this.proxy) throw new Error("Database not open");
+    return this.proxy.vacuum();
+  }
+  async checkpoint() {
+    return 0;
+  }
+  async getStorageMode() {
+    if (!this.proxy) throw new Error("Database not open");
+    try {
+      log("[WebSQLiteProxy] Calling proxy.getStorageMode()...");
+      const mode = await this.proxy.getStorageMode();
+      log("[WebSQLiteProxy] getStorageMode() returned:", mode);
+      return mode;
+    } catch (err) {
+      console.error("[WebSQLiteProxy] getStorageMode() failed:", err);
+      throw err;
+    }
+  }
+};
+async function createWebSQLiteProxy(config) {
+  const proxy = new WebSQLiteProxy();
+  await proxy.open(config);
+  return proxy;
+}
+export {
+  WebSQLiteProxy,
+  createWebSQLiteProxy
+};

package/dist/adapters/web-worker.d.ts

@@ -0,0 +1,32 @@
+import { b as SQLiteConfig, a as SQLRow, S as SQLValue, R as RunResult } from '../types-C_aHfRDF.js';
+
+/**
+ * @xnetjs/sqlite - Web Worker entry point for SQLite WASM
+ *
+ * This file runs in a Web Worker and handles all SQLite operations.
+ * The main thread communicates with it via postMessage/Comlink.
+ */
+
+/**
+ * SQLite worker handler that wraps the adapter for message-based communication.
+ */
+declare class SQLiteWorkerHandler {
+    private adapter;
+    open(config: SQLiteConfig): Promise<void>;
+    close(): Promise<void>;
+    isOpen(): boolean;
+    query<T extends SQLRow = SQLRow>(sql: string, params?: SQLValue[]): Promise<T[]>;
+    queryOne<T extends SQLRow = SQLRow>(sql: string, params?: SQLValue[]): Promise<T | null>;
+    run(sql: string, params?: SQLValue[]): Promise<RunResult>;
+    exec(sql: string): Promise<void>;
+    transaction(operations: Array<{
+        sql: string;
+        params?: SQLValue[];
+    }>): Promise<void>;
+    getSchemaVersion(): Promise<number>;
+    vacuum(): Promise<void>;
+    getDatabaseSize(): Promise<number>;
+    getStorageMode(): Promise<'opfs' | 'memory'>;
+}
+
+export { SQLiteWorkerHandler };

package/dist/adapters/web-worker.js

@@ -0,0 +1,81 @@
+import {
+  createWebSQLiteAdapter
+} from "../chunk-BXYZU3OL.js";
+import "../chunk-HIREU5S5.js";
+
+// src/adapters/web-worker.ts
+import * as Comlink from "comlink";
+function isDebugEnabled() {
+  return typeof self !== "undefined" && typeof localStorage !== "undefined" && localStorage.getItem("xnet:sqlite:debug") === "true";
+}
+function log(...args) {
+  if (isDebugEnabled()) {
+    console.log(...args);
+  }
+}
+log("[SQLiteWorker] Worker script loaded, Comlink imported");
+var SQLiteWorkerHandler = class {
+  adapter = null;
+  async open(config) {
+    log("[SQLiteWorkerHandler] open() called with config:", config);
+    if (this.adapter) {
+      throw new Error("Database already open");
+    }
+    this.adapter = await createWebSQLiteAdapter(config);
+    log("[SQLiteWorkerHandler] open() completed");
+  }
+  async close() {
+    if (this.adapter) {
+      await this.adapter.close();
+      this.adapter = null;
+    }
+  }
+  isOpen() {
+    return this.adapter?.isOpen() ?? false;
+  }
+  async query(sql, params) {
+    if (!this.adapter) throw new Error("Database not open");
+    return this.adapter.query(sql, params);
+  }
+  async queryOne(sql, params) {
+    if (!this.adapter) throw new Error("Database not open");
+    return this.adapter.queryOne(sql, params);
+  }
+  async run(sql, params) {
+    if (!this.adapter) throw new Error("Database not open");
+    return this.adapter.run(sql, params);
+  }
+  async exec(sql) {
+    if (!this.adapter) throw new Error("Database not open");
+    return this.adapter.exec(sql);
+  }
+  async transaction(operations) {
+    if (!this.adapter) throw new Error("Database not open");
+    await this.adapter.transaction(async () => {
+      for (const op of operations) {
+        await this.adapter.run(op.sql, op.params);
+      }
+    });
+  }
+  async getSchemaVersion() {
+    if (!this.adapter) throw new Error("Database not open");
+    return this.adapter.getSchemaVersion();
+  }
+  async vacuum() {
+    if (!this.adapter) throw new Error("Database not open");
+    return this.adapter.vacuum();
+  }
+  async getDatabaseSize() {
+    if (!this.adapter) throw new Error("Database not open");
+    return this.adapter.getDatabaseSize();
+  }
+  async getStorageMode() {
+    if (!this.adapter) throw new Error("Database not open");
+    return this.adapter.getStorageMode();
+  }
+};
+var handler = new SQLiteWorkerHandler();
+log("[SQLiteWorker] Handler instance created");
+log("[SQLiteWorker] Exposing handler via Comlink...");
+Comlink.expose(handler);
+log("[SQLiteWorker] Handler exposed - worker ready!");

package/dist/adapters/web.d.ts

@@ -0,0 +1,64 @@
+import { S as SQLiteAdapter, P as PreparedStatement } from '../adapter-I7yAV6iu.js';
+import { b as SQLiteConfig, a as SQLRow, S as SQLValue, R as RunResult } from '../types-C_aHfRDF.js';
+
+/**
+ * @xnetjs/sqlite - Web SQLite adapter using @sqlite.org/sqlite-wasm
+ *
+ * Uses the official SQLite WASM package with OPFS for browser-based persistence.
+ * Must run in a Web Worker for OPFS access.
+ */
+
+/**
+ * SQLite adapter for web browsers using @sqlite.org/sqlite-wasm.
+ *
+ * Uses the opfs-sahpool VFS for OPFS persistence which:
+ * - Works in Safari 16.4+ (unlike the opfs VFS which needs 17+)
+ * - Doesn't require COOP/COEP headers
+ * - Provides best performance
+ *
+ * Must run in a Web Worker for OPFS access.
+ *
+ * @example
+ * ```typescript
+ * // In a Web Worker
+ * const adapter = new WebSQLiteAdapter()
+ * await adapter.open({ path: '/xnet.db' })
+ *
+ * const nodes = await adapter.query('SELECT * FROM nodes')
+ * ```
+ */
+declare class WebSQLiteAdapter implements SQLiteAdapter {
+    private sqlite3;
+    private db;
+    private poolUtil;
+    private _config;
+    private inTransaction;
+    private storageMode;
+    open(config: SQLiteConfig): Promise<void>;
+    close(): Promise<void>;
+    isOpen(): boolean;
+    getStorageMode(): 'opfs' | 'memory';
+    query<T extends SQLRow = SQLRow>(sql: string, params?: SQLValue[]): Promise<T[]>;
+    queryOne<T extends SQLRow = SQLRow>(sql: string, params?: SQLValue[]): Promise<T | null>;
+    run(sql: string, params?: SQLValue[]): Promise<RunResult>;
+    exec(sql: string): Promise<void>;
+    private execSync;
+    transaction<T>(fn: () => Promise<T>): Promise<T>;
+    beginTransaction(): Promise<void>;
+    commit(): Promise<void>;
+    rollback(): Promise<void>;
+    prepare(sql: string): Promise<PreparedStatement>;
+    getSchemaVersion(): Promise<number>;
+    setSchemaVersion(version: number): Promise<void>;
+    applySchema(version: number, sql: string): Promise<boolean>;
+    getDatabaseSize(): Promise<number>;
+    vacuum(): Promise<void>;
+    checkpoint(): Promise<number>;
+    private ensureOpen;
+}
+/**
+ * Create a WebSQLiteAdapter with schema applied.
+ */
+declare function createWebSQLiteAdapter(config: SQLiteConfig): Promise<WebSQLiteAdapter>;
+
+export { WebSQLiteAdapter, createWebSQLiteAdapter };

package/dist/adapters/web.js

@@ -0,0 +1,9 @@
+import {
+  WebSQLiteAdapter,
+  createWebSQLiteAdapter
+} from "../chunk-BXYZU3OL.js";
+import "../chunk-HIREU5S5.js";
+export {
+  WebSQLiteAdapter,
+  createWebSQLiteAdapter
+};

package/dist/browser-support.d.ts

@@ -0,0 +1,67 @@
+/**
+ * @xnetjs/sqlite - Browser support detection for OPFS-based SQLite
+ */
+/**
+ * Result of browser support check.
+ */
+interface BrowserSupport {
+    /** OPFS is available */
+    opfs: boolean;
+    /** Web Workers are available */
+    worker: boolean;
+    /** Browser is fully supported for SQLite-WASM with OPFS */
+    supported: boolean;
+    /** Reason for lack of support (if not supported) */
+    reason?: string;
+    /** Warning message for soft failures (app can still work with fallback) */
+    warning?: string;
+}
+/**
+ * Check if the current browser supports SQLite-WASM with OPFS.
+ *
+ * Requirements:
+ * - Web Workers (for running SQLite off the main thread)
+ * - Origin Private File System (OPFS) for persistent storage
+ *
+ * Supported browsers:
+ * - Chrome 102+ (March 2022)
+ * - Edge 102+ (March 2022)
+ * - Firefox 111+ (March 2023)
+ * - Safari 16.4+ (March 2023)
+ *
+ * Note: If OPFS test fails but APIs exist, we allow the app to proceed
+ * with a warning. The worker will fall back to in-memory mode if needed.
+ *
+ * @example
+ * ```typescript
+ * const support = await checkBrowserSupport()
+ * if (!support.supported) {
+ *   showUnsupportedBrowserMessage(support.reason!)
+ *   return
+ * }
+ * if (support.warning) {
+ *   showWarningBanner(support.warning)
+ * }
+ * // Proceed with SQLite initialization
+ * ```
+ */
+declare function checkBrowserSupport(): Promise<BrowserSupport>;
+/**
+ * Show an unsupported browser message to the user.
+ *
+ * This replaces the app content with a helpful message explaining
+ * that the browser is not supported and suggesting alternatives.
+ *
+ * @param reason - The reason for lack of support
+ *
+ * @example
+ * ```typescript
+ * const support = await checkBrowserSupport()
+ * if (!support.supported) {
+ *   showUnsupportedBrowserMessage(support.reason!)
+ * }
+ * ```
+ */
+declare function showUnsupportedBrowserMessage(reason: string): void;
+
+export { type BrowserSupport, checkBrowserSupport, showUnsupportedBrowserMessage };

package/dist/browser-support.js

@@ -0,0 +1,8 @@
+import {
+  checkBrowserSupport,
+  showUnsupportedBrowserMessage
+} from "./chunk-ZRR5D2OD.js";
+export {
+  checkBrowserSupport,
+  showUnsupportedBrowserMessage
+};