react-native-onyx 2.0.12 → 2.0.14

package/dist/Logger.d.ts

@@ -1,13 +1,18 @@
-declare type LogData = {
+type LogData = {
     message: string;
     level: 'alert' | 'info';
 };
-
+type LoggerCallback = (data: LogData) => void;
 /**
  * Register the logging callback
- *
- * @param callback
  */
-declare function registerLogger(callback: (data: LogData) => void): void;
-
-export {registerLogger};
+declare function registerLogger(callback: LoggerCallback): void;
+/**
+ * Send an alert message to the logger
+ */
+declare function logAlert(message: string): void;
+/**
+ * Send an info message to the logger
+ */
+declare function logInfo(message: string): void;
+export { registerLogger, logInfo, logAlert };

package/dist/Logger.js

@@ -1,12 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.logAlert = exports.logInfo = exports.registerLogger = void 0;
-// Logging callback
+// eslint-disable-next-line @typescript-eslint/no-empty-function
 let logger = () => { };
 /**
  * Register the logging callback
- *
- * @param {Function} callback
  */
 function registerLogger(callback) {
     logger = callback;
@@ -14,8 +12,6 @@ function registerLogger(callback) {
 exports.registerLogger = registerLogger;
 /**
  * Send an alert message to the logger
- *
- * @param {String} message
  */
 function logAlert(message) {
     logger({ message: `[Onyx] ${message}`, level: 'alert' });
@@ -23,8 +19,6 @@ function logAlert(message) {
 exports.logAlert = logAlert;
 /**
  * Send an info message to the logger
- *
- * @param {String} message
  */
 function logInfo(message) {
     logger({ message: `[Onyx] ${message}`, level: 'info' });

package/dist/Str.d.ts

@@ -1,18 +1,17 @@
 /**
  * Returns true if the haystack begins with the needle
  *
- * @param {String} haystack  The full string to be searched
- * @param {String} needle    The case-sensitive string to search for
- * @return {Boolean} Returns true if the haystack starts with the needle.
+ * @param haystack  The full string to be searched
+ * @param needle    The case-sensitive string to search for
+ * @return Returns true if the haystack starts with the needle.
  */
-export function startsWith(haystack: string, needle: string): boolean;
+declare function startsWith(haystack: string, needle: string): boolean;
 /**
  * Checks if parameter is a string or function.
  * If it is a string, then we will just return it.
  * If it is a function, then we will call it with
  * any additional arguments and return the result.
- *
- * @param {String|Function} parameter
- * @returns {*}
  */
-export function result(parameter: string | Function, ...args: any[]): any;
+declare function result(parameter: string): string;
+declare function result<TFunction extends (...a: TArgs) => unknown, TArgs extends unknown[]>(parameter: TFunction, ...args: TArgs): ReturnType<TFunction>;
+export { startsWith, result };

package/dist/Str.js

@@ -1,31 +1,18 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.result = exports.startsWith = void 0;
-const underscore_1 = __importDefault(require("underscore"));
 /**
  * Returns true if the haystack begins with the needle
  *
- * @param {String} haystack  The full string to be searched
- * @param {String} needle    The case-sensitive string to search for
- * @return {Boolean} Returns true if the haystack starts with the needle.
+ * @param haystack  The full string to be searched
+ * @param needle    The case-sensitive string to search for
+ * @return Returns true if the haystack starts with the needle.
  */
 function startsWith(haystack, needle) {
-    return underscore_1.default.isString(haystack) && underscore_1.default.isString(needle) && haystack.startsWith(needle);
+    return typeof haystack === 'string' && typeof needle === 'string' && haystack.startsWith(needle);
 }
 exports.startsWith = startsWith;
-/**
- * Checks if parameter is a string or function.
- * If it is a string, then we will just return it.
- * If it is a function, then we will call it with
- * any additional arguments and return the result.
- *
- * @param {String|Function} parameter
- * @returns {*}
- */
 function result(parameter, ...args) {
-    return underscore_1.default.isFunction(parameter) ? parameter(...args) : parameter;
+    return typeof parameter === 'function' ? parameter(...args) : parameter;
 }
 exports.result = result;

package/dist/createDeferredTask.d.ts

@@ -1,12 +1,11 @@
+type DeferredTask = {
+    promise: Promise<void>;
+    resolve?: () => void;
+};
 /**
  * Create a deferred task that can be resolved when we call `resolve()`
  * The returned promise will complete when we call `resolve`
  * Useful when we want to wait for a tasks that is resolved from an external action
- *
- * @template T
- * @returns {{ resolve: function(*), promise: Promise<T|void> }}
  */
-export default function createDeferredTask<T>(): {
-    resolve: (arg0: any) => any;
-    promise: Promise<void | T>;
-};
+export default function createDeferredTask(): DeferredTask;
+export {};

package/dist/createDeferredTask.js

@@ -4,9 +4,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
  * Create a deferred task that can be resolved when we call `resolve()`
  * The returned promise will complete when we call `resolve`
  * Useful when we want to wait for a tasks that is resolved from an external action
- *
- * @template T
- * @returns {{ resolve: function(*), promise: Promise<T|void> }}
  */
 function createDeferredTask() {
     const deferred = {};

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.12",
+  "version": "2.0.14",
   "author": "Expensify, Inc.",
   "homepage": "https://expensify.com",
   "description": "State management for React Native",

package/dist/SyncQueue.d.ts

@@ -1,32 +0,0 @@
-/**
- * Synchronous queue that can be used to ensure promise based tasks are run in sequence.
- * Pass to the constructor a function that returns a promise to run the task then add data.
- *
- * @example
- *
- *     const queue = new SyncQueue(({key, val}) => {
- *         return someAsyncProcess(key, val);
- *     });
- *
- *     queue.push({key: 1, val: '1'});
- *     queue.push({key: 2, val: '2'});
- */
-export default class SyncQueue {
-    /**
-     * @param {Function} run - must return a promise
-     */
-    constructor(run: Function);
-    queue: any[];
-    isProcessing: boolean;
-    run: Function;
-    /**
-     * Stop the queue from being processed and clear out any existing tasks
-     */
-    abort(): void;
-    process(): void;
-    /**
-     * @param {*} data
-     * @returns {Promise}
-     */
-    push(data: any): Promise<any>;
-}

package/dist/SyncQueue.js

@@ -1,57 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-/**
- * Synchronous queue that can be used to ensure promise based tasks are run in sequence.
- * Pass to the constructor a function that returns a promise to run the task then add data.
- *
- * @example
- *
- *     const queue = new SyncQueue(({key, val}) => {
- *         return someAsyncProcess(key, val);
- *     });
- *
- *     queue.push({key: 1, val: '1'});
- *     queue.push({key: 2, val: '2'});
- */
-class SyncQueue {
-    /**
-     * @param {Function} run - must return a promise
-     */
-    constructor(run) {
-        this.queue = [];
-        this.isProcessing = false;
-        this.run = run;
-    }
-    /**
-     * Stop the queue from being processed and clear out any existing tasks
-     */
-    abort() {
-        this.queue = [];
-        this.isProcessing = false;
-    }
-    process() {
-        if (this.isProcessing || this.queue.length === 0) {
-            return;
-        }
-        this.isProcessing = true;
-        const { data, resolve, reject } = this.queue.shift();
-        this.run(data)
-            .then(resolve)
-            .catch(reject)
-            .finally(() => {
-            this.isProcessing = false;
-            this.process();
-        });
-    }
-    /**
-     * @param {*} data
-     * @returns {Promise}
-     */
-    push(data) {
-        return new Promise((resolve, reject) => {
-            this.queue.push({ resolve, reject, data });
-            this.process();
-        });
-    }
-}
-exports.default = SyncQueue;

package/dist/compose.d.ts

@@ -1,19 +0,0 @@
-/**
- * This is a utility function taken directly from Redux. (We don't want to add Redux as a dependency)
- * It enables functional composition, useful for the chaining/composition of HOCs.
- *
- * For example, instead of:
- *
- * export default hoc1(config1, hoc2(config2, hoc3(config3)))(Component);
- *
- * Use this instead:
- *
- * export default compose(
- *     hoc1(config1),
- *     hoc2(config2),
- *     hoc3(config3),
- * )(Component)
- *
- * @returns {Function}
- */
-export default function compose(...funcs: any[]): Function;

package/dist/compose.js

@@ -1,31 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-/**
- * This is a utility function taken directly from Redux. (We don't want to add Redux as a dependency)
- * It enables functional composition, useful for the chaining/composition of HOCs.
- *
- * For example, instead of:
- *
- * export default hoc1(config1, hoc2(config2, hoc3(config3)))(Component);
- *
- * Use this instead:
- *
- * export default compose(
- *     hoc1(config1),
- *     hoc2(config2),
- *     hoc3(config3),
- * )(Component)
- *
- * @returns {Function}
- */
-function compose(...funcs) {
-    if (funcs.length === 0) {
-        return (arg) => arg;
-    }
-    if (funcs.length === 1) {
-        return funcs[0];
-    }
-    // eslint-disable-next-line rulesdir/prefer-underscore-method
-    return funcs.reduce((a, b) => (...args) => a(b(...args)));
-}
-exports.default = compose;