react-native-onyx 3.0.120 → 3.0.122

package/API.md

@@ -15,9 +15,6 @@ This method will be deprecated soon. Please use <code>Onyx.connectWithoutView()<
 <dt><a href="#connectWithoutView">connectWithoutView(connectOptions)</a> ⇒</dt>
 <dd><p>Connects to an Onyx key given the options passed and listens to its changes.</p>
 </dd>
-<dt><a href="#disconnect">disconnect(connection)</a></dt>
-<dd><p>Disconnects and removes the listener from the Onyx key.</p>
-</dd>
 <dt><a href="#set">set(key, value, options)</a></dt>
 <dd><p>Write a value to our store with the given key</p>
 </dd>
@@ -91,7 +88,7 @@ Connects to an Onyx key given the options passed and listens to its changes.
 This method will be deprecated soon. Please use `Onyx.connectWithoutView()` instead.
 
 **Kind**: global function  
-**Returns**: The `Connection` handle to use when calling `Onyx.disconnect()`.  
+**Returns**: The `Connection` handle whose `unsubscribe()` stops this subscription.  
 
 | Param | Description |
 | --- | --- |
@@ -118,7 +115,7 @@ cache after any same-tick writes have applied.
 Connects to an Onyx key given the options passed and listens to its changes.
 
 **Kind**: global function  
-**Returns**: The `Connection` handle to use when calling `Onyx.disconnect()`.  
+**Returns**: The `Connection` handle whose `unsubscribe()` stops this subscription.  
 
 | Param | Description |
 | --- | --- |
@@ -139,26 +136,6 @@ object whenever any member changes; signature `(collection, collectionKey)`.
 For any other key, the callback fires with the value at that key; signature
 `(value, key)`. Initial fire is deferred via `scheduleInitialSubscriberNotification` so it reads
 cache after any same-tick writes have applied.
-<a name="disconnect"></a>
-
-## disconnect(connection)
-Disconnects and removes the listener from the Onyx key.
-
-**Kind**: global function  
-
-| Param | Description |
-| --- | --- |
-| connection | Connection object returned by calling `Onyx.connect()` or `Onyx.connectWithoutView()`. |
-
-**Example**  
-```ts
-const connection = Onyx.connectWithoutView({
-    key: ONYXKEYS.SESSION,
-    callback: onSessionChange,
-});
-
-Onyx.disconnect(connection);
-```
 <a name="set"></a>
 
 ## set(key, value, options)

package/README.md

@@ -130,10 +130,10 @@ const connection = Onyx.connectWithoutView({
 });
 ```
 
-To teardown the subscription call `Onyx.disconnect()` with the connection returned from `Onyx.connectWithoutView()`. It's recommended to clean up subscriptions anytime you are connecting from within a function to prevent memory leaks.
+To teardown the subscription call `unsubscribe()` on the connection returned from `Onyx.connectWithoutView()`. It's recommended to clean up subscriptions anytime you are connecting from within a function to prevent memory leaks.
 
 ```javascript
-Onyx.disconnect(connection);
+connection.unsubscribe();
 ```
 
 We can also access values inside React function components via the `useOnyx()` [hook](https://react.dev/reference/react/hooks). When the data changes the component will re-render.

package/dist/Onyx.d.ts

@@ -23,7 +23,7 @@ declare function init({ keys, initialKeyStates, evictableKeys, shouldSyncMultipl
  * @param connectOptions The options object that will define the behavior of the connection.
  * @param connectOptions.key The Onyx key to subscribe to.
  * @param connectOptions.callback A function that will be called when the Onyx data we are subscribed changes.
- * @returns The `Connection` handle to use when calling `Onyx.disconnect()`.
+ * @returns The `Connection` handle whose `unsubscribe()` stops this subscription.
  */
 declare function connect<TKey extends OnyxKey>(connectOptions: ConnectOptions<TKey>): Connection;
 /**
@@ -46,25 +46,9 @@ declare function connect<TKey extends OnyxKey>(connectOptions: ConnectOptions<TK
  * @param connectOptions The options object that will define the behavior of the connection.
  * @param connectOptions.key The Onyx key to subscribe to.
  * @param connectOptions.callback A function that will be called when the Onyx data we are subscribed changes.
- * @returns The `Connection` handle to use when calling `Onyx.disconnect()`.
+ * @returns The `Connection` handle whose `unsubscribe()` stops this subscription.
  */
 declare function connectWithoutView<TKey extends OnyxKey>(connectOptions: ConnectOptions<TKey>): Connection;
-/**
- * Disconnects and removes the listener from the Onyx key.
- *
- * @example
- * ```ts
- * const connection = Onyx.connectWithoutView({
- *     key: ONYXKEYS.SESSION,
- *     callback: onSessionChange,
- * });
- *
- * Onyx.disconnect(connection);
- * ```
- *
- * @param connection Connection object returned by calling `Onyx.connect()` or `Onyx.connectWithoutView()`.
- */
-declare function disconnect(connection: Connection): void;
 /**
  * Write a value to our store with the given key
  *
@@ -208,7 +192,6 @@ declare const Onyx: {
     };
     connect: typeof connect;
     connectWithoutView: typeof connectWithoutView;
-    disconnect: typeof disconnect;
     set: typeof set;
     multiSet: typeof multiSet;
     merge: typeof merge;

package/dist/Onyx.js

@@ -131,7 +131,7 @@ function init({ keys = {}, initialKeyStates = {}, evictableKeys = [], shouldSync
  * @param connectOptions The options object that will define the behavior of the connection.
  * @param connectOptions.key The Onyx key to subscribe to.
  * @param connectOptions.callback A function that will be called when the Onyx data we are subscribed changes.
- * @returns The `Connection` handle to use when calling `Onyx.disconnect()`.
+ * @returns The `Connection` handle whose `unsubscribe()` stops this subscription.
  */
 function connect(connectOptions) {
     const { key, callback } = connectOptions;
@@ -220,32 +220,11 @@ function connect(connectOptions) {
  * @param connectOptions The options object that will define the behavior of the connection.
  * @param connectOptions.key The Onyx key to subscribe to.
  * @param connectOptions.callback A function that will be called when the Onyx data we are subscribed changes.
- * @returns The `Connection` handle to use when calling `Onyx.disconnect()`.
+ * @returns The `Connection` handle whose `unsubscribe()` stops this subscription.
  */
 function connectWithoutView(connectOptions) {
     return connect(connectOptions);
 }
-/**
- * Disconnects and removes the listener from the Onyx key.
- *
- * @example
- * ```ts
- * const connection = Onyx.connectWithoutView({
- *     key: ONYXKEYS.SESSION,
- *     callback: onSessionChange,
- * });
- *
- * Onyx.disconnect(connection);
- * ```
- *
- * @param connection Connection object returned by calling `Onyx.connect()` or `Onyx.connectWithoutView()`.
- */
-function disconnect(connection) {
-    if (!connection) {
-        return;
-    }
-    connection.unsubscribe();
-}
 /**
  * Write a value to our store with the given key
  *
@@ -706,7 +685,6 @@ const Onyx = {
     METHOD: OnyxUtils_1.default.METHOD,
     connect,
     connectWithoutView,
-    disconnect,
     set,
     multiSet,
     merge,

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/dist/types.d.ts

@@ -353,7 +353,7 @@ type MixedOperationsQueue = {
 };
 /**
  * Represents a connection to an Onyx key, returned by `Onyx.connect()`/`Onyx.connectWithoutView()`.
- * Pass it to `Onyx.disconnect()` to stop receiving callbacks for this subscription.
+ * Call its `unsubscribe()` to stop receiving callbacks for this subscription.
  */
 type Connection = {
     /** Unsubscribe this connection. Idempotent. */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-onyx",
-  "version": "3.0.120",
+  "version": "3.0.122",
   "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": {