@xnetjs/sqlite 0.0.2

package/dist/adapters/electron.js

@@ -0,0 +1,336 @@
+import {
+  SCHEMA_DDL,
+  SCHEMA_VERSION
+} from "../chunk-HIREU5S5.js";
+
+// src/adapters/electron.ts
+var DatabaseConstructor = null;
+async function getBetterSqlite3() {
+  if (DatabaseConstructor) return DatabaseConstructor;
+  const module = await import("better-sqlite3");
+  DatabaseConstructor = module.default;
+  return DatabaseConstructor;
+}
+var ElectronSQLiteAdapter = class {
+  db = null;
+  config = null;
+  inTransaction = false;
+  // Cached prepared statements for performance
+  statementCache = /* @__PURE__ */ new Map();
+  async open(config) {
+    if (this.db) {
+      throw new Error("Database already open. Call close() first.");
+    }
+    const Database = await getBetterSqlite3();
+    this.db = new Database(config.path);
+    this.config = config;
+    if (config.walMode !== false) {
+      this.db.pragma("journal_mode = WAL");
+    }
+    if (config.foreignKeys !== false) {
+      this.db.pragma("foreign_keys = ON");
+    }
+    if (config.busyTimeout) {
+      this.db.pragma(`busy_timeout = ${config.busyTimeout}`);
+    } else {
+      this.db.pragma("busy_timeout = 5000");
+    }
+    this.db.pragma("synchronous = NORMAL");
+    this.db.pragma("cache_size = -64000");
+    this.db.pragma("temp_store = MEMORY");
+  }
+  async close() {
+    if (!this.db) return;
+    this.statementCache.clear();
+    if (this.config?.walMode !== false) {
+      try {
+        this.db.pragma("wal_checkpoint(TRUNCATE)");
+      } catch {
+      }
+    }
+    this.db.close();
+    this.db = null;
+    this.config = null;
+  }
+  isOpen() {
+    return this.db !== null;
+  }
+  async query(sql, params) {
+    this.ensureOpen();
+    try {
+      const stmt = this.getOrPrepare(sql);
+      const rows = params ? stmt.all(...params) : stmt.all();
+      return rows;
+    } catch (err) {
+      throw this.wrapError(err, sql);
+    }
+  }
+  async queryOne(sql, params) {
+    this.ensureOpen();
+    try {
+      const stmt = this.getOrPrepare(sql);
+      const row = params ? stmt.get(...params) : stmt.get();
+      return row ?? null;
+    } catch (err) {
+      throw this.wrapError(err, sql);
+    }
+  }
+  async run(sql, params) {
+    this.ensureOpen();
+    try {
+      const stmt = this.getOrPrepare(sql);
+      const result = params ? stmt.run(...params) : stmt.run();
+      return {
+        changes: result.changes,
+        lastInsertRowid: BigInt(result.lastInsertRowid)
+      };
+    } catch (err) {
+      throw this.wrapError(err, sql);
+    }
+  }
+  async exec(sql) {
+    this.ensureOpen();
+    try {
+      this.db.exec(sql);
+    } catch (err) {
+      throw this.wrapError(err, sql);
+    }
+  }
+  async transaction(fn) {
+    this.ensureOpen();
+    await this.beginTransaction();
+    try {
+      const result = await fn();
+      await this.commit();
+      return result;
+    } catch (err) {
+      await this.rollback();
+      throw err;
+    }
+  }
+  /**
+   * Synchronous transaction for performance-critical batch operations.
+   * Prefer this over async transaction when the body is synchronous.
+   */
+  transactionSync(fn) {
+    this.ensureOpen();
+    const txn = this.db.transaction(fn);
+    return txn();
+  }
+  async beginTransaction() {
+    if (this.inTransaction) {
+      throw new Error("Transaction already in progress");
+    }
+    this.db.exec("BEGIN IMMEDIATE");
+    this.inTransaction = true;
+  }
+  async commit() {
+    if (!this.inTransaction) {
+      throw new Error("No transaction in progress");
+    }
+    this.db.exec("COMMIT");
+    this.inTransaction = false;
+  }
+  async rollback() {
+    if (!this.inTransaction) {
+      return;
+    }
+    this.db.exec("ROLLBACK");
+    this.inTransaction = false;
+  }
+  async prepare(sql) {
+    this.ensureOpen();
+    const stmt = this.db.prepare(sql);
+    return {
+      query: async (params) => {
+        const rows = params ? stmt.all(...params) : stmt.all();
+        return rows;
+      },
+      queryOne: async (params) => {
+        const row = params ? stmt.get(...params) : stmt.get();
+        return row ?? null;
+      },
+      run: async (params) => {
+        const result = params ? stmt.run(...params) : stmt.run();
+        return {
+          changes: result.changes,
+          lastInsertRowid: BigInt(result.lastInsertRowid)
+        };
+      },
+      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;
+    }
+    return this.transactionSync(() => {
+      this.db.exec(sql);
+      this.db.prepare("INSERT INTO _schema_version (version, applied_at) VALUES (?, ?)").run(
+        version,
+        Date.now()
+      );
+      return true;
+    });
+  }
+  async getDatabaseSize() {
+    try {
+      const row = await this.queryOne(
+        "SELECT page_count, page_size FROM pragma_page_count(), pragma_page_size()"
+      );
+      if (row) {
+        return row.page_count * row.page_size;
+      }
+      if (this.config?.path && this.config.path !== ":memory:") {
+        const { statSync } = await import("fs");
+        try {
+          const stats = statSync(this.config.path);
+          return stats.size;
+        } catch {
+          return 0;
+        }
+      }
+      return 0;
+    } catch {
+      return 0;
+    }
+  }
+  async vacuum() {
+    this.ensureOpen();
+    this.db.exec("VACUUM");
+  }
+  async checkpoint() {
+    return 0;
+  }
+  getStorageMode() {
+    return "opfs";
+  }
+  // ─── Helper Methods ─────────────────────────────────────────────────────
+  /**
+   * Get a statement from cache or prepare it.
+   * Statement caching significantly improves performance for repeated queries.
+   */
+  getOrPrepare(sql) {
+    let stmt = this.statementCache.get(sql);
+    if (!stmt) {
+      stmt = this.db.prepare(sql);
+      this.statementCache.set(sql, stmt);
+    }
+    return stmt;
+  }
+  ensureOpen() {
+    if (!this.db) {
+      throw new Error("Database not open. Call open() first.");
+    }
+  }
+  wrapError(err, sql) {
+    const message = err instanceof Error ? err.message : String(err);
+    return new Error(
+      `SQLite error: ${message}
+SQL: ${sql.slice(0, 200)}${sql.length > 200 ? "..." : ""}`
+    );
+  }
+  // ─── Electron-Specific Methods ──────────────────────────────────────────
+  /**
+   * Get the underlying better-sqlite3 database instance.
+   * Use for advanced operations not covered by the interface.
+   */
+  getRawDatabase() {
+    this.ensureOpen();
+    return this.db;
+  }
+  /**
+   * Create a batch writer for efficient bulk inserts.
+   */
+  createBatchWriter(options) {
+    return new ElectronBatchWriter(this, options);
+  }
+};
+var ElectronBatchWriter = class {
+  adapter;
+  pendingOps = [];
+  maxBatchSize;
+  flushTimer = null;
+  flushPromise = null;
+  constructor(adapter, options) {
+    this.adapter = adapter;
+    this.maxBatchSize = options?.maxBatchSize ?? 100;
+  }
+  /**
+   * Queue an operation for batch execution.
+   */
+  queue(sql, params) {
+    this.pendingOps.push({ sql, params });
+    if (this.pendingOps.length >= this.maxBatchSize) {
+      this.flush();
+    } else if (!this.flushTimer) {
+      this.flushTimer = setTimeout(() => this.flush(), 50);
+    }
+  }
+  /**
+   * Flush all pending operations.
+   */
+  async flush() {
+    if (this.flushTimer) {
+      clearTimeout(this.flushTimer);
+      this.flushTimer = null;
+    }
+    if (this.pendingOps.length === 0) return;
+    if (this.flushPromise) {
+      await this.flushPromise;
+      return this.flush();
+    }
+    const ops = this.pendingOps;
+    this.pendingOps = [];
+    this.flushPromise = (async () => {
+      this.adapter.transactionSync(() => {
+        const db = this.adapter.getRawDatabase();
+        for (const { sql, params } of ops) {
+          db.prepare(sql).run(...params);
+        }
+      });
+    })();
+    try {
+      await this.flushPromise;
+    } finally {
+      this.flushPromise = null;
+    }
+  }
+  /**
+   * Close the batch writer, flushing any pending operations.
+   */
+  async close() {
+    await this.flush();
+  }
+};
+async function createElectronSQLiteAdapter(config) {
+  const adapter = new ElectronSQLiteAdapter();
+  await adapter.open(config);
+  await adapter.applySchema(SCHEMA_VERSION, SCHEMA_DDL);
+  return adapter;
+}
+export {
+  ElectronBatchWriter,
+  ElectronSQLiteAdapter,
+  SCHEMA_DDL,
+  SCHEMA_VERSION,
+  createElectronSQLiteAdapter
+};

package/dist/adapters/expo.d.ts

@@ -0,0 +1,65 @@
+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 - Expo SQLite adapter using expo-sqlite
+ *
+ * expo-sqlite runs SQLite on a native thread for performance.
+ * All methods are async to match the native API.
+ */
+
+/**
+ * SQLite adapter for Expo/React Native using expo-sqlite.
+ *
+ * expo-sqlite runs SQLite on a native thread for performance.
+ * All methods are async to match the native API.
+ *
+ * @example
+ * ```typescript
+ * const adapter = new ExpoSQLiteAdapter()
+ * await adapter.open({ path: 'xnet.db' })
+ *
+ * const nodes = await adapter.query('SELECT * FROM nodes')
+ * ```
+ */
+declare class ExpoSQLiteAdapter implements SQLiteAdapter {
+    private db;
+    private config;
+    private inTransaction;
+    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>;
+    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(): 'opfs' | 'memory';
+    private ensureOpen;
+    /**
+     * Get storage statistics.
+     */
+    getStats(): Promise<{
+        documentCount: number;
+        updateCount: number;
+        snapshotCount: number;
+        blobCount: number;
+        totalBlobSize: number;
+    }>;
+}
+/**
+ * Create an ExpoSQLiteAdapter with schema applied.
+ */
+declare function createExpoSQLiteAdapter(config: SQLiteConfig): Promise<ExpoSQLiteAdapter>;
+
+export { ExpoSQLiteAdapter, createExpoSQLiteAdapter };

package/dist/adapters/expo.js

@@ -0,0 +1,217 @@
+import {
+  SCHEMA_DDL,
+  SCHEMA_VERSION
+} from "../chunk-HIREU5S5.js";
+
+// src/adapters/expo.ts
+var ExpoSQLiteAdapter = class {
+  db = null;
+  config = null;
+  inTransaction = false;
+  async open(config) {
+    if (this.db) {
+      throw new Error("Database already open. Call close() first.");
+    }
+    const SQLite = await import("expo-sqlite");
+    this.db = await SQLite.openDatabaseAsync(config.path);
+    this.config = config;
+    if (config.foreignKeys !== false) {
+      await this.exec("PRAGMA foreign_keys = ON");
+    }
+    if (config.busyTimeout) {
+      await this.exec(`PRAGMA busy_timeout = ${config.busyTimeout}`);
+    } else {
+      await this.exec("PRAGMA busy_timeout = 5000");
+    }
+    await this.exec("PRAGMA synchronous = NORMAL");
+    await this.exec("PRAGMA cache_size = -32000");
+    await this.exec("PRAGMA temp_store = MEMORY");
+    if (config.walMode !== false) {
+      await this.exec("PRAGMA journal_mode = WAL");
+    }
+  }
+  async close() {
+    if (this.db) {
+      await this.db.closeAsync();
+      this.db = null;
+    }
+    this.config = null;
+  }
+  isOpen() {
+    return this.db !== null;
+  }
+  async query(sql, params) {
+    this.ensureOpen();
+    const result = await this.db.getAllAsync(sql, params ?? []);
+    return result;
+  }
+  async queryOne(sql, params) {
+    this.ensureOpen();
+    const result = await this.db.getFirstAsync(sql, params ?? []);
+    return result ?? null;
+  }
+  async run(sql, params) {
+    this.ensureOpen();
+    const result = await this.db.runAsync(sql, params ?? []);
+    return {
+      changes: result.changes,
+      lastInsertRowid: BigInt(result.lastInsertRowId)
+    };
+  }
+  async exec(sql) {
+    this.ensureOpen();
+    await this.db.execAsync(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 IMMEDIATE");
+    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) {
+      return;
+    }
+    await this.exec("ROLLBACK");
+    this.inTransaction = false;
+  }
+  async prepare(sql) {
+    this.ensureOpen();
+    const stmt = await this.db.prepareAsync(sql);
+    return {
+      query: async (params) => {
+        const result = await stmt.executeAsync(params ?? []);
+        return await result.getAllAsync();
+      },
+      queryOne: async (params) => {
+        const result = await stmt.executeAsync(params ?? []);
+        const first = await result.getFirstAsync();
+        return first ?? null;
+      },
+      run: async (params) => {
+        await stmt.executeAsync(params ?? []);
+        const changesRow = await this.db.getFirstAsync(
+          "SELECT changes() as changes",
+          []
+        );
+        const lastIdRow = await this.db.getFirstAsync(
+          "SELECT last_insert_rowid() as id",
+          []
+        );
+        return {
+          changes: changesRow?.changes ?? 0,
+          lastInsertRowid: BigInt(lastIdRow?.id ?? 0)
+        };
+      },
+      finalize: async () => {
+        await stmt.finalizeAsync();
+      }
+    };
+  }
+  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() {
+    try {
+      const result = await this.queryOne("PRAGMA wal_checkpoint(PASSIVE)");
+      return result?.checkpointed ?? 0;
+    } catch {
+      return 0;
+    }
+  }
+  getStorageMode() {
+    return "opfs";
+  }
+  ensureOpen() {
+    if (!this.db) {
+      throw new Error("Database not open. Call open() first.");
+    }
+  }
+  // ─── Expo-Specific Methods ──────────────────────────────────────────────
+  /**
+   * Get storage statistics.
+   */
+  async getStats() {
+    const [nodes, changes, blobs] = await Promise.all([
+      this.queryOne("SELECT COUNT(*) as count FROM nodes"),
+      this.queryOne("SELECT COUNT(*) as count FROM changes"),
+      this.queryOne(
+        "SELECT COUNT(*) as count, COALESCE(SUM(size), 0) as total_size FROM blobs"
+      )
+    ]);
+    return {
+      documentCount: nodes?.count ?? 0,
+      updateCount: changes?.count ?? 0,
+      snapshotCount: 0,
+      // Snapshots are derived, not stored separately
+      blobCount: blobs?.count ?? 0,
+      totalBlobSize: blobs?.total_size ?? 0
+    };
+  }
+};
+async function createExpoSQLiteAdapter(config) {
+  const adapter = new ExpoSQLiteAdapter();
+  await adapter.open(config);
+  await adapter.applySchema(SCHEMA_VERSION, SCHEMA_DDL);
+  return adapter;
+}
+export {
+  ExpoSQLiteAdapter,
+  createExpoSQLiteAdapter
+};

package/dist/adapters/memory.d.ts

@@ -0,0 +1,46 @@
+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 - In-memory SQLite adapter for testing
+ *
+ * Uses sql.js (SQLite compiled to WASM) for Node.js testing.
+ */
+
+/**
+ * In-memory SQLite adapter using sql.js for testing.
+ * This adapter is synchronous but exposes async interface for compatibility.
+ *
+ * Note: Requires sql.js as a dev dependency for tests.
+ */
+declare class MemorySQLiteAdapter implements SQLiteAdapter {
+    private db;
+    private opened;
+    private inTransaction;
+    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>;
+    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(): 'opfs' | 'memory';
+    private ensureOpen;
+}
+/**
+ * Create a MemorySQLiteAdapter with schema applied.
+ */
+declare function createMemorySQLiteAdapter(): Promise<MemorySQLiteAdapter>;
+
+export { MemorySQLiteAdapter, createMemorySQLiteAdapter };