react-native-onyx 2.0.117 → 2.0.118

package/dist/OnyxUtils.js

@@ -31,6 +31,7 @@ exports.clearOnyxUtilsInternals = void 0;
 const fast_equals_1 = require("fast-equals");
 const clone_1 = __importDefault(require("lodash/clone"));
 const pick_1 = __importDefault(require("lodash/pick"));
+const underscore_1 = __importDefault(require("underscore"));
 const DevTools_1 = __importDefault(require("./DevTools"));
 const Logger = __importStar(require("./Logger"));
 const OnyxCache_1 = __importStar(require("./OnyxCache"));
@@ -42,6 +43,7 @@ const utils_1 = __importDefault(require("./utils"));
 const createDeferredTask_1 = __importDefault(require("./createDeferredTask"));
 const GlobalSettings = __importStar(require("./GlobalSettings"));
 const metrics_1 = __importDefault(require("./metrics"));
+const logMessages_1 = __importDefault(require("./logMessages"));
 // Method constants
 const METHOD = {
     SET: 'set',
@@ -285,7 +287,7 @@ function multiGet(keys) {
         values.forEach(([key, value]) => {
             if (skippableCollectionMemberIDs.size) {
                 try {
-                    const [, collectionMemberID] = OnyxUtils.splitCollectionMemberKey(key);
+                    const [, collectionMemberID] = splitCollectionMemberKey(key);
                     if (skippableCollectionMemberIDs.has(collectionMemberID)) {
                         // The key is a skippable one, so we skip this iteration.
                         return;
@@ -309,7 +311,7 @@ function multiGet(keys) {
  * Note: just using `.map`, you'd end up with `Array<OnyxCollection<Report>|OnyxEntry<string>>`, which is not what we want. This preserves the order of the keys provided.
  */
 function tupleGet(keys) {
-    return Promise.all(keys.map((key) => OnyxUtils.get(key)));
+    return Promise.all(keys.map((key) => get(key)));
 }
 /**
  * Stores a subscription ID associated with a given key.
@@ -955,59 +957,75 @@ function broadcastUpdate(key, value, hasChanged) {
 function hasPendingMergeForKey(key) {
     return !!mergeQueue[key];
 }
-/**
- * Removes a key from storage if the value is null.
- * Otherwise removes all nested null values in objects,
- * if shouldRemoveNestedNulls is true and returns the object.
- *
- * @returns The value without null values and a boolean "wasRemoved", which indicates if the key got removed completely
- */
-function removeNullValues(key, value, shouldRemoveNestedNulls = true) {
-    if (value === null) {
-        remove(key);
-        return { value, wasRemoved: true };
-    }
-    if (value === undefined) {
-        return { value, wasRemoved: false };
-    }
-    // We can remove all null values in an object by merging it with itself
-    // utils.fastMerge recursively goes through the object and removes all null values
-    // Passing two identical objects as source and target to fastMerge will not change it, but only remove the null values
-    return { value: shouldRemoveNestedNulls ? utils_1.default.removeNestedNullValues(value) : value, wasRemoved: false };
-}
 /**
  * Storage expects array like: [["@MyApp_user", value_1], ["@MyApp_key", value_2]]
  * This method transforms an object like {'@MyApp_user': myUserValue, '@MyApp_key': myKeyValue}
  * to an array of key-value pairs in the above format and removes key-value pairs that are being set to null
-
-* @return an array of key - value pairs <[key, value]>
+ *
+ * @return an array of key - value pairs <[key, value]>
  */
-function prepareKeyValuePairsForStorage(data, shouldRemoveNestedNulls) {
-    return Object.entries(data).reduce((pairs, [key, value]) => {
-        const { value: valueAfterRemoving, wasRemoved } = removeNullValues(key, value, shouldRemoveNestedNulls);
-        if (!wasRemoved && valueAfterRemoving !== undefined) {
-            pairs.push([key, valueAfterRemoving]);
+function prepareKeyValuePairsForStorage(data, shouldRemoveNestedNulls, replaceNullPatches) {
+    const pairs = [];
+    Object.entries(data).forEach(([key, value]) => {
+        if (value === null) {
+            remove(key);
+            return;
+        }
+        const valueWithoutNestedNullValues = (shouldRemoveNestedNulls !== null && shouldRemoveNestedNulls !== void 0 ? shouldRemoveNestedNulls : true) ? utils_1.default.removeNestedNullValues(value) : value;
+        if (valueWithoutNestedNullValues !== undefined) {
+            pairs.push([key, valueWithoutNestedNullValues, replaceNullPatches === null || replaceNullPatches === void 0 ? void 0 : replaceNullPatches[key]]);
         }
-        return pairs;
-    }, []);
+    });
+    return pairs;
 }
 /**
- * Merges an array of changes with an existing value
+ * Merges an array of changes with an existing value or creates a single change.
  *
- * @param changes Array of changes that should be applied to the existing value
+ * @param changes Array of changes that should be merged
+ * @param existingValue The existing value that should be merged with the changes
  */
-function applyMerge(existingValue, changes, shouldRemoveNestedNulls) {
+function mergeChanges(changes, existingValue) {
+    return mergeInternal('merge', changes, existingValue);
+}
+/**
+ * Merges an array of changes with an existing value or creates a single change.
+ * It will also mark deep nested objects that need to be entirely replaced during the merge.
+ *
+ * @param changes Array of changes that should be merged
+ * @param existingValue The existing value that should be merged with the changes
+ */
+function mergeAndMarkChanges(changes, existingValue) {
+    return mergeInternal('mark', changes, existingValue);
+}
+/**
+ * Merges an array of changes with an existing value or creates a single change.
+ *
+ * @param changes Array of changes that should be merged
+ * @param existingValue The existing value that should be merged with the changes
+ */
+function mergeInternal(mode, changes, existingValue) {
     const lastChange = changes === null || changes === void 0 ? void 0 : changes.at(-1);
     if (Array.isArray(lastChange)) {
-        return lastChange;
+        return { result: lastChange, replaceNullPatches: [] };
     }
     if (changes.some((change) => change && typeof change === 'object')) {
         // Object values are then merged one after the other
-        return changes.reduce((modifiedData, change) => utils_1.default.fastMerge(modifiedData, change, shouldRemoveNestedNulls), (existingValue || {}));
+        return changes.reduce((modifiedData, change) => {
+            const options = mode === 'merge' ? { shouldRemoveNestedNulls: true, objectRemovalMode: 'replace' } : { objectRemovalMode: 'mark' };
+            const { result, replaceNullPatches } = utils_1.default.fastMerge(modifiedData.result, change, options);
+            // eslint-disable-next-line no-param-reassign
+            modifiedData.result = result;
+            // eslint-disable-next-line no-param-reassign
+            modifiedData.replaceNullPatches = [...modifiedData.replaceNullPatches, ...replaceNullPatches];
+            return modifiedData;
+        }, {
+            result: (existingValue !== null && existingValue !== void 0 ? existingValue : {}),
+            replaceNullPatches: [],
+        });
     }
     // If we have anything else we can't merge it so we'll
     // simply return the last value that was queued
-    return lastChange;
+    return { result: lastChange, replaceNullPatches: [] };
 }
 /**
  * Merge user provided default key value pairs.
@@ -1015,7 +1033,9 @@ function applyMerge(existingValue, changes, shouldRemoveNestedNulls) {
 function initializeWithDefaultKeyStates() {
     return storage_1.default.multiGet(Object.keys(defaultKeyStates)).then((pairs) => {
         const existingDataAsObject = Object.fromEntries(pairs);
-        const merged = utils_1.default.fastMerge(existingDataAsObject, defaultKeyStates);
+        const merged = utils_1.default.fastMerge(existingDataAsObject, defaultKeyStates, {
+            shouldRemoveNestedNulls: true,
+        }).result;
         OnyxCache_1.default.merge(merged !== null && merged !== void 0 ? merged : {});
         Object.entries(merged !== null && merged !== void 0 ? merged : {}).forEach(([key, value]) => keyChanged(key, value, existingDataAsObject));
     });
@@ -1157,11 +1177,11 @@ function unsubscribeFromKey(subscriptionID) {
     delete callbackToStateMapping[subscriptionID];
 }
 function updateSnapshots(data, mergeFn) {
-    const snapshotCollectionKey = OnyxUtils.getSnapshotKey();
+    const snapshotCollectionKey = getSnapshotKey();
     if (!snapshotCollectionKey)
         return [];
     const promises = [];
-    const snapshotCollection = OnyxUtils.getCachedCollection(snapshotCollectionKey);
+    const snapshotCollection = getCachedCollection(snapshotCollectionKey);
     Object.entries(snapshotCollection).forEach(([snapshotEntryKey, snapshotEntryValue]) => {
         // Snapshots may not be present in cache. We don't know how to update them so we skip.
         if (!snapshotEntryValue) {
@@ -1170,7 +1190,7 @@ function updateSnapshots(data, mergeFn) {
         let updatedData = {};
         data.forEach(({ key, value }) => {
             // snapshots are normal keys so we want to skip update if they are written to Onyx
-            if (OnyxUtils.isCollectionMemberKey(snapshotCollectionKey, key)) {
+            if (isCollectionMemberKey(snapshotCollectionKey, key)) {
                 return;
             }
             if (typeof snapshotEntryValue !== 'object' || !('data' in snapshotEntryValue)) {
@@ -1209,6 +1229,115 @@ function updateSnapshots(data, mergeFn) {
     });
     return promises;
 }
+/**
+ * Merges a collection based on their keys.
+ * Serves as core implementation for `Onyx.mergeCollection()` public function, the difference being
+ * that this internal function allows passing an additional `mergeReplaceNullPatches` parameter.
+ *
+ * @param collectionKey e.g. `ONYXKEYS.COLLECTION.REPORT`
+ * @param collection Object collection keyed by individual collection member keys and values
+ * @param mergeReplaceNullPatches Record where the key is a collection member key and the value is a list of
+ * tuples that we'll use to replace the nested objects of that collection member record with something else.
+ */
+function mergeCollectionWithPatches(collectionKey, collection, mergeReplaceNullPatches) {
+    if (!isValidNonEmptyCollectionForMerge(collection)) {
+        Logger.logInfo('mergeCollection() called with invalid or empty value. Skipping this update.');
+        return Promise.resolve();
+    }
+    let resultCollection = collection;
+    let resultCollectionKeys = Object.keys(resultCollection);
+    // Confirm all the collection keys belong to the same parent
+    if (!doAllCollectionItemsBelongToSameParent(collectionKey, resultCollectionKeys)) {
+        return Promise.resolve();
+    }
+    if (skippableCollectionMemberIDs.size) {
+        resultCollection = resultCollectionKeys.reduce((result, key) => {
+            try {
+                const [, collectionMemberID] = splitCollectionMemberKey(key, collectionKey);
+                // If the collection member key is a skippable one we set its value to null.
+                // eslint-disable-next-line no-param-reassign
+                result[key] = !skippableCollectionMemberIDs.has(collectionMemberID) ? resultCollection[key] : null;
+            }
+            catch (_a) {
+                // Something went wrong during split, so we assign the data to result anyway.
+                // eslint-disable-next-line no-param-reassign
+                result[key] = resultCollection[key];
+            }
+            return result;
+        }, {});
+    }
+    resultCollectionKeys = Object.keys(resultCollection);
+    return getAllKeys()
+        .then((persistedKeys) => {
+        // Split to keys that exist in storage and keys that don't
+        const keys = resultCollectionKeys.filter((key) => {
+            if (resultCollection[key] === null) {
+                remove(key);
+                return false;
+            }
+            return true;
+        });
+        const existingKeys = keys.filter((key) => persistedKeys.has(key));
+        const cachedCollectionForExistingKeys = getCachedCollection(collectionKey, existingKeys);
+        const existingKeyCollection = existingKeys.reduce((obj, key) => {
+            const { isCompatible, existingValueType, newValueType } = utils_1.default.checkCompatibilityWithExistingValue(resultCollection[key], cachedCollectionForExistingKeys[key]);
+            if (!isCompatible) {
+                Logger.logAlert(logMessages_1.default.incompatibleUpdateAlert(key, 'mergeCollection', existingValueType, newValueType));
+                return obj;
+            }
+            // eslint-disable-next-line no-param-reassign
+            obj[key] = resultCollection[key];
+            return obj;
+        }, {});
+        const newCollection = {};
+        keys.forEach((key) => {
+            if (persistedKeys.has(key)) {
+                return;
+            }
+            newCollection[key] = resultCollection[key];
+        });
+        // When (multi-)merging the values with the existing values in storage,
+        // we don't want to remove nested null values from the data that we pass to the storage layer,
+        // because the storage layer uses them to remove nested keys from storage natively.
+        const keyValuePairsForExistingCollection = prepareKeyValuePairsForStorage(existingKeyCollection, false, mergeReplaceNullPatches);
+        // We can safely remove nested null values when using (multi-)set,
+        // because we will simply overwrite the existing values in storage.
+        const keyValuePairsForNewCollection = prepareKeyValuePairsForStorage(newCollection, true);
+        const promises = [];
+        // We need to get the previously existing values so we can compare the new ones
+        // against them, to avoid unnecessary subscriber updates.
+        const previousCollectionPromise = Promise.all(existingKeys.map((key) => get(key).then((value) => [key, value]))).then(Object.fromEntries);
+        // New keys will be added via multiSet while existing keys will be updated using multiMerge
+        // This is because setting a key that doesn't exist yet with multiMerge will throw errors
+        if (keyValuePairsForExistingCollection.length > 0) {
+            promises.push(storage_1.default.multiMerge(keyValuePairsForExistingCollection));
+        }
+        if (keyValuePairsForNewCollection.length > 0) {
+            promises.push(storage_1.default.multiSet(keyValuePairsForNewCollection));
+        }
+        // finalMergedCollection contains all the keys that were merged, without the keys of incompatible updates
+        const finalMergedCollection = Object.assign(Object.assign({}, existingKeyCollection), newCollection);
+        // Prefill cache if necessary by calling get() on any existing keys and then merge original data to cache
+        // and update all subscribers
+        const promiseUpdate = previousCollectionPromise.then((previousCollection) => {
+            OnyxCache_1.default.merge(finalMergedCollection);
+            return scheduleNotifyCollectionSubscribers(collectionKey, finalMergedCollection, previousCollection);
+        });
+        return Promise.all(promises)
+            .catch((error) => evictStorageAndRetry(error, mergeCollectionWithPatches, collectionKey, resultCollection))
+            .then(() => {
+            sendActionToDevTools(METHOD.MERGE_COLLECTION, undefined, resultCollection);
+            return promiseUpdate;
+        });
+    })
+        .then(() => undefined);
+}
+function logKeyChanged(onyxMethod, key, value, hasChanged) {
+    Logger.logInfo(`${onyxMethod} called for key: ${key}${underscore_1.default.isObject(value) ? ` properties: ${underscore_1.default.keys(value).join(',')}` : ''} hasChanged: ${hasChanged}`);
+}
+function logKeyRemoved(onyxMethod, key) {
+    Logger.logInfo(`${onyxMethod} called for key: ${key} => null passed, so key was removed`);
+}
 /**
  * Clear internal variables used in this file, useful in test environments.
  */
@@ -1252,9 +1381,9 @@ const OnyxUtils = {
     evictStorageAndRetry,
     broadcastUpdate,
     hasPendingMergeForKey,
-    removeNullValues,
     prepareKeyValuePairsForStorage,
-    applyMerge,
+    mergeChanges,
+    mergeAndMarkChanges,
     initializeWithDefaultKeyStates,
     getSnapshotKey,
     multiGet,
@@ -1270,6 +1399,9 @@ const OnyxUtils = {
     addKeyToRecentlyAccessedIfNeeded,
     reduceCollectionWithSelector,
     updateSnapshots,
+    mergeCollectionWithPatches,
+    logKeyChanged,
+    logKeyRemoved,
 };
 GlobalSettings.addGlobalSettingsChangeListener(({ enablePerformanceMetrics }) => {
     if (!enablePerformanceMetrics) {
@@ -1289,8 +1421,6 @@ GlobalSettings.addGlobalSettingsChangeListener(({ enablePerformanceMetrics }) =>
     // @ts-expect-error Reassign
     getCollectionKeys = (0, metrics_1.default)(getCollectionKeys, 'OnyxUtils.getCollectionKeys');
     // @ts-expect-error Reassign
-    addEvictableKeysToRecentlyAccessedList = (0, metrics_1.default)(OnyxCache_1.default.addEvictableKeysToRecentlyAccessedList, 'OnyxCache.addEvictableKeysToRecentlyAccessedList');
-    // @ts-expect-error Reassign
     keysChanged = (0, metrics_1.default)(keysChanged, 'OnyxUtils.keysChanged');
     // @ts-expect-error Reassign
     keyChanged = (0, metrics_1.default)(keyChanged, 'OnyxUtils.keyChanged');

package/dist/storage/InstanceSync/index.web.d.ts

@@ -4,14 +4,14 @@
  * data changes and then stay up-to-date with everything happening in Onyx.
  */
 import type { OnyxKey } from '../../types';
-import type { KeyList, OnStorageKeyChanged } from '../providers/types';
+import type { StorageKeyList, OnStorageKeyChanged } from '../providers/types';
 import type StorageProvider from '../providers/types';
 /**
  * Raise an event through `localStorage` to let other tabs know a value changed
  * @param {String} onyxKey
  */
 declare function raiseStorageSyncEvent(onyxKey: OnyxKey): void;
-declare function raiseStorageSyncManyKeysEvent(onyxKeys: KeyList): void;
+declare function raiseStorageSyncManyKeysEvent(onyxKeys: StorageKeyList): void;
 declare const InstanceSync: {
     shouldBeUsed: boolean;
     /**

package/dist/storage/__mocks__/index.d.ts

@@ -2,15 +2,15 @@
 declare const StorageMock: {
     init: jest.Mock<void, [], any>;
     getItem: jest.Mock<Promise<unknown>, [key: any], any>;
-    multiGet: jest.Mock<Promise<import("../providers/types").KeyValuePairList>, [keys: import("../providers/types").KeyList], any>;
-    setItem: jest.Mock<Promise<void | import("react-native-nitro-sqlite").QueryResult<import("react-native-nitro-sqlite").QueryResultRow>>, [key: any, value: unknown], any>;
-    multiSet: jest.Mock<Promise<void | import("react-native-nitro-sqlite").BatchQueryResult>, [pairs: import("../providers/types").KeyValuePairList], any>;
-    mergeItem: jest.Mock<Promise<void | import("react-native-nitro-sqlite").BatchQueryResult>, [key: any, deltaChanges: unknown, preMergedValue: unknown, shouldSetValue?: boolean | undefined], any>;
-    multiMerge: jest.Mock<Promise<void | import("react-native-nitro-sqlite").BatchQueryResult | IDBValidKey[]>, [pairs: import("../providers/types").KeyValuePairList], any>;
-    removeItem: jest.Mock<Promise<void | import("react-native-nitro-sqlite").QueryResult<import("react-native-nitro-sqlite").QueryResultRow>>, [key: string], any>;
-    removeItems: jest.Mock<Promise<void | import("react-native-nitro-sqlite").QueryResult<import("react-native-nitro-sqlite").QueryResultRow>>, [keys: import("../providers/types").KeyList], any>;
-    clear: jest.Mock<Promise<void | import("react-native-nitro-sqlite").QueryResult<import("react-native-nitro-sqlite").QueryResultRow>>, [], any>;
-    getAllKeys: jest.Mock<Promise<import("../providers/types").KeyList>, [], any>;
+    multiGet: jest.Mock<Promise<import("../providers/types").StorageKeyValuePair[]>, [keys: import("../providers/types").StorageKeyList], any>;
+    setItem: jest.Mock<Promise<void>, [key: any, value: unknown], any>;
+    multiSet: jest.Mock<Promise<void>, [pairs: import("../providers/types").StorageKeyValuePair[]], any>;
+    mergeItem: jest.Mock<Promise<void>, [key: any, change: unknown, replaceNullPatches?: import("../../utils").FastMergeReplaceNullPatch[] | undefined], any>;
+    multiMerge: jest.Mock<Promise<void>, [pairs: import("../providers/types").StorageKeyValuePair[]], any>;
+    removeItem: jest.Mock<Promise<void>, [key: string], any>;
+    removeItems: jest.Mock<Promise<void>, [keys: import("../providers/types").StorageKeyList], any>;
+    clear: jest.Mock<Promise<void>, [], any>;
+    getAllKeys: jest.Mock<Promise<import("../providers/types").StorageKeyList>, [], any>;
     getDatabaseSize: jest.Mock<Promise<{
         bytesUsed: number;
         bytesRemaining: number;

package/dist/storage/index.js

@@ -120,8 +120,8 @@ const storage = {
     /**
      * Merging an existing value with a new one
      */
-    mergeItem: (key, deltaChanges, preMergedValue, shouldSetValue = false) => tryOrDegradePerformance(() => {
-        const promise = provider.mergeItem(key, deltaChanges, preMergedValue, shouldSetValue);
+    mergeItem: (key, change, replaceNullPatches) => tryOrDegradePerformance(() => {
+        const promise = provider.mergeItem(key, change, replaceNullPatches);
         if (shouldKeepInstancesSync) {
             return promise.then(() => InstanceSync_1.default.mergeItem(key));
         }

package/dist/storage/providers/IDBKeyValProvider.js

@@ -43,15 +43,18 @@ const provider = {
             });
             const upsertMany = pairsWithoutNull.map(([key, value], index) => {
                 const prev = values[index];
-                const newValue = utils_1.default.fastMerge(prev, value);
+                const newValue = utils_1.default.fastMerge(prev, value, {
+                    shouldRemoveNestedNulls: true,
+                    objectRemovalMode: 'replace',
+                }).result;
                 return (0, idb_keyval_1.promisifyRequest)(store.put(newValue, key));
             });
-            return Promise.all(upsertMany);
+            return Promise.all(upsertMany).then(() => undefined);
         });
     }),
-    mergeItem(key, _deltaChanges, preMergedValue) {
-        // Since Onyx also merged the existing value with the changes, we can just set the value directly
-        return provider.setItem(key, preMergedValue);
+    mergeItem(key, change) {
+        // Since Onyx already merged the existing value with the changes, we can just set the value directly.
+        return provider.multiMerge([[key, change]]);
     },
     multiSet: (pairs) => {
         const pairsWithoutNull = pairs.filter(([key, value]) => {

package/dist/storage/providers/MemoryOnlyProvider.js

@@ -60,9 +60,9 @@ const provider = {
     /**
      * Merging an existing value with a new one
      */
-    mergeItem(key, _deltaChanges, preMergedValue) {
-        // Since Onyx already merged the existing value with the changes, we can just set the value directly
-        return this.setItem(key, preMergedValue);
+    mergeItem(key, change) {
+        // Since Onyx already merged the existing value with the changes, we can just set the value directly.
+        return this.multiMerge([[key, change]]);
     },
     /**
      * Multiple merging of existing and new values in a batch
@@ -71,10 +71,13 @@ const provider = {
     multiMerge(pairs) {
         underscore_1.default.forEach(pairs, ([key, value]) => {
             const existingValue = store[key];
-            const newValue = utils_1.default.fastMerge(existingValue, value);
+            const newValue = utils_1.default.fastMerge(existingValue, value, {
+                shouldRemoveNestedNulls: true,
+                objectRemovalMode: 'replace',
+            }).result;
             set(key, newValue);
         });
-        return Promise.resolve([]);
+        return Promise.resolve();
     },
     /**
      * Remove given key and it's value from memory

package/dist/storage/providers/NoopProvider.js

@@ -46,7 +46,7 @@ const provider = {
      * This function also removes all nested null values from an object.
      */
     multiMerge() {
-        return Promise.resolve([]);
+        return Promise.resolve();
     },
     /**
      * Remove given key and it's value from memory

package/dist/storage/providers/SQLiteProvider.js

@@ -14,6 +14,24 @@ const utils_1 = __importDefault(require("../../utils"));
 (0, react_native_nitro_sqlite_1.enableSimpleNullHandling)();
 const DB_NAME = 'OnyxDB';
 let db;
+/**
+ * Prevents the stringifying of the object markers.
+ */
+function objectMarkRemover(key, value) {
+    if (key === utils_1.default.ONYX_INTERNALS__REPLACE_OBJECT_MARK)
+        return undefined;
+    return value;
+}
+/**
+ * Transforms the replace null patches into SQL queries to be passed to JSON_REPLACE.
+ */
+function generateJSONReplaceSQLQueries(key, patches) {
+    const queries = patches.map(([pathArray, value]) => {
+        const jsonPath = `$.${pathArray.join('.')}`;
+        return [jsonPath, JSON.stringify(value), key];
+    });
+    return queries;
+}
 const provider = {
     /**
      * The name of the provider that can be printed to the logs
@@ -53,7 +71,7 @@ const provider = {
         });
     },
     setItem(key, value) {
-        return db.executeAsync('REPLACE INTO keyvaluepairs (record_key, valueJSON) VALUES (?, ?);', [key, JSON.stringify(value)]);
+        return db.executeAsync('REPLACE INTO keyvaluepairs (record_key, valueJSON) VALUES (?, ?);', [key, JSON.stringify(value)]).then(() => undefined);
     },
     multiSet(pairs) {
         const query = 'REPLACE INTO keyvaluepairs (record_key, valueJSON) VALUES (?, json(?));';
@@ -61,41 +79,57 @@ const provider = {
         if (utils_1.default.isEmptyObject(params)) {
             return Promise.resolve();
         }
-        return db.executeBatchAsync([{ query, params }]);
+        return db.executeBatchAsync([{ query, params }]).then(() => undefined);
     },
     multiMerge(pairs) {
-        // Note: We use `ON CONFLICT DO UPDATE` here instead of `INSERT OR REPLACE INTO`
-        // so the new JSON value is merged into the old one if there's an existing value
-        const query = `INSERT INTO keyvaluepairs (record_key, valueJSON)
-             VALUES (:key, JSON(:value))
-             ON CONFLICT DO UPDATE
-             SET valueJSON = JSON_PATCH(valueJSON, JSON(:value));
+        const commands = [];
+        // Query to merge the change into the DB value.
+        const patchQuery = `INSERT INTO keyvaluepairs (record_key, valueJSON)
+            VALUES (:key, JSON(:value))
+            ON CONFLICT DO UPDATE
+            SET valueJSON = JSON_PATCH(valueJSON, JSON(:value));
         `;
-        const nonUndefinedPairs = pairs.filter((pair) => pair[1] !== undefined);
-        const params = nonUndefinedPairs.map((pair) => {
-            const value = JSON.stringify(pair[1]);
-            return [pair[0], value];
-        });
-        return db.executeBatchAsync([{ query, params }]);
-    },
-    mergeItem(key, deltaChanges, preMergedValue, shouldSetValue) {
-        if (shouldSetValue) {
-            return this.setItem(key, preMergedValue);
+        const patchQueryArguments = [];
+        // Query to fully replace the nested objects of the DB value.
+        const replaceQuery = `UPDATE keyvaluepairs
+            SET valueJSON = JSON_REPLACE(valueJSON, ?, JSON(?))
+            WHERE record_key = ?;
+        `;
+        const replaceQueryArguments = [];
+        const nonNullishPairs = pairs.filter((pair) => pair[1] !== undefined);
+        for (const [key, value, replaceNullPatches] of nonNullishPairs) {
+            const changeWithoutMarkers = JSON.stringify(value, objectMarkRemover);
+            patchQueryArguments.push([key, changeWithoutMarkers]);
+            const patches = replaceNullPatches !== null && replaceNullPatches !== void 0 ? replaceNullPatches : [];
+            if (patches.length > 0) {
+                const queries = generateJSONReplaceSQLQueries(key, patches);
+                if (queries.length > 0) {
+                    replaceQueryArguments.push(...queries);
+                }
+            }
+        }
+        commands.push({ query: patchQuery, params: patchQueryArguments });
+        if (replaceQueryArguments.length > 0) {
+            commands.push({ query: replaceQuery, params: replaceQueryArguments });
         }
-        return this.multiMerge([[key, deltaChanges]]);
+        return db.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 this.multiMerge([[key, change, replaceNullPatches]]);
     },
     getAllKeys: () => db.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 : []);
     }),
-    removeItem: (key) => db.executeAsync('DELETE FROM keyvaluepairs WHERE record_key = ?;', [key]),
+    removeItem: (key) => db.executeAsync('DELETE FROM keyvaluepairs WHERE record_key = ?;', [key]).then(() => undefined),
     removeItems: (keys) => {
         const placeholders = keys.map(() => '?').join(',');
         const query = `DELETE FROM keyvaluepairs WHERE record_key IN (${placeholders});`;
-        return db.executeAsync(query, keys);
+        return db.executeAsync(query, keys).then(() => undefined);
     },
-    clear: () => db.executeAsync('DELETE FROM keyvaluepairs;', []),
+    clear: () => db.executeAsync('DELETE FROM keyvaluepairs;', []).then(() => undefined),
     getDatabaseSize() {
         return Promise.all([db.executeAsync('PRAGMA page_size;'), db.executeAsync('PRAGMA page_count;'), (0, react_native_device_info_1.getFreeDiskStorage)()]).then(([pageSizeResult, pageCountResult, bytesRemaining]) => {
             var _a, _b, _c, _d, _e, _f;

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

@@ -1,8 +1,11 @@
-import type { BatchQueryResult, QueryResult } from 'react-native-nitro-sqlite';
 import type { OnyxKey, OnyxValue } from '../../types';
-type KeyValuePair = [OnyxKey, OnyxValue<OnyxKey>];
-type KeyList = OnyxKey[];
-type KeyValuePairList = KeyValuePair[];
+import type { FastMergeReplaceNullPatch } from '../../utils';
+type StorageKeyValuePair = [key: OnyxKey, value: OnyxValue<OnyxKey>, replaceNullPatches?: FastMergeReplaceNullPatch[]];
+type StorageKeyList = OnyxKey[];
+type DatabaseSize = {
+    bytesUsed: number;
+    bytesRemaining: number;
+};
 type OnStorageKeyChanged = <TKey extends OnyxKey>(key: TKey, value: OnyxValue<TKey>) => void;
 type StorageProvider = {
     /**
@@ -20,53 +23,48 @@ type StorageProvider = {
     /**
      * Get multiple key-value pairs for the given array of keys in a batch
      */
-    multiGet: (keys: KeyList) => Promise<KeyValuePairList>;
+    multiGet: (keys: StorageKeyList) => Promise<StorageKeyValuePair[]>;
     /**
      * Sets the value for a given key. The only requirement is that the value should be serializable to JSON string
      */
-    setItem: <TKey extends OnyxKey>(key: TKey, value: OnyxValue<TKey>) => Promise<QueryResult | void>;
+    setItem: <TKey extends OnyxKey>(key: TKey, value: OnyxValue<TKey>) => Promise<void>;
     /**
      * Stores multiple key-value pairs in a batch
      */
-    multiSet: (pairs: KeyValuePairList) => Promise<BatchQueryResult | void>;
+    multiSet: (pairs: StorageKeyValuePair[]) => Promise<void>;
     /**
      * Multiple merging of existing and new values in a batch
      */
-    multiMerge: (pairs: KeyValuePairList) => Promise<BatchQueryResult | IDBValidKey[] | void>;
+    multiMerge: (pairs: StorageKeyValuePair[]) => Promise<void>;
     /**
-     * Merges an existing value with a new one by leveraging JSON_PATCH
-     * @param deltaChanges - the delta for a specific key
-     * @param preMergedValue - the pre-merged data from `Onyx.applyMerge`
-     * @param shouldSetValue - whether the data should be set instead of merged
+     * Merges an existing value with a new one
+     * @param change - the change to merge with the existing value
      */
-    mergeItem: <TKey extends OnyxKey>(key: TKey, deltaChanges: OnyxValue<TKey>, preMergedValue: OnyxValue<TKey>, shouldSetValue?: boolean) => Promise<BatchQueryResult | void>;
+    mergeItem: <TKey extends OnyxKey>(key: TKey, change: OnyxValue<TKey>, replaceNullPatches?: FastMergeReplaceNullPatch[]) => Promise<void>;
     /**
      * Returns all keys available in storage
      */
-    getAllKeys: () => Promise<KeyList>;
+    getAllKeys: () => Promise<StorageKeyList>;
     /**
      * Removes given key and its value from storage
      */
-    removeItem: (key: OnyxKey) => Promise<QueryResult | void>;
+    removeItem: (key: OnyxKey) => Promise<void>;
     /**
      * Removes given keys and their values from storage
      */
-    removeItems: (keys: KeyList) => Promise<QueryResult | void>;
+    removeItems: (keys: StorageKeyList) => Promise<void>;
     /**
      * Clears absolutely everything from storage
      */
-    clear: () => Promise<QueryResult | void>;
+    clear: () => Promise<void>;
     /**
      * Gets the total bytes of the database file
      */
-    getDatabaseSize: () => Promise<{
-        bytesUsed: number;
-        bytesRemaining: number;
-    }>;
+    getDatabaseSize: () => Promise<DatabaseSize>;
     /**
      * @param onStorageKeyChanged Storage synchronization mechanism keeping all opened tabs in sync
      */
     keepInstancesSync?: (onStorageKeyChanged: OnStorageKeyChanged) => void;
 };
 export default StorageProvider;
-export type { KeyList, KeyValuePair, KeyValuePairList, OnStorageKeyChanged };
+export type { StorageKeyList, StorageKeyValuePair, OnStorageKeyChanged };