react-native-onyx 3.0.120 → 3.0.121

package/dist/storage/providers/SQLiteProvider.js

@@ -1,10 +1,44 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const react_native_nitro_sqlite_1 = require("react-native-nitro-sqlite");
 const react_native_device_info_1 = require("react-native-device-info");
+const Logger = __importStar(require("../../Logger"));
 const utils_1 = __importDefault(require("../../utils"));
 const classifySQLiteError_1 = __importDefault(require("./classifySQLiteError"));
 const DB_NAME = 'OnyxDB';
@@ -14,6 +48,28 @@ const COMPILE_OPTIONS = {
 };
 /** SQLite's maximum number of bound parameters per statement, read once from PRAGMA compile_options in init(). */
 let sqliteMaxVariableNumber = SQLITE_MAX_VARIABLE_NUMBER;
+let readStore;
+let getItemStatement;
+let setItemStatement;
+let removeItemStatement;
+let pendingWrite = Promise.resolve();
+let pendingWriteCount = 0;
+function trackWrite(operation) {
+    // All writes use the same NitroSQLite connection queue and finish in call order.
+    // A failed write still releases later reads; its caller receives the rejection.
+    pendingWriteCount++;
+    pendingWrite = operation.then(() => {
+        pendingWriteCount--;
+    }, () => {
+        pendingWriteCount--;
+    });
+    return operation;
+}
+function readAfterPendingWrites(read) {
+    // Capture the writes already queued when the read was requested. New writes can run
+    // alongside this read on the separate connection once those writes have committed.
+    return pendingWriteCount === 0 ? read() : pendingWrite.then(read);
+}
 /**
  * Returns the value of a compile option from the rows returned by `PRAGMA compile_options`.
  * For flag-only options (e.g. `ENABLE_FTS3`), returns an empty string when the option is present.
@@ -61,13 +117,16 @@ const provider = {
      */
     name: 'SQLiteProvider',
     /**
-     * Classifies a SQLite write failure into the shared storage taxonomy.
+     * Classifies a SQLite failure into the shared storage taxonomy.
      */
     classifyError: classifySQLiteError_1.default,
     /**
      * Initializes the storage provider
      */
     init() {
+        if (provider.store) {
+            return;
+        }
         provider.store = (0, react_native_nitro_sqlite_1.open)({ name: DB_NAME });
         provider.store.execute('CREATE TABLE IF NOT EXISTS keyvaluepairs (record_key TEXT NOT NULL PRIMARY KEY , valueJSON JSON NOT NULL) WITHOUT ROWID;');
         // All of the 3 pragmas below were suggested by SQLite team.
@@ -80,12 +139,45 @@ const provider = {
         // stores it in a global variable, that is going to be used during runtime.
         const maxVariableNumber = Number(getCompileOptionValue(compileOptionsResult, COMPILE_OPTIONS.MAX_VARIABLE_NUMBER));
         sqliteMaxVariableNumber = maxVariableNumber > 0 ? maxVariableNumber : SQLITE_MAX_VARIABLE_NUMBER;
+        setItemStatement = provider.store.prepare('REPLACE INTO keyvaluepairs (record_key, valueJSON) VALUES (?, ?);');
+        removeItemStatement = provider.store.prepare('DELETE FROM keyvaluepairs WHERE record_key = ?;');
+        let independentReader;
+        try {
+            // WAL lets the read-only handle read committed data while the writer is active.
+            independentReader = (0, react_native_nitro_sqlite_1.open)({ name: DB_NAME, connection: 'independent', readOnly: true });
+            // Cache size is connection-local. WAL is shared, and synchronous only controls writes.
+            independentReader.execute('PRAGMA CACHE_SIZE=-8000;');
+            // Reads are not retried by Onyx; allow temporary WAL locks to clear.
+            independentReader.execute('PRAGMA busy_timeout=2000;');
+            getItemStatement = independentReader.prepare('SELECT record_key, valueJSON FROM keyvaluepairs WHERE record_key = ?;');
+            readStore = independentReader;
+        }
+        catch (error) {
+            // SQLite can report failures on first use, so protect all reader setup.
+            Logger.logInfo('SQLite independent reader unavailable, reading through the writer.', {
+                error: error instanceof Error ? error.message : String(error),
+            });
+            try {
+                independentReader === null || independentReader === void 0 ? void 0 : independentReader.close();
+            }
+            catch (cleanupError) {
+                // Reader cleanup must not prevent the writer from serving reads.
+                Logger.logInfo('SQLite independent reader cleanup failed.', {
+                    error: cleanupError instanceof Error ? cleanupError.message : String(cleanupError),
+                });
+            }
+            readStore = provider.store;
+            getItemStatement = provider.store.prepare('SELECT record_key, valueJSON FROM keyvaluepairs WHERE record_key = ?;');
+        }
+        pendingWrite = Promise.resolve();
+        pendingWriteCount = 0;
     },
     getItem(key) {
-        if (!provider.store) {
+        const statement = getItemStatement;
+        if (!statement) {
             throw new Error('Store is not initialized!');
         }
-        return provider.store.executeAsync('SELECT record_key, valueJSON FROM keyvaluepairs WHERE record_key = ?;', [key]).then(({ rows }) => {
+        return readAfterPendingWrites(() => statement.executeAsync([key])).then(({ rows }) => {
             if (!rows || (rows === null || rows === void 0 ? void 0 : rows.length) === 0) {
                 return null;
             }
@@ -97,21 +189,27 @@ const provider = {
         });
     },
     multiGet(keys) {
-        if (!provider.store) {
+        if (!readStore) {
             throw new Error('Store is not initialized!');
         }
         if (keys.length === 0) {
             return Promise.resolve([]);
         }
         const keyChunks = utils_1.default.chunkArray(keys, sqliteMaxVariableNumber);
-        return Promise.all(keyChunks.map((keyChunk) => {
-            if (!provider.store) {
-                throw new Error('Store is not initialized!');
+        const reader = readStore;
+        const commands = keyChunks.map((keyChunk) => ({
+            query: `SELECT record_key, valueJSON FROM keyvaluepairs WHERE record_key IN (${keyChunk.map(() => '?').join(',')});`,
+            params: keyChunk,
+        }));
+        const readChunks = () => {
+            if (commands.length === 1) {
+                const { query, params } = commands[0];
+                return reader.executeAsync(query, params).then((result) => [result]);
             }
-            const placeholders = keyChunk.map(() => '?').join(',');
-            const command = `SELECT record_key, valueJSON FROM keyvaluepairs WHERE record_key IN (${placeholders});`;
-            return provider.store.executeAsync(command, keyChunk);
-        })).then((results) => {
+            // Keep all chunks on one snapshot even if the writer commits between queries.
+            return reader.transaction((tx) => Promise.all(commands.map(({ query, params }) => tx.executeAsync(query, params))));
+        };
+        return readAfterPendingWrites(readChunks).then((results) => {
             const result = results.flatMap(({ rows }) => { var _a; 
             // eslint-disable-next-line no-underscore-dangle
             return (_a = rows === null || rows === void 0 ? void 0 : rows._array.map((row) => [row.record_key, JSON.parse(row.valueJSON)])) !== null && _a !== void 0 ? _a : []; });
@@ -119,10 +217,10 @@ const provider = {
         });
     },
     setItem(key, value) {
-        if (!provider.store) {
+        if (!setItemStatement) {
             throw new Error('Store is not initialized!');
         }
-        return provider.store.executeAsync('REPLACE INTO keyvaluepairs (record_key, valueJSON) VALUES (?, ?);', [key, JSON.stringify(value)]).then(() => undefined);
+        return trackWrite(setItemStatement.executeAsync([key, JSON.stringify(value)]).then(() => undefined));
     },
     multiSet(pairs) {
         if (!provider.store) {
@@ -133,7 +231,7 @@ const provider = {
         if (utils_1.default.isEmptyObject(params)) {
             return Promise.resolve();
         }
-        return provider.store.executeBatchAsync([{ query, params }]).then(() => undefined);
+        return trackWrite(provider.store.executeBatchAsync([{ query, params }]).then(() => undefined));
     },
     multiMerge(pairs) {
         if (!provider.store) {
@@ -173,31 +271,31 @@ const provider = {
         if (replaceQueryArguments.length > 0) {
             commands.push({ query: replaceQuery, params: replaceQueryArguments });
         }
-        return provider.store.executeBatchAsync(commands).then(() => undefined);
+        return trackWrite(provider.store.executeBatchAsync(commands).then(() => undefined));
     },
     mergeItem(key, change, replaceNullPatches) {
         // Since Onyx already merged the existing value with the changes, we can just set the value directly.
         return provider.multiMerge([[key, change, replaceNullPatches]]);
     },
     getAllKeys() {
-        if (!provider.store) {
+        if (!readStore) {
             throw new Error('Store is not initialized!');
         }
-        return provider.store.executeAsync('SELECT record_key FROM keyvaluepairs;').then(({ rows }) => {
+        const reader = readStore;
+        return readAfterPendingWrites(() => reader.executeAsync('SELECT record_key FROM keyvaluepairs;')).then(({ rows }) => {
             // eslint-disable-next-line no-underscore-dangle
             const result = rows === null || rows === void 0 ? void 0 : rows._array.map((row) => row.record_key);
             return (result !== null && result !== void 0 ? result : []);
         });
     },
     getAll() {
-        if (!provider.store) {
+        if (!readStore) {
             throw new Error('Store is not initialized!');
         }
         // Aggregate the whole table into a single JSON string in SQLite so we only run JSON.parse
         // once, instead of returning every row and parsing each one individually in JavaScript.
-        return provider.store
-            .executeAsync('SELECT json_group_array(json_array(record_key, json(valueJSON))) AS aggregated FROM keyvaluepairs;')
-            .then(({ rows }) => {
+        const reader = readStore;
+        return readAfterPendingWrites(() => reader.executeAsync('SELECT json_group_array(json_array(record_key, json(valueJSON))) AS aggregated FROM keyvaluepairs;')).then(({ rows }) => {
             var _a;
             const aggregated = (_a = rows === null || rows === void 0 ? void 0 : rows.item(0)) === null || _a === void 0 ? void 0 : _a.aggregated;
             if (aggregated == null) {
@@ -207,10 +305,10 @@ const provider = {
         });
     },
     removeItem(key) {
-        if (!provider.store) {
+        if (!removeItemStatement) {
             throw new Error('Store is not initialized!');
         }
-        return provider.store.executeAsync('DELETE FROM keyvaluepairs WHERE record_key = ?;', [key]).then(() => undefined);
+        return trackWrite(removeItemStatement.executeAsync([key]).then(() => undefined));
     },
     removeItems(keys) {
         if (!provider.store) {
@@ -226,19 +324,24 @@ const provider = {
         };
         if (keyChunks.length === 1) {
             const keyChunk = keyChunks[0];
-            return provider.store.executeAsync(buildDeleteQuery(keyChunk), keyChunk).then(() => undefined);
+            return trackWrite(provider.store.executeAsync(buildDeleteQuery(keyChunk), keyChunk).then(() => undefined));
         }
-        const commands = keyChunks.map((keyChunk) => ({
-            query: buildDeleteQuery(keyChunk),
-            params: keyChunk,
-        }));
-        return provider.store.executeBatchAsync(commands).then(() => undefined);
+        const firstChunk = keyChunks[0];
+        const lastChunk = keyChunks[keyChunks.length - 1];
+        const hasSmallerLastChunk = lastChunk.length < firstChunk.length;
+        // NitroSQLite reuses one prepared statement for each grouped parameter set.
+        // Only the final partial chunk needs a different number of placeholders.
+        const commands = [{ query: buildDeleteQuery(firstChunk), params: hasSmallerLastChunk ? keyChunks.slice(0, -1) : keyChunks }];
+        if (hasSmallerLastChunk) {
+            commands.push({ query: buildDeleteQuery(lastChunk), params: lastChunk });
+        }
+        return trackWrite(provider.store.executeBatchAsync(commands).then(() => undefined));
     },
     clear() {
         if (!provider.store) {
             throw new Error('Store is not initialized!');
         }
-        return provider.store.executeAsync('DELETE FROM keyvaluepairs;', []).then(() => undefined);
+        return trackWrite(provider.store.executeAsync('DELETE FROM keyvaluepairs;', []).then(() => undefined));
     },
     getDatabaseSize() {
         if (!provider.store) {

package/dist/storage/providers/classifySQLiteError.d.ts

@@ -1,10 +1,10 @@
 import type { ValueOf } from 'type-fest';
 import { StorageErrorClass } from '../errors';
 /**
- * Classifies a SQLite write failure into the shared storage taxonomy (lib/storage/errors.ts).
+ * Classifies a SQLite failure into the shared storage taxonomy (lib/storage/errors.ts).
  * This is the SQLite engine's own dialect — it is NOT shared with other engines. It lives in a
- * standalone module (no `react-native-nitro-sqlite` import) so it can be reused without pulling in
- * native dependencies.
+ * standalone module that uses NitroSQLite's native-free errors export without initializing the
+ * native module.
  *
  * SQLite surfaces fewer distinct write-failure shapes than IndexedDB. As telemetry from the UNKNOWN
  * bucket (see OnyxUtils.retryOperation) reveals recurring native errors, add matchers here.

package/dist/storage/providers/classifySQLiteError.js

@@ -1,24 +1,32 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const errors_1 = require("../errors");
+const errors_1 = require("react-native-nitro-sqlite/errors");
+const errors_2 = require("../errors");
 /**
- * Classifies a SQLite write failure into the shared storage taxonomy (lib/storage/errors.ts).
+ * Classifies a SQLite failure into the shared storage taxonomy (lib/storage/errors.ts).
  * This is the SQLite engine's own dialect — it is NOT shared with other engines. It lives in a
- * standalone module (no `react-native-nitro-sqlite` import) so it can be reused without pulling in
- * native dependencies.
+ * standalone module that uses NitroSQLite's native-free errors export without initializing the
+ * native module.
  *
  * SQLite surfaces fewer distinct write-failure shapes than IndexedDB. As telemetry from the UNKNOWN
  * bucket (see OnyxUtils.retryOperation) reveals recurring native errors, add matchers here.
  */
 function classifySQLiteError(error) {
-    const { message } = (0, errors_1.getErrorParts)(error);
+    // If the database cannot open, initialization must fall back to memory storage.
+    if (isDatabaseOpenError(error)) {
+        return errors_2.StorageErrorClass.UNAVAILABLE;
+    }
+    const { message } = (0, errors_2.getErrorParts)(error);
     // Device disk full.
     if (message.includes('database or disk is full')) {
-        return errors_1.StorageErrorClass.CAPACITY;
+        return errors_2.StorageErrorClass.CAPACITY;
     }
     if (message.includes('disk i/o error') || message.includes('unable to open database file')) {
-        return errors_1.StorageErrorClass.DISK_PRESSURE;
+        return errors_2.StorageErrorClass.DISK_PRESSURE;
     }
-    return errors_1.StorageErrorClass.UNKNOWN;
+    return errors_2.StorageErrorClass.UNKNOWN;
+}
+function isDatabaseOpenError(error) {
+    return typeof error === 'object' && error !== null && 'type' in error && error.type === errors_1.NitroSQLiteExceptionType.DatabaseCannotBeOpened;
 }
 exports.default = classifySQLiteError;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-onyx",
-  "version": "3.0.120",
+  "version": "3.0.121",
   "author": "Expensify, Inc.",
   "homepage": "https://expensify.com",
   "description": "State management for React Native",
@@ -75,7 +75,7 @@
     "@typescript-eslint/eslint-plugin": "^8.51.0",
     "@typescript-eslint/parser": "^8.51.0",
     "@vercel/ncc": "0.38.1",
-    "better-sqlite3": "^12.10.0",
+    "better-sqlite3": "^12.11.1",
     "date-fns": "^4.1.0",
     "eslint": "^9.39.2",
     "eslint-config-expensify": "2.0.108",
@@ -97,7 +97,7 @@
     "react-native": "0.76.3",
     "react-native-device-info": "^10.3.0",
     "react-native-nitro-modules": "^0.35.0",
-    "react-native-nitro-sqlite": "^9.6.0",
+    "react-native-nitro-sqlite": "10.2.0",
     "react-test-renderer": "18.2.0",
     "reassure": "1.4.0",
     "ts-node": "^10.9.2",
@@ -110,7 +110,7 @@
     "react-native": ">=0.75.0",
     "react-native-device-info": "^10.3.0",
     "react-native-nitro-modules": ">=0.35.0",
-    "react-native-nitro-sqlite": "^9.6.0"
+    "react-native-nitro-sqlite": "^10.2.0"
   },
   "peerDependenciesMeta": {
     "idb-keyval": {