@rocicorp/zero 0.22.2025081301 → 0.23.2025081400

package/out/expo.js

@@ -0,0 +1,356 @@
+import {
+  promiseUndefined,
+  promiseVoid
+} from "./chunk-MKB4RXL3.js";
+import {
+  deepFreeze
+} from "./chunk-SGW2EIVJ.js";
+import "./chunk-424PT5DM.js";
+
+// ../zero-expo/src/store.ts
+import {
+  deleteDatabaseSync,
+  openDatabaseSync
+} from "expo-sqlite";
+
+// ../replicache/src/kv/sqlite-store.ts
+import { Lock, RWLock } from "@rocicorp/lock";
+var getTransactionPreparedStatements = (db) => ({
+  begin: db.prepare("BEGIN"),
+  beginImmediate: db.prepare("BEGIN IMMEDIATE"),
+  commit: db.prepare("COMMIT"),
+  rollback: db.prepare("ROLLBACK")
+});
+var getRWPreparedStatements = (db) => ({
+  get: db.prepare("SELECT value FROM entry WHERE key = ?"),
+  put: db.prepare("INSERT OR REPLACE INTO entry (key, value) VALUES (?, ?)"),
+  del: db.prepare("DELETE FROM entry WHERE key = ?")
+});
+var SQLiteReadConnectionManager = class {
+  #pool = [];
+  #nextIndex = 0;
+  #rwLock;
+  constructor(name, manager, rwLock, opts) {
+    if (opts.readPoolSize <= 1) {
+      throw new Error("readPoolSize must be greater than 1");
+    }
+    this.#rwLock = rwLock;
+    for (let i = 0; i < opts.readPoolSize; i++) {
+      const { db, preparedStatements } = manager.open(name, opts);
+      this.#pool.push({
+        db,
+        lock: new Lock(),
+        preparedStatements
+      });
+    }
+  }
+  /**
+   * Acquire a round-robin read connection from the pool.
+   *
+   * The returned `release` callback **must** be invoked once the caller is done
+   * using the prepared statements, otherwise other readers may be blocked
+   * indefinitely.
+   */
+  async acquire() {
+    const slot = this.#nextIndex;
+    this.#nextIndex = (this.#nextIndex + 1) % this.#pool.length;
+    const entry = this.#pool[slot];
+    const releaseRWLock = await this.#rwLock.read();
+    const releaseLock = await entry.lock.lock();
+    return {
+      preparedStatements: entry.preparedStatements,
+      release: () => {
+        releaseRWLock();
+        releaseLock();
+      }
+    };
+  }
+  /**
+   * Finalizes all prepared statements and closes the underlying connections.
+   * After calling this method the manager can no longer be used.
+   */
+  close() {
+    for (const entry of this.#pool) {
+      for (const stmt of Object.values(entry.preparedStatements)) {
+        stmt.finalize();
+      }
+      entry.db.close();
+    }
+    this.#pool = [];
+  }
+};
+var SQLiteWriteConnectionManager = class {
+  #rwLock;
+  #preparedStatements;
+  #db;
+  constructor(name, manager, rwLock, opts) {
+    const { db, preparedStatements } = manager.open(name, opts);
+    this.#preparedStatements = preparedStatements;
+    this.#db = db;
+    this.#rwLock = rwLock;
+  }
+  async acquire() {
+    const release = await this.#rwLock.write();
+    return { preparedStatements: this.#preparedStatements, release };
+  }
+  close() {
+    for (const stmt of Object.values(this.#preparedStatements)) {
+      stmt.finalize();
+    }
+    this.#db.close();
+  }
+};
+var SQLiteStore = class {
+  #name;
+  #dbm;
+  #writeConnectionManager;
+  #readConnectionManager;
+  #rwLock = new RWLock();
+  #closed = false;
+  constructor(name, dbm, opts) {
+    this.#name = name;
+    this.#dbm = dbm;
+    this.#writeConnectionManager = new SQLiteWriteConnectionManager(
+      name,
+      dbm,
+      this.#rwLock,
+      opts
+    );
+    this.#readConnectionManager = new SQLiteReadConnectionManager(
+      name,
+      dbm,
+      this.#rwLock,
+      opts
+    );
+  }
+  async read() {
+    const { preparedStatements, release } = await this.#readConnectionManager.acquire();
+    return new SQLiteStoreRead(preparedStatements, release);
+  }
+  async write() {
+    const { preparedStatements, release } = await this.#writeConnectionManager.acquire();
+    return new SQLiteStoreWrite(preparedStatements, release);
+  }
+  close() {
+    this.#writeConnectionManager.close();
+    this.#readConnectionManager.close();
+    this.#dbm.close(this.#name);
+    this.#closed = true;
+    return promiseVoid;
+  }
+  get closed() {
+    return this.#closed;
+  }
+};
+var SQLiteStoreRWBase = class {
+  _preparedStatements;
+  #release;
+  #closed = false;
+  constructor(preparedStatements, release) {
+    this._preparedStatements = preparedStatements;
+    this.#release = release;
+  }
+  has(key) {
+    const unsafeValue = this.#getSql(key);
+    return Promise.resolve(unsafeValue !== void 0);
+  }
+  get(key) {
+    const unsafeValue = this.#getSql(key);
+    if (unsafeValue === void 0) return promiseUndefined;
+    const parsedValue = JSON.parse(unsafeValue);
+    const frozenValue = deepFreeze(parsedValue);
+    return Promise.resolve(frozenValue);
+  }
+  #getSql(key) {
+    const rows = this._preparedStatements.get.all(key);
+    if (rows.length === 0) return void 0;
+    return rows[0].value;
+  }
+  _release() {
+    this.#closed = true;
+    this.#release();
+  }
+  get closed() {
+    return this.#closed;
+  }
+};
+var SQLiteStoreRead = class extends SQLiteStoreRWBase {
+  constructor(preparedStatements, release) {
+    super(preparedStatements, release);
+    this._preparedStatements.begin.run();
+  }
+  release() {
+    this._preparedStatements.commit.run();
+    this._release();
+  }
+};
+var SQLiteStoreWrite = class extends SQLiteStoreRWBase {
+  #committed = false;
+  constructor(preparedStatements, release) {
+    super(preparedStatements, release);
+    this._preparedStatements.beginImmediate.run();
+  }
+  put(key, value) {
+    this._preparedStatements.put.run(key, JSON.stringify(value));
+    return promiseVoid;
+  }
+  del(key) {
+    this._preparedStatements.del.run(key);
+    return promiseVoid;
+  }
+  commit() {
+    this._preparedStatements.commit.run();
+    this.#committed = true;
+    return promiseVoid;
+  }
+  release() {
+    if (!this.#committed) {
+      this._preparedStatements.rollback.run();
+    }
+    this._release();
+  }
+};
+var safeFilename = (name) => name.replace(/[^a-zA-Z0-9]/g, "_");
+function createSQLiteStore(dbm) {
+  return (name, opts) => new SQLiteStore(name, dbm, opts);
+}
+var SQLiteDatabaseManager = class {
+  #dbm;
+  #dbInstances = /* @__PURE__ */ new Map();
+  constructor(dbm) {
+    this.#dbm = dbm;
+  }
+  clearAllStoresForTesting() {
+    for (const [name] of this.#dbInstances) {
+      this.destroy(name);
+    }
+  }
+  open(name, opts) {
+    const dbInstance = this.#dbInstances.get(name);
+    const fileName = safeFilename(name);
+    const newDb = this.#dbm.open(fileName);
+    const txPreparedStatements = getTransactionPreparedStatements(newDb);
+    const exec = (sql) => {
+      const statement = newDb.prepare(sql);
+      statement.run();
+      statement.finalize();
+    };
+    if (!dbInstance) {
+      this.#ensureSchema(exec, txPreparedStatements);
+    }
+    if (opts.busyTimeout !== void 0) {
+      exec(`PRAGMA busy_timeout = ${opts.busyTimeout}`);
+    }
+    if (opts.journalMode !== void 0) {
+      exec(`PRAGMA journal_mode = ${opts.journalMode}`);
+    }
+    if (opts.synchronous !== void 0) {
+      exec(`PRAGMA synchronous = ${opts.synchronous}`);
+    }
+    if (opts.readUncommitted !== void 0) {
+      exec(
+        `PRAGMA read_uncommitted = ${opts.readUncommitted ? "true" : "false"}`
+      );
+    }
+    const rwPreparedStatements = getRWPreparedStatements(newDb);
+    const preparedStatements = {
+      ...txPreparedStatements,
+      ...rwPreparedStatements
+    };
+    this.#dbInstances.set(name, {
+      instances: [
+        ...dbInstance?.instances ?? [],
+        { db: newDb, preparedStatements }
+      ]
+    });
+    return {
+      db: newDb,
+      preparedStatements
+    };
+  }
+  close(name) {
+    const dbInstance = this.#dbInstances.get(name);
+    if (!dbInstance) return;
+    for (const instance of dbInstance.instances) {
+      for (const stmt of Object.values(instance.preparedStatements)) {
+        stmt.finalize();
+      }
+      instance.db.close();
+    }
+  }
+  destroy(name) {
+    const dbInstance = this.#dbInstances.get(name);
+    if (!dbInstance) return;
+    for (const instance of dbInstance.instances) {
+      for (const stmt of Object.values(instance.preparedStatements)) {
+        stmt.finalize();
+      }
+      instance.db.close();
+    }
+    for (const instance of dbInstance.instances) {
+      instance.db.destroy();
+    }
+    this.#dbInstances.delete(name);
+  }
+  #ensureSchema(exec, preparedStatements) {
+    preparedStatements.begin.run();
+    try {
+      exec(
+        "CREATE TABLE IF NOT EXISTS entry (key TEXT PRIMARY KEY, value TEXT NOT NULL) WITHOUT ROWID"
+      );
+      preparedStatements.commit.run();
+    } catch (e) {
+      preparedStatements.rollback.run();
+      throw e;
+    }
+  }
+};
+
+// ../zero-expo/src/store.ts
+var expoDbManagerInstance = new SQLiteDatabaseManager({
+  open: (fileName) => {
+    const db = openDatabaseSync(fileName);
+    const genericDb = {
+      close: () => db.closeSync(),
+      destroy: () => {
+        db.closeSync();
+        deleteDatabaseSync(fileName);
+      },
+      prepare: (sql) => {
+        const stmt = db.prepareSync(sql);
+        return {
+          run: (...params) => {
+            stmt.executeSync(params);
+          },
+          all: (...params) => {
+            const result = stmt.executeSync(params);
+            return result.getAllSync();
+          },
+          finalize: () => stmt.finalizeSync()
+        };
+      }
+    };
+    return genericDb;
+  }
+});
+var expoSQLiteStoreProvider = (opts) => ({
+  create: (name) => createSQLiteStore(expoDbManagerInstance)(name, {
+    // we default to 3 read connections for mobile devices
+    readPoolSize: 3,
+    busyTimeout: 200,
+    synchronous: "NORMAL",
+    readUncommitted: false,
+    ...opts,
+    // we override the journal mode to undefined because
+    // setting it to WAL causes hanging COMMITs on Expo
+    journalMode: void 0
+  }),
+  drop: (name) => {
+    expoDbManagerInstance.destroy(name);
+    return promiseVoid;
+  }
+});
+export {
+  expoSQLiteStoreProvider
+};
+//# sourceMappingURL=expo.js.map

package/out/expo.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../zero-expo/src/store.ts", "../../replicache/src/kv/sqlite-store.ts"],
+  "sourcesContent": ["import {\n  deleteDatabaseSync,\n  openDatabaseSync,\n  type SQLiteBindParams,\n} from 'expo-sqlite';\nimport {\n  createSQLiteStore,\n  SQLiteDatabaseManager,\n  type SQLiteDatabase,\n  type SQLiteDatabaseManagerOptions,\n} from '../../replicache/src/kv/sqlite-store.ts';\nimport type {StoreProvider} from '../../replicache/src/kv/store.ts';\nimport {promiseVoid} from '../../shared/src/resolved-promises.ts';\n\nconst expoDbManagerInstance = new SQLiteDatabaseManager({\n  open: fileName => {\n    const db = openDatabaseSync(fileName);\n\n    const genericDb: SQLiteDatabase = {\n      close: () => db.closeSync(),\n      destroy: () => {\n        db.closeSync();\n        deleteDatabaseSync(fileName);\n      },\n      prepare: (sql: string) => {\n        const stmt = db.prepareSync(sql);\n        return {\n          run: (...params: unknown[]): void => {\n            stmt.executeSync(params as SQLiteBindParams);\n          },\n          all: <T>(...params: unknown[]): T[] => {\n            const result = stmt.executeSync(params as SQLiteBindParams);\n            return result.getAllSync() as unknown as T[];\n          },\n          finalize: () => stmt.finalizeSync(),\n        };\n      },\n    };\n\n    return genericDb;\n  },\n});\n\nexport const expoSQLiteStoreProvider = (\n  opts?: Partial<Omit<SQLiteDatabaseManagerOptions, 'journalMode'>>,\n): StoreProvider => ({\n  create: (name: string) =>\n    createSQLiteStore(expoDbManagerInstance)(name, {\n      // we default to 3 read connections for mobile devices\n      readPoolSize: 3,\n      busyTimeout: 200,\n      synchronous: 'NORMAL',\n      readUncommitted: false,\n      ...opts,\n      // we override the journal mode to undefined because\n      // setting it to WAL causes hanging COMMITs on Expo\n      journalMode: undefined,\n    }),\n  drop: (name: string) => {\n    expoDbManagerInstance.destroy(name);\n\n    return promiseVoid;\n  },\n});\n", "import {Lock, RWLock} from '@rocicorp/lock';\nimport type {ReadonlyJSONValue} from '../../../shared/src/json.ts';\nimport {\n  promiseUndefined,\n  promiseVoid,\n} from '../../../shared/src/resolved-promises.ts';\nimport {deepFreeze} from '../frozen-json.ts';\nimport type {Read, Store, Write} from './store.ts';\n\n/**\n * A SQLite prepared statement.\n *\n * `run` executes the statement with optional parameters.\n * `all` executes the statement and returns the result rows.\n * `finalize` releases the statement.\n */\nexport interface PreparedStatement {\n  run(...params: unknown[]): void;\n  all<T>(...params: unknown[]): T[];\n  finalize(): void;\n}\n\nexport interface SQLiteDatabase {\n  /**\n   * Close the database connection.\n   */\n  close(): void;\n\n  /**\n   * Destroy or delete the database (e.g. delete file).\n   */\n  destroy(): void;\n\n  /**\n   * Prepare a SQL string, returning a statement you can execute.\n   * E.g. `const stmt = db.prepare(\"SELECT * FROM todos WHERE id=?\");`\n   */\n  prepare(sql: string): PreparedStatement;\n}\n\ntype SQLiteTransactionPreparedStatements = {\n  begin: PreparedStatement;\n  beginImmediate: PreparedStatement;\n  commit: PreparedStatement;\n  rollback: PreparedStatement;\n};\n\nconst getTransactionPreparedStatements = (\n  db: SQLiteDatabase,\n): SQLiteTransactionPreparedStatements => ({\n  begin: db.prepare('BEGIN'),\n  beginImmediate: db.prepare('BEGIN IMMEDIATE'),\n  commit: db.prepare('COMMIT'),\n  rollback: db.prepare('ROLLBACK'),\n});\n\ntype SQLiteRWPreparedStatements = {\n  get: PreparedStatement;\n  put: PreparedStatement;\n  del: PreparedStatement;\n};\n\nconst getRWPreparedStatements = (\n  db: SQLiteDatabase,\n): SQLiteRWPreparedStatements => ({\n  get: db.prepare('SELECT value FROM entry WHERE key = ?'),\n  put: db.prepare('INSERT OR REPLACE INTO entry (key, value) VALUES (?, ?)'),\n  del: db.prepare('DELETE FROM entry WHERE key = ?'),\n});\n\ntype SQLitePreparedStatements = SQLiteTransactionPreparedStatements &\n  SQLiteRWPreparedStatements;\n\ninterface SQLiteConnectionManager {\n  acquire(): Promise<{\n    preparedStatements: SQLitePreparedStatements;\n    release: () => void;\n  }>;\n  close(): void;\n}\n\ntype SQLitePreparedStatementPoolEntry = {\n  db: SQLiteDatabase;\n  lock: Lock;\n  preparedStatements: SQLitePreparedStatements;\n};\n\n/**\n * Manages a pool of read-only SQLite connections.\n *\n * Each connection in the pool is protected by its own `Lock` instance which\n * guarantees that it is held by at most one reader at a time. Consumers call\n * {@link acquire} to get access to a set of prepared statements for a\n * connection and must invoke the provided `release` callback when they are\n * finished.\n *\n * The pool eagerly creates the configured number of connections up-front so\n * that the first `acquire` call never has to pay the connection setup cost.\n */\nclass SQLiteReadConnectionManager implements SQLiteConnectionManager {\n  #pool: SQLitePreparedStatementPoolEntry[] = [];\n  #nextIndex = 0;\n  readonly #rwLock: RWLock;\n\n  constructor(\n    name: string,\n    manager: SQLiteDatabaseManager,\n    rwLock: RWLock,\n    opts: SQLiteDatabaseManagerOptions,\n  ) {\n    if (opts.readPoolSize <= 1) {\n      throw new Error('readPoolSize must be greater than 1');\n    }\n\n    this.#rwLock = rwLock;\n\n    for (let i = 0; i < opts.readPoolSize; i++) {\n      // create a new readonly SQLiteDatabase for each instance in the pool\n      const {db, preparedStatements} = manager.open(name, opts);\n      this.#pool.push({\n        db,\n        lock: new Lock(),\n        preparedStatements,\n      });\n    }\n  }\n\n  /**\n   * Acquire a round-robin read connection from the pool.\n   *\n   * The returned `release` callback **must** be invoked once the caller is done\n   * using the prepared statements, otherwise other readers may be blocked\n   * indefinitely.\n   */\n  async acquire(): Promise<{\n    preparedStatements: SQLitePreparedStatements;\n    release: () => void;\n  }> {\n    const slot = this.#nextIndex;\n    this.#nextIndex = (this.#nextIndex + 1) % this.#pool.length;\n\n    const entry = this.#pool[slot];\n\n    // we have two levels of locking\n    // 1. the RWLock to prevent concurrent read operations while a write is in progress\n    // 2. the Lock to prevent concurrent read operations on the same connection\n    const releaseRWLock = await this.#rwLock.read();\n    const releaseLock = await entry.lock.lock();\n\n    return {\n      preparedStatements: entry.preparedStatements,\n      release: () => {\n        releaseRWLock();\n        releaseLock();\n      },\n    };\n  }\n\n  /**\n   * Finalizes all prepared statements and closes the underlying connections.\n   * After calling this method the manager can no longer be used.\n   */\n  close(): void {\n    for (const entry of this.#pool) {\n      for (const stmt of Object.values(entry.preparedStatements)) {\n        stmt.finalize();\n      }\n      entry.db.close();\n    }\n    this.#pool = [];\n  }\n}\n\n/**\n * Manages a single write connection with an external RWLock.\n */\nclass SQLiteWriteConnectionManager implements SQLiteConnectionManager {\n  readonly #rwLock: RWLock;\n  readonly #preparedStatements: SQLitePreparedStatements;\n  readonly #db: SQLiteDatabase;\n\n  constructor(\n    name: string,\n    manager: SQLiteDatabaseManager,\n    rwLock: RWLock,\n    opts: SQLiteDatabaseManagerOptions,\n  ) {\n    const {db, preparedStatements} = manager.open(name, opts);\n    this.#preparedStatements = preparedStatements;\n    this.#db = db;\n    this.#rwLock = rwLock;\n  }\n\n  async acquire(): Promise<{\n    preparedStatements: SQLitePreparedStatements;\n    release: () => void;\n  }> {\n    const release = await this.#rwLock.write();\n    return {preparedStatements: this.#preparedStatements, release};\n  }\n\n  close(): void {\n    for (const stmt of Object.values(this.#preparedStatements)) {\n      stmt.finalize();\n    }\n    this.#db.close();\n  }\n}\n\n/**\n * A SQLite-based Store implementation.\n *\n * This store provides a generic SQLite implementation that can be used with different\n * SQLite providers (expo-sqlite, better-sqlite3, etc). It implements the Store\n * interface using a single 'entry' table with key-value pairs.\n *\n * The store uses a single RWLock to prevent concurrent read and write operations.\n *\n * The store also uses a pool of read connections to allow concurrent reads with separate transactions.\n */\nexport class SQLiteStore implements Store {\n  readonly #name: string;\n  readonly #dbm: SQLiteDatabaseManager;\n  readonly #writeConnectionManager: SQLiteConnectionManager;\n  readonly #readConnectionManager: SQLiteConnectionManager;\n  readonly #rwLock = new RWLock();\n\n  #closed = false;\n\n  constructor(\n    name: string,\n    dbm: SQLiteDatabaseManager,\n    opts: SQLiteDatabaseManagerOptions,\n  ) {\n    this.#name = name;\n    this.#dbm = dbm;\n\n    this.#writeConnectionManager = new SQLiteWriteConnectionManager(\n      name,\n      dbm,\n      this.#rwLock,\n      opts,\n    );\n    this.#readConnectionManager = new SQLiteReadConnectionManager(\n      name,\n      dbm,\n      this.#rwLock,\n      opts,\n    );\n  }\n\n  async read(): Promise<Read> {\n    const {preparedStatements, release} =\n      await this.#readConnectionManager.acquire();\n    return new SQLiteStoreRead(preparedStatements, release);\n  }\n\n  async write(): Promise<Write> {\n    const {preparedStatements, release} =\n      await this.#writeConnectionManager.acquire();\n    return new SQLiteStoreWrite(preparedStatements, release);\n  }\n\n  close(): Promise<void> {\n    this.#writeConnectionManager.close();\n    this.#readConnectionManager.close();\n    this.#dbm.close(this.#name);\n    this.#closed = true;\n\n    return promiseVoid;\n  }\n\n  get closed(): boolean {\n    return this.#closed;\n  }\n}\n\nclass SQLiteStoreRWBase {\n  protected readonly _preparedStatements: SQLitePreparedStatements;\n  readonly #release: () => void;\n  #closed = false;\n\n  constructor(\n    preparedStatements: SQLitePreparedStatements,\n    release: () => void,\n  ) {\n    this._preparedStatements = preparedStatements;\n    this.#release = release;\n  }\n\n  has(key: string): Promise<boolean> {\n    const unsafeValue = this.#getSql(key);\n    return Promise.resolve(unsafeValue !== undefined);\n  }\n\n  get(key: string): Promise<ReadonlyJSONValue | undefined> {\n    const unsafeValue = this.#getSql(key);\n    if (unsafeValue === undefined) return promiseUndefined;\n    const parsedValue = JSON.parse(unsafeValue) as ReadonlyJSONValue;\n    const frozenValue = deepFreeze(parsedValue);\n    return Promise.resolve(frozenValue);\n  }\n\n  #getSql(key: string): string | undefined {\n    const rows = this._preparedStatements.get.all<{value: string}>(key);\n    if (rows.length === 0) return undefined;\n    return rows[0].value;\n  }\n\n  protected _release(): void {\n    this.#closed = true;\n    this.#release();\n  }\n\n  get closed(): boolean {\n    return this.#closed;\n  }\n}\n\nexport class SQLiteStoreRead extends SQLiteStoreRWBase implements Read {\n  constructor(\n    preparedStatements: SQLitePreparedStatements,\n    release: () => void,\n  ) {\n    super(preparedStatements, release);\n\n    // BEGIN\n    this._preparedStatements.begin.run();\n  }\n\n  release(): void {\n    // COMMIT\n    this._preparedStatements.commit.run();\n\n    this._release();\n  }\n}\n\nexport class SQLiteStoreWrite extends SQLiteStoreRWBase implements Write {\n  #committed = false;\n\n  constructor(\n    preparedStatements: SQLitePreparedStatements,\n    release: () => void,\n  ) {\n    super(preparedStatements, release);\n\n    // BEGIN IMMEDIATE grabs a RESERVED lock\n    this._preparedStatements.beginImmediate.run();\n  }\n\n  put(key: string, value: ReadonlyJSONValue): Promise<void> {\n    this._preparedStatements.put.run(key, JSON.stringify(value));\n    return promiseVoid;\n  }\n\n  del(key: string): Promise<void> {\n    this._preparedStatements.del.run(key);\n    return promiseVoid;\n  }\n\n  commit(): Promise<void> {\n    // COMMIT\n    this._preparedStatements.commit.run();\n    this.#committed = true;\n    return promiseVoid;\n  }\n\n  release(): void {\n    if (!this.#committed) {\n      // ROLLBACK if not committed\n      this._preparedStatements.rollback.run();\n    }\n\n    this._release();\n  }\n}\n\nexport interface GenericSQLiteDatabaseManager {\n  open(fileName: string): SQLiteDatabase;\n}\n\n// we replace non-alphanumeric characters with underscores\n// because SQLite doesn't allow them in database names\nconst safeFilename = (name: string) => name.replace(/[^a-zA-Z0-9]/g, '_');\n\n/**\n * Creates a function that returns new SQLite store instances.\n * This is the main entry point for using the SQLite store implementation.\n *\n * @param dbm The SQLite database manager implementation\n * @returns A function that creates new store instances\n */\nexport function createSQLiteStore(dbm: SQLiteDatabaseManager) {\n  return (name: string, opts: SQLiteDatabaseManagerOptions) =>\n    new SQLiteStore(name, dbm, opts);\n}\n\nexport type SQLiteDatabaseManagerOptions = {\n  /**\n   * The number of read connections to keep open.\n   *\n   * This must be greater than 1 to support concurrent reads.\n   */\n  readPoolSize: number;\n\n  busyTimeout?: number | undefined;\n  journalMode?: 'WAL' | 'DELETE' | undefined;\n  synchronous?: 'NORMAL' | 'FULL' | undefined;\n  readUncommitted?: boolean | undefined;\n};\n\nexport class SQLiteDatabaseManager {\n  readonly #dbm: GenericSQLiteDatabaseManager;\n  readonly #dbInstances = new Map<\n    string,\n    {\n      instances: {\n        db: SQLiteDatabase;\n        preparedStatements: SQLitePreparedStatements;\n      }[];\n    }\n  >();\n\n  constructor(dbm: GenericSQLiteDatabaseManager) {\n    this.#dbm = dbm;\n  }\n\n  clearAllStoresForTesting(): void {\n    for (const [name] of this.#dbInstances) {\n      this.destroy(name);\n    }\n  }\n\n  open(\n    name: string,\n    opts: Omit<SQLiteDatabaseManagerOptions, 'poolSize'>,\n  ): {db: SQLiteDatabase; preparedStatements: SQLitePreparedStatements} {\n    const dbInstance = this.#dbInstances.get(name);\n\n    const fileName = safeFilename(name);\n    const newDb = this.#dbm.open(fileName);\n\n    const txPreparedStatements = getTransactionPreparedStatements(newDb);\n\n    const exec = (sql: string) => {\n      const statement = newDb.prepare(sql);\n      statement.run();\n      statement.finalize();\n    };\n\n    if (!dbInstance) {\n      // we only ensure the schema for the first open\n      // the schema is the same for all connections\n      this.#ensureSchema(exec, txPreparedStatements);\n    }\n\n    if (opts.busyTimeout !== undefined) {\n      // we set a busy timeout to wait for write locks to be released\n      exec(`PRAGMA busy_timeout = ${opts.busyTimeout}`);\n    }\n    if (opts.journalMode !== undefined) {\n      // WAL allows concurrent readers (improves write throughput ~15x and read throughput ~1.5x)\n      // but does not work on all platforms (e.g. Expo)\n      exec(`PRAGMA journal_mode = ${opts.journalMode}`);\n    }\n    if (opts.synchronous !== undefined) {\n      exec(`PRAGMA synchronous = ${opts.synchronous}`);\n    }\n    if (opts.readUncommitted !== undefined) {\n      exec(\n        `PRAGMA read_uncommitted = ${opts.readUncommitted ? 'true' : 'false'}`,\n      );\n    }\n\n    // we prepare these after the schema is created\n    const rwPreparedStatements = getRWPreparedStatements(newDb);\n\n    const preparedStatements = {\n      ...txPreparedStatements,\n      ...rwPreparedStatements,\n    };\n\n    this.#dbInstances.set(name, {\n      instances: [\n        ...(dbInstance?.instances ?? []),\n        {db: newDb, preparedStatements},\n      ],\n    });\n\n    return {\n      db: newDb,\n      preparedStatements,\n    };\n  }\n\n  close(name: string) {\n    const dbInstance = this.#dbInstances.get(name);\n    if (!dbInstance) return;\n\n    for (const instance of dbInstance.instances) {\n      for (const stmt of Object.values(instance.preparedStatements)) {\n        stmt.finalize();\n      }\n      instance.db.close();\n    }\n  }\n\n  destroy(name: string): void {\n    const dbInstance = this.#dbInstances.get(name);\n    if (!dbInstance) return;\n\n    // we close all databases first before destroying\n    for (const instance of dbInstance.instances) {\n      for (const stmt of Object.values(instance.preparedStatements)) {\n        stmt.finalize();\n      }\n      instance.db.close();\n    }\n    for (const instance of dbInstance.instances) {\n      instance.db.destroy();\n    }\n    this.#dbInstances.delete(name);\n  }\n\n  #ensureSchema(\n    exec: (sql: string) => void,\n    preparedStatements: SQLiteTransactionPreparedStatements,\n  ): void {\n    preparedStatements.begin.run();\n\n    try {\n      // WITHOUT ROWID increases write throughput\n      exec(\n        'CREATE TABLE IF NOT EXISTS entry (key TEXT PRIMARY KEY, value TEXT NOT NULL) WITHOUT ROWID',\n      );\n      preparedStatements.commit.run();\n    } catch (e) {\n      preparedStatements.rollback.run();\n      throw e;\n    }\n  }\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/out/{inspector-AF3UI76B.js → inspector-J5P4DOGH.js}

@@ -2,20 +2,26 @@ import {
   ENTITIES_KEY_PREFIX,
   Latest,
   SUBQ_PREFIX,
-  assert,
+  TDigest,
   getClient,
   getClientGroup,
   getClients,
+  inspectMetricsDownSchema,
   inspectQueriesDownSchema,
+  inspectVersionDownSchema,
+  mapValues,
   must,
   nanoid,
   normalizeTTL,
   readFromHash,
   test,
-  unreachable,
   valita_exports,
   withRead
-} from "./chunk-LENWM5WE.js";
+} from "./chunk-O536GEIT.js";
+import {
+  assert,
+  unreachable
+} from "./chunk-SGW2EIVJ.js";
 import "./chunk-424PT5DM.js";
 
 // ../ast-to-zql/src/ast-to-zql.ts
@@ -189,9 +195,16 @@ function transformParameter(param) {
 }
 
 // ../zero-client/src/client/inspector/inspector.ts
-async function newInspector(rep, schema, socket) {
+async function newInspector(rep, clientMetricsDelegate, schema, socket) {
   const clientGroupID = await rep.clientGroupID;
-  return new Inspector(rep, schema, rep.clientID, clientGroupID, socket);
+  return new Inspector(
+    rep,
+    clientMetricsDelegate,
+    schema,
+    rep.clientID,
+    clientGroupID,
+    socket
+  );
 }
 var Inspector = class {
   #rep;
@@ -199,25 +212,58 @@ var Inspector = class {
   clientGroup;
   #schema;
   socket;
-  constructor(rep, schema, clientID, clientGroupID, socket) {
+  #metricsDelegate;
+  constructor(rep, clientMetricsDelegate, schema, clientID, clientGroupID, socket) {
     this.#rep = rep;
     this.#schema = schema;
-    this.client = new Client(rep, schema, socket, clientID, clientGroupID);
+    this.client = new Client(
+      rep,
+      clientMetricsDelegate,
+      schema,
+      socket,
+      clientID,
+      clientGroupID
+    );
     this.clientGroup = this.client.clientGroup;
     this.socket = socket;
+    this.#metricsDelegate = clientMetricsDelegate;
+  }
+  async metrics() {
+    const clientMetrics = this.#metricsDelegate.metrics;
+    const serverMetricsJSON = await rpc(
+      await this.socket(),
+      { op: "metrics" },
+      inspectMetricsDownSchema
+    );
+    return mergeMetrics(clientMetrics, serverMetricsJSON);
   }
   clients() {
     return withDagRead(
       this.#rep,
-      (dagRead) => clients(this.#rep, this.socket, this.#schema, dagRead)
+      (dagRead) => clients(
+        this.#rep,
+        this.#metricsDelegate,
+        this.socket,
+        this.#schema,
+        dagRead
+      )
     );
   }
   clientsWithQueries() {
     return withDagRead(
       this.#rep,
-      (dagRead) => clientsWithQueries(this.#rep, this.socket, this.#schema, dagRead)
+      (dagRead) => clientsWithQueries(
+        this.#rep,
+        this.#metricsDelegate,
+        this.socket,
+        this.#schema,
+        dagRead
+      )
     );
   }
+  async serverVersion() {
+    return rpc(await this.socket(), { op: "version" }, inspectVersionDownSchema);
+  }
 };
 function rpc(socket, arg, downSchema) {
   return new Promise((resolve, reject) => {
@@ -248,14 +294,20 @@ var Client = class {
   #rep;
   id;
   clientGroup;
-  #schema;
   #socket;
-  constructor(rep, schema, socket, id, clientGroupID) {
+  #clientMetricsDelegate;
+  constructor(rep, clientMetricsDelegate, schema, socket, id, clientGroupID) {
     this.#rep = rep;
-    this.#schema = schema;
     this.#socket = socket;
     this.id = id;
-    this.clientGroup = new ClientGroup(rep, socket, schema, clientGroupID);
+    this.clientGroup = new ClientGroup(
+      rep,
+      clientMetricsDelegate,
+      socket,
+      schema,
+      clientGroupID
+    );
+    this.#clientMetricsDelegate = clientMetricsDelegate;
   }
   async queries() {
     const rows = await rpc(
@@ -263,7 +315,7 @@ var Client = class {
       { op: "queries", clientID: this.id },
       inspectQueriesDownSchema
     );
-    return rows.map((row) => new Query(row, this.#schema));
+    return rows.map((row) => new Query(row, this.#clientMetricsDelegate));
   }
   map() {
     return withDagRead(this.#rep, async (dagRead) => {
@@ -295,8 +347,10 @@ var ClientGroup = class {
   id;
   #schema;
   #socket;
-  constructor(rep, socket, schema, id) {
+  #metricsDelegate;
+  constructor(rep, metricsDelegate, socket, schema, id) {
     this.#rep = rep;
+    this.#metricsDelegate = metricsDelegate;
     this.#socket = socket;
     this.#schema = schema;
     this.id = id;
@@ -306,6 +360,7 @@ var ClientGroup = class {
       this.#rep,
       (dagRead) => clients(
         this.#rep,
+        this.#metricsDelegate,
         this.#socket,
         this.#schema,
         dagRead,
@@ -318,6 +373,7 @@ var ClientGroup = class {
       this.#rep,
       (dagRead) => clientsWithQueries(
         this.#rep,
+        this.#metricsDelegate,
         this.#socket,
         this.#schema,
         dagRead,
@@ -331,7 +387,7 @@ var ClientGroup = class {
       { op: "queries" },
       inspectQueriesDownSchema
     );
-    return rows.map((row) => new Query(row, this.#schema));
+    return rows.map((row) => new Query(row, this.#metricsDelegate));
   }
 };
 async function withDagRead(rep, f) {
@@ -352,14 +408,28 @@ async function getBTree(dagRead, clientID) {
   );
   return dbRead.map;
 }
-async function clients(rep, socket, schema, dagRead, predicate = () => true) {
+async function clients(rep, metricsDelegate, socket, schema, dagRead, predicate = () => true) {
   const clients2 = await getClients(dagRead);
   return [...clients2.entries()].filter(predicate).map(
-    ([clientID, { clientGroupID }]) => new Client(rep, schema, socket, clientID, clientGroupID)
+    ([clientID, { clientGroupID }]) => new Client(
+      rep,
+      metricsDelegate,
+      schema,
+      socket,
+      clientID,
+      clientGroupID
+    )
   );
 }
-async function clientsWithQueries(rep, socket, schema, dagRead, predicate = () => true) {
-  const allClients = await clients(rep, socket, schema, dagRead, predicate);
+async function clientsWithQueries(rep, metricsDelegate, socket, schema, dagRead, predicate = () => true) {
+  const allClients = await clients(
+    rep,
+    metricsDelegate,
+    socket,
+    schema,
+    dagRead,
+    predicate
+  );
   const clientsWithQueries2 = [];
   await Promise.all(
     allClients.map(async (client) => {
@@ -383,21 +453,47 @@ var Query = class {
   id;
   zql;
   clientID;
-  constructor(row, _schema) {
+  metrics;
+  constructor(row, metricsDelegate) {
+    const { ast, queryID, inactivatedAt } = row;
     this.clientID = row.clientID;
-    this.id = row.queryID;
-    this.inactivatedAt = row.inactivatedAt === null ? null : new Date(row.inactivatedAt);
+    this.id = queryID;
+    this.inactivatedAt = inactivatedAt === null ? null : new Date(inactivatedAt);
     this.ttl = normalizeTTL(row.ttl);
-    this.ast = row.ast;
+    this.ast = ast;
     this.name = row.name;
     this.args = row.args;
     this.got = row.got;
     this.rowCount = row.rowCount;
     this.deleted = row.deleted;
-    this.zql = this.ast ? this.ast.table + astToZQL(this.ast) : null;
+    this.zql = ast ? ast.table + astToZQL(ast) : null;
+    const clientMetrics = metricsDelegate.getQueryMetrics(queryID);
+    const serverMetrics = row.metrics;
+    this.metrics = mergeMetrics(clientMetrics, serverMetrics);
   }
 };
+function mergeMetrics(clientMetrics, serverMetrics) {
+  return {
+    ...clientMetrics ?? newClientMetrics(),
+    ...serverMetrics ? convertServerMetrics(serverMetrics) : newServerMetrics()
+  };
+}
+function newClientMetrics() {
+  return {
+    "query-materialization-client": new TDigest(),
+    "query-materialization-end-to-end": new TDigest(),
+    "query-update-client": new TDigest()
+  };
+}
+function newServerMetrics() {
+  return {
+    "query-materialization-server": new TDigest()
+  };
+}
+function convertServerMetrics(metrics) {
+  return mapValues(metrics, (v) => TDigest.fromJSON(v));
+}
 export {
   newInspector
 };
-//# sourceMappingURL=inspector-AF3UI76B.js.map
+//# sourceMappingURL=inspector-J5P4DOGH.js.map