@rocicorp/zero 0.24.2025090402 → 0.24.2025091200

package/out/react-native.js

@@ -1,341 +1,339 @@
 import {
-  promiseUndefined,
-  promiseVoid
-} from "./chunk-MKB4RXL3.js";
+  throwIfStoreClosed,
+  throwIfTransactionClosed
+} from "./chunk-ASRS2LFV.js";
 import {
   deepFreeze
 } from "./chunk-SGW2EIVJ.js";
 import "./chunk-424PT5DM.js";
 
-// ../replicache/src/expo/store.ts
+// ../replicache/src/kv/expo-sqlite/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 { preparedStatements } = manager.open(name, opts);
-      this.#pool.push({
-        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();
-      }
-    };
-  }
-};
-var SQLiteWriteConnectionManager = class {
-  #rwLock;
-  #preparedStatements;
-  constructor(name, manager, rwLock, opts) {
-    const { preparedStatements } = manager.open(name, opts);
-    this.#preparedStatements = preparedStatements;
-    this.#rwLock = rwLock;
-  }
-  async acquire() {
-    const release = await this.#rwLock.write();
-    return { preparedStatements: this.#preparedStatements, release };
-  }
-};
+import { RWLock } from "@rocicorp/lock";
 var SQLiteStore = class {
-  #name;
-  #dbm;
-  #writeConnectionManager;
-  #readConnectionManager;
-  #rwLock = new RWLock();
+  #filename;
+  #entry;
   #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
-    );
+  constructor(name, create, opts) {
+    this.#filename = safeFilename(name);
+    this.#entry = getOrCreateEntry(name, create, opts);
   }
   async read() {
-    const { preparedStatements, release } = await this.#readConnectionManager.acquire();
-    return new SQLiteStoreRead(preparedStatements, release);
+    throwIfStoreClosed(this);
+    const entry = this.#entry;
+    const { db, lock, preparedStatements } = entry;
+    const release = await lock.read();
+    if (entry.activeReaders === 0) {
+      db.execSync("BEGIN");
+    }
+    entry.activeReaders++;
+    return new SQLiteStoreRead(() => {
+      entry.activeReaders--;
+      if (entry.activeReaders === 0) {
+        db.execSync("COMMIT");
+      }
+      release();
+    }, preparedStatements);
   }
   async write() {
-    const { preparedStatements, release } = await this.#writeConnectionManager.acquire();
-    return new SQLiteStoreWrite(preparedStatements, release);
+    throwIfStoreClosed(this);
+    const { lock, db, preparedStatements } = this.#entry;
+    const release = await lock.write();
+    db.execSync("BEGIN IMMEDIATE");
+    return new SQLiteWrite(release, db, preparedStatements);
   }
-  close() {
-    this.#dbm.close(this.#name);
+  async close() {
+    if (this.#closed) {
+      return;
+    }
+    const { lock, db } = this.#entry;
+    const writeRelease = await lock.write();
+    decrementStoreRefCount(this.#filename, db);
     this.#closed = true;
-    return promiseVoid;
+    writeRelease();
   }
   get closed() {
     return this.#closed;
   }
 };
-var SQLiteStoreRWBase = class {
-  _preparedStatements;
+function safeFilename(name) {
+  return name.replace(/[^a-zA-Z0-9]/g, "_");
+}
+function setupDatabase(delegate, opts) {
+  delegate.execSync(`PRAGMA busy_timeout = ${opts?.busyTimeout ?? 200}`);
+  delegate.execSync(`PRAGMA journal_mode = '${opts?.journalMode ?? "WAL"}'`);
+  delegate.execSync(`PRAGMA synchronous = '${opts?.synchronous ?? "NORMAL"}'`);
+  delegate.execSync(
+    `PRAGMA read_uncommitted = ${Boolean(opts?.readUncommitted)}`
+  );
+  delegate.execSync(`
+    CREATE TABLE IF NOT EXISTS entry (
+      key TEXT PRIMARY KEY, 
+      value TEXT NOT NULL
+    ) WITHOUT ROWID
+  `);
+  return {
+    has: delegate.prepare(`SELECT 1 FROM entry WHERE key = ? LIMIT 1`),
+    get: delegate.prepare("SELECT value FROM entry WHERE key = ?"),
+    put: delegate.prepare(
+      "INSERT OR REPLACE INTO entry (key, value) VALUES (?, ?)"
+    ),
+    del: delegate.prepare("DELETE FROM entry WHERE key = ?")
+  };
+}
+var SQLiteStoreRead = class {
   #release;
   #closed = false;
-  constructor(preparedStatements, release) {
-    this._preparedStatements = preparedStatements;
+  #preparedStatements;
+  constructor(release, preparedStatements) {
     this.#release = release;
+    this.#preparedStatements = preparedStatements;
   }
-  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);
+  async has(key) {
+    throwIfTransactionClosed(this);
+    const value = await this.#preparedStatements.has.firstValue([key]);
+    return value !== void 0;
   }
-  #getSql(key) {
-    const rows = this._preparedStatements.get.all(key);
-    if (rows.length === 0) return void 0;
-    return rows[0].value;
+  async get(key) {
+    throwIfTransactionClosed(this);
+    const value = await this.#preparedStatements.get.firstValue([key]);
+    if (!value) {
+      return void 0;
+    }
+    const parsedValue = JSON.parse(value);
+    return deepFreeze(parsedValue);
   }
-  _release() {
-    this.#closed = true;
-    this.#release();
+  release() {
+    if (!this.#closed) {
+      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();
+var SQLiteWrite = class {
+  #release;
+  #dbDelegate;
+  #preparedStatements;
+  #committed = false;
+  #closed = false;
+  constructor(release, dbDelegate, preparedStatements) {
+    this.#release = release;
+    this.#dbDelegate = dbDelegate;
+    this.#preparedStatements = preparedStatements;
   }
-  release() {
-    this._preparedStatements.commit.run();
-    this._release();
+  async has(key) {
+    throwIfTransactionClosed(this);
+    const value = await this.#preparedStatements.has.firstValue([key]);
+    return value !== void 0;
   }
-};
-var SQLiteStoreWrite = class extends SQLiteStoreRWBase {
-  #committed = false;
-  constructor(preparedStatements, release) {
-    super(preparedStatements, release);
-    this._preparedStatements.beginImmediate.run();
+  async get(key) {
+    throwIfTransactionClosed(this);
+    const value = await this.#preparedStatements.get.firstValue([key]);
+    if (!value) {
+      return void 0;
+    }
+    const parsedValue = JSON.parse(value);
+    return deepFreeze(parsedValue);
   }
-  put(key, value) {
-    this._preparedStatements.put.run(key, JSON.stringify(value));
-    return promiseVoid;
+  async put(key, value) {
+    throwIfTransactionClosed(this);
+    await this.#preparedStatements.put.exec([key, JSON.stringify(value)]);
   }
-  del(key) {
-    this._preparedStatements.del.run(key);
-    return promiseVoid;
+  async del(key) {
+    throwIfTransactionClosed(this);
+    await this.#preparedStatements.del.exec([key]);
   }
-  commit() {
-    this._preparedStatements.commit.run();
+  // eslint-disable-next-line require-await
+  async commit() {
+    throwIfTransactionClosed(this);
+    this.#dbDelegate.execSync("COMMIT");
     this.#committed = true;
-    return promiseVoid;
   }
   release() {
-    if (!this.#committed) {
-      this._preparedStatements.rollback.run();
+    if (!this.#closed) {
+      this.#closed = true;
+      if (!this.#committed) {
+        this.#dbDelegate.execSync("ROLLBACK");
+      }
+      this.#release();
     }
-    this._release();
+  }
+  get closed() {
+    return this.#closed;
   }
 };
-function safeFilename(name) {
-  return name.replace(/[^a-zA-Z0-9]/g, "_");
+var stores = /* @__PURE__ */ new Map();
+function getOrCreateEntry(name, create, opts) {
+  const filename = safeFilename(name);
+  const entry = stores.get(filename);
+  if (entry) {
+    entry.refCount++;
+    return entry;
+  }
+  const dbDelegate = create(filename, opts);
+  const preparedStatements = setupDatabase(dbDelegate, opts);
+  const lock = new RWLock();
+  const newEntry = {
+    lock,
+    db: dbDelegate,
+    refCount: 1,
+    activeReaders: 0,
+    preparedStatements
+  };
+  stores.set(filename, newEntry);
+  return newEntry;
 }
-var OPEN = 1;
-var CLOSED = 0;
-var SQLiteDatabaseManager = class {
-  #dbm;
-  #dbInstances = /* @__PURE__ */ new Map();
-  constructor(dbm) {
-    this.#dbm = dbm;
-  }
-  clearAllStoresForTesting() {
-    for (const [name] of this.#dbInstances) {
-      this.destroy(name);
+function decrementStoreRefCount(filename, dbDelegate) {
+  const entry = stores.get(filename);
+  if (entry) {
+    entry.refCount--;
+    if (entry.refCount <= 0) {
+      dbDelegate.close();
+      stores.delete(filename);
     }
   }
-  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, state: OPEN }
-      ]
-    });
-    return {
-      db: newDb,
-      preparedStatements
-    };
-  }
-  #closeDBInstance(name) {
-    const dbInstance = this.#dbInstances.get(name);
-    if (dbInstance) {
-      for (const instance of dbInstance.instances) {
-        if (instance.state === CLOSED) {
-          continue;
-        }
-        for (const stmt of Object.values(instance.preparedStatements)) {
-          stmt.finalize();
-        }
-        instance.db.close();
-        instance.state = CLOSED;
-      }
-    }
-    return dbInstance;
+}
+function dropStore(name, createDelegate) {
+  const filename = safeFilename(name);
+  const entry = stores.get(filename);
+  if (entry) {
+    entry.db.close();
+    stores.delete(filename);
+  }
+  const tempDelegate = createDelegate(filename);
+  tempDelegate.destroy();
+  return Promise.resolve();
+}
+
+// ../replicache/src/kv/expo-sqlite/store.ts
+function dropExpoSQLiteStore(name) {
+  return dropStore(name, (filename) => new ExpoSQLiteDatabase(filename));
+}
+function expoSQLiteStoreProvider(opts) {
+  return {
+    create: (name) => new SQLiteStore(name, (name2) => new ExpoSQLiteDatabase(name2), opts),
+    drop: dropExpoSQLiteStore
+  };
+}
+var ExpoSQLitePreparedStatement = class {
+  #statement;
+  constructor(statement) {
+    this.#statement = statement;
   }
-  close(name) {
-    this.#closeDBInstance(name);
+  async firstValue(params) {
+    const result = await this.#statement.executeForRawResultAsync(params);
+    const row = await result.getFirstAsync();
+    return row === null ? void 0 : row[0];
   }
-  destroy(name) {
-    const dbInstance = this.#closeDBInstance(name);
-    dbInstance?.instances[0].db.destroy();
-    this.#dbInstances.delete(name);
+  async exec(params) {
+    await this.#statement.executeForRawResultAsync(params);
   }
-  #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;
+};
+var ExpoSQLiteDatabase = class {
+  #db;
+  #filename;
+  #statements = /* @__PURE__ */ new Set();
+  constructor(filename) {
+    this.#filename = filename;
+    this.#db = openDatabaseSync(filename);
+  }
+  close() {
+    for (const stmt of this.#statements) {
+      stmt.finalizeSync();
     }
+    this.#db.closeSync();
+  }
+  destroy() {
+    deleteDatabaseSync(this.#filename);
+  }
+  prepare(sql) {
+    const statement = this.#db.prepareSync(sql);
+    this.#statements.add(statement);
+    return new ExpoSQLitePreparedStatement(statement);
+  }
+  execSync(sql) {
+    this.#db.execSync(sql);
   }
 };
 
-// ../replicache/src/expo/store.ts
-function expoSQLiteStoreProvider(opts) {
+// ../replicache/src/kv/op-sqlite/types.ts
+import { open as openDB } from "@op-engineering/op-sqlite";
+var open = openDB;
+
+// ../replicache/src/kv/op-sqlite/store.ts
+function dropOpSQLiteStore(name) {
+  return dropStore(
+    name,
+    (filename, opts) => new OpSQLiteDatabase(filename, opts)
+  );
+}
+function opSQLiteStoreProvider(opts) {
   return {
-    create: (name) => {
-      const expoDbManagerInstance = new SQLiteDatabaseManager({
-        open: (fileName) => {
-          const db = openDatabaseSync(fileName);
-          let closed = false;
-          const close = () => {
-            if (!closed) {
-              db.closeSync();
-              closed = true;
-            }
-          };
-          return {
-            close,
-            destroy() {
-              close();
-              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 new SQLiteStore(name, expoDbManagerInstance, {
-        // we default to 3 read connections for mobile devices
-        readPoolSize: 3,
-        busyTimeout: 200,
-        synchronous: "NORMAL",
-        readUncommitted: false,
-        journalMode: "WAL",
-        ...opts
-      });
-    },
-    drop: (name) => {
-      deleteDatabaseSync(safeFilename(name));
-      return Promise.resolve();
-    }
+    create: (name) => new SQLiteStore(
+      name,
+      (name2, options) => new OpSQLiteDatabase(name2, options),
+      opts
+    ),
+    drop: dropOpSQLiteStore
   };
 }
+var OpSQLitePreparedStatement = class {
+  #db;
+  #sql;
+  constructor(db, sql) {
+    this.#db = db;
+    this.#sql = sql;
+  }
+  async firstValue(params) {
+    const rows = await this.#db.executeRaw(this.#sql, params);
+    return rows[0]?.[0];
+  }
+  async exec(params) {
+    await this.#db.executeRaw(this.#sql, params);
+  }
+};
+var OpSQLiteDatabase = class {
+  #db;
+  #filename;
+  constructor(filename, opts) {
+    this.#filename = filename;
+    const openOpts = { name: filename };
+    if (opts?.location) {
+      openOpts.location = opts.location;
+    }
+    if (opts?.encryptionKey) {
+      openOpts.encryptionKey = opts.encryptionKey;
+    }
+    this.#db = open(openOpts);
+  }
+  close() {
+    this.#db.close();
+  }
+  destroy() {
+    try {
+      const tempDb = open({ name: this.#filename });
+      tempDb.delete();
+      tempDb.close();
+    } catch (error) {
+    }
+  }
+  prepare(sql) {
+    return new OpSQLitePreparedStatement(this.#db, sql);
+  }
+  execSync(sql) {
+    this.#db.executeRawSync(sql, []);
+  }
+};
 export {
-  expoSQLiteStoreProvider
+  expoSQLiteStoreProvider,
+  opSQLiteStoreProvider
 };
 //# sourceMappingURL=react-native.js.map