react-native-onyx 2.0.13 → 2.0.14

package/dist/storage/__mocks__/index.js

@@ -10,6 +10,7 @@ const set = jest.fn((key, value) => {
     return Promise.resolve(value);
 });
 const idbKeyvalMock = {
+    name: 'KeyValMockProvider',
     init: () => undefined,
     setItem(key, value) {
         return set(key, value);

package/dist/storage/index.d.ts

@@ -1,6 +1,6 @@
 import type StorageProvider from './providers/types';
 type Storage = {
     getStorageProvider: () => StorageProvider;
-} & StorageProvider;
+} & Omit<StorageProvider, 'name'>;
 declare const Storage: Storage;
 export default Storage;

package/dist/storage/index.js

@@ -1,12 +1,71 @@
 "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 (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __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 Logger = __importStar(require("../Logger"));
 const platforms_1 = __importDefault(require("./platforms"));
 const InstanceSync_1 = __importDefault(require("./InstanceSync"));
-const provider = platforms_1.default;
+const NoopProvider_1 = __importDefault(require("./providers/NoopProvider"));
+let provider = platforms_1.default;
 let shouldKeepInstancesSync = false;
+let finishInitalization;
+const initPromise = new Promise((resolve) => {
+    finishInitalization = resolve;
+});
+/**
+ * Degrade performance by removing the storage provider and only using cache
+ */
+function degradePerformance(error) {
+    Logger.logAlert(`Error while using ${provider.name}. Falling back to only using cache and dropping storage.`);
+    console.error(error);
+    provider = NoopProvider_1.default;
+}
+/**
+ * Runs a piece of code and degrades performance if certain errors are thrown
+ */
+function tryOrDegradePerformance(fn) {
+    return new Promise((resolve, reject) => {
+        initPromise.then(() => {
+            try {
+                resolve(fn());
+            }
+            catch (error) {
+                // Test for known critical errors that the storage provider throws, e.g. when storage is full
+                if (error instanceof Error) {
+                    // IndexedDB error when storage is full (https://github.com/Expensify/App/issues/29403)
+                    if (error.message.includes('Internal error opening backing store for indexedDB.open')) {
+                        degradePerformance(error);
+                    }
+                }
+                reject(error);
+            }
+        });
+    });
+}
 const Storage = {
     /**
      * Returns the storage provider currently in use
@@ -19,90 +78,92 @@ const Storage = {
      * and enables fallback providers if necessary
      */
     init() {
-        provider.init();
+        tryOrDegradePerformance(provider.init).finally(() => {
+            finishInitalization();
+        });
     },
     /**
      * Get the value of a given key or return `null` if it's not available
      */
-    getItem: (key) => provider.getItem(key),
+    getItem: (key) => tryOrDegradePerformance(() => provider.getItem(key)),
     /**
      * Get multiple key-value pairs for the give array of keys in a batch
      */
-    multiGet: (keys) => provider.multiGet(keys),
+    multiGet: (keys) => tryOrDegradePerformance(() => provider.multiGet(keys)),
     /**
      * Sets the value for a given key. The only requirement is that the value should be serializable to JSON string
      */
-    setItem: (key, value) => {
+    setItem: (key, value) => tryOrDegradePerformance(() => {
         const promise = provider.setItem(key, value);
         if (shouldKeepInstancesSync) {
             return promise.then(() => InstanceSync_1.default.setItem(key));
         }
         return promise;
-    },
+    }),
     /**
      * Stores multiple key-value pairs in a batch
      */
-    multiSet: (pairs) => provider.multiSet(pairs),
+    multiSet: (pairs) => tryOrDegradePerformance(() => provider.multiSet(pairs)),
     /**
      * Merging an existing value with a new one
      */
-    mergeItem: (key, changes, modifiedData) => {
+    mergeItem: (key, changes, modifiedData) => tryOrDegradePerformance(() => {
         const promise = provider.mergeItem(key, changes, modifiedData);
         if (shouldKeepInstancesSync) {
             return promise.then(() => InstanceSync_1.default.mergeItem(key));
         }
         return promise;
-    },
+    }),
     /**
      * Multiple merging of existing and new values in a batch
      * This function also removes all nested null values from an object.
      */
-    multiMerge: (pairs) => provider.multiMerge(pairs),
+    multiMerge: (pairs) => tryOrDegradePerformance(() => provider.multiMerge(pairs)),
     /**
      * Removes given key and its value
      */
-    removeItem: (key) => {
+    removeItem: (key) => tryOrDegradePerformance(() => {
         const promise = provider.removeItem(key);
         if (shouldKeepInstancesSync) {
             return promise.then(() => InstanceSync_1.default.removeItem(key));
         }
         return promise;
-    },
+    }),
     /**
      * Remove given keys and their values
      */
-    removeItems: (keys) => {
+    removeItems: (keys) => tryOrDegradePerformance(() => {
         const promise = provider.removeItems(keys);
         if (shouldKeepInstancesSync) {
             return promise.then(() => InstanceSync_1.default.removeItems(keys));
         }
         return promise;
-    },
+    }),
     /**
      * Clears everything
      */
-    clear: () => {
+    clear: () => tryOrDegradePerformance(() => {
         if (shouldKeepInstancesSync) {
             return InstanceSync_1.default.clear(() => provider.clear());
         }
         return provider.clear();
-    },
+    }),
     // This is a noop for now in order to keep clients from crashing see https://github.com/Expensify/Expensify/issues/312438
-    setMemoryOnlyKeys: () => provider.setMemoryOnlyKeys(),
+    setMemoryOnlyKeys: () => tryOrDegradePerformance(() => provider.setMemoryOnlyKeys()),
     /**
      * Returns all available keys
      */
-    getAllKeys: () => provider.getAllKeys(),
+    getAllKeys: () => tryOrDegradePerformance(() => provider.getAllKeys()),
     /**
      * Gets the total bytes of the store
      */
-    getDatabaseSize: () => provider.getDatabaseSize(),
+    getDatabaseSize: () => tryOrDegradePerformance(() => provider.getDatabaseSize()),
     /**
      * @param onStorageKeyChanged - Storage synchronization mechanism keeping all opened tabs in sync (web only)
      */
     keepInstancesSync(onStorageKeyChanged) {
         // If InstanceSync is null, it means we're on a native platform and we don't need to keep instances in sync
-        if (InstanceSync_1.default == null)
+        if (InstanceSync_1.default === null)
             return;
         shouldKeepInstancesSync = true;
         InstanceSync_1.default.init(onStorageKeyChanged);

package/dist/storage/providers/IDBKeyValProvider.js

@@ -9,6 +9,10 @@ const utils_1 = __importDefault(require("../../utils"));
 // which might not be available in certain environments that load the bundle (e.g. electron main process).
 let idbKeyValStore;
 const provider = {
+    /**
+     * The name of the provider that can be printed to the logs
+     */
+    name: 'IDBKeyValProvider',
     /**
      * Initializes the storage provider
      */

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

@@ -0,0 +1,3 @@
+import type StorageProvider from './types';
+declare const provider: StorageProvider;
+export default provider;

package/dist/storage/providers/NoopProvider.js

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const provider = {
+    /**
+     * The name of the provider that can be printed to the logs
+     */
+    name: 'NoopProvider',
+    /**
+     * Initializes the storage provider
+     */
+    init() {
+        // do nothing
+    },
+    /**
+     * Get the value of a given key or return `null` if it's not available in memory
+     * @param {String} key
+     * @return {Promise<*>}
+     */
+    getItem() {
+        return Promise.resolve(null);
+    },
+    /**
+     * Get multiple key-value pairs for the give array of keys in a batch.
+     */
+    multiGet() {
+        return Promise.resolve([]);
+    },
+    /**
+     * Sets the value for a given key. The only requirement is that the value should be serializable to JSON string
+     */
+    setItem() {
+        return Promise.resolve();
+    },
+    /**
+     * Stores multiple key-value pairs in a batch
+     */
+    multiSet() {
+        return Promise.resolve();
+    },
+    /**
+     * Merging an existing value with a new one
+     */
+    mergeItem() {
+        return Promise.resolve();
+    },
+    /**
+     * Multiple merging of existing and new values in a batch
+     * This function also removes all nested null values from an object.
+     */
+    multiMerge() {
+        return Promise.resolve([]);
+    },
+    /**
+     * Remove given key and it's value from memory
+     */
+    removeItem() {
+        return Promise.resolve();
+    },
+    /**
+     * Remove given keys and their values from memory
+     */
+    removeItems() {
+        return Promise.resolve();
+    },
+    /**
+     * Clear everything from memory
+     */
+    clear() {
+        return Promise.resolve();
+    },
+    // This is a noop for now in order to keep clients from crashing see https://github.com/Expensify/Expensify/issues/312438
+    setMemoryOnlyKeys() {
+        // do nothing
+    },
+    /**
+     * Returns all keys available in memory
+     */
+    getAllKeys() {
+        return Promise.resolve([]);
+    },
+    /**
+     * Gets the total bytes of the store.
+     * `bytesRemaining` will always be `Number.POSITIVE_INFINITY` since we don't have a hard limit on memory.
+     */
+    getDatabaseSize() {
+        return Promise.resolve({ bytesRemaining: Number.POSITIVE_INFINITY, bytesUsed: 0 });
+    },
+};
+exports.default = provider;

package/dist/storage/providers/SQLiteProvider.js

@@ -9,6 +9,10 @@ const utils_1 = __importDefault(require("../../utils"));
 const DB_NAME = 'OnyxDB';
 let db;
 const provider = {
+    /**
+     * The name of the provider that can be printed to the logs
+     */
+    name: 'SQLiteProvider',
     /**
      * Initializes the storage provider
      */

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

@@ -6,6 +6,10 @@ type KeyList = Key[];
 type KeyValuePairList = KeyValuePair[];
 type OnStorageKeyChanged = (key: Key, value: Value | null) => void;
 type StorageProvider = {
+    /**
+     * The name of the provider that can be printed to the logs
+     */
+    name: string;
     /**
      * Initializes the storage provider
      */
@@ -69,4 +73,4 @@ type StorageProvider = {
     keepInstancesSync?: (onStorageKeyChanged: OnStorageKeyChanged) => void;
 };
 export default StorageProvider;
-export type { Value, Key, KeyList, KeyValuePairList, OnStorageKeyChanged };
+export type { Value, Key, KeyList, KeyValuePair, KeyValuePairList, OnStorageKeyChanged };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-onyx",
-  "version": "2.0.13",
+  "version": "2.0.14",
   "author": "Expensify, Inc.",
   "homepage": "https://expensify.com",
   "description": "State management for React Native",