react-native-onyx 2.0.21 → 2.0.23

package/dist/PerformanceUtils.d.ts

@@ -1,10 +1,8 @@
-type Mapping = Record<string, unknown> & {
-    key: string;
-    displayName: string;
-};
+import type { OnyxKey } from './types';
+import type { Mapping } from './Onyx';
 declare function setShouldDebugSetState(debug: boolean): void;
 /**
  * Provide insights into why a setState() call occurred by diffing the before and after values.
  */
-declare function logSetStateCall(mapping: Mapping, previousValue: unknown, newValue: unknown, caller: string, keyThatChanged: string): void;
+declare function logSetStateCall<TKey extends OnyxKey>(mapping: Mapping<TKey>, previousValue: unknown, newValue: unknown, caller: string, keyThatChanged?: string): void;
 export { logSetStateCall, setShouldDebugSetState };

package/dist/index.d.ts

@@ -1,8 +1,9 @@
 import Onyx from './Onyx';
 import type { OnyxUpdate, ConnectOptions } from './Onyx';
-import type { CustomTypeOptions, OnyxCollection, OnyxEntry, NullishDeep, KeyValueMapping, OnyxKey, Selector, WithOnyxInstanceState } from './types';
+import type { CustomTypeOptions, OnyxCollection, OnyxEntry, NullishDeep, KeyValueMapping, OnyxKey, Selector, WithOnyxInstanceState, OnyxValue } from './types';
+import type { UseOnyxResult, FetchStatus } from './useOnyx';
 import useOnyx from './useOnyx';
 import withOnyx from './withOnyx';
 export default Onyx;
 export { withOnyx, useOnyx };
-export type { CustomTypeOptions, OnyxCollection, OnyxEntry, OnyxUpdate, ConnectOptions, NullishDeep, KeyValueMapping, OnyxKey, Selector, WithOnyxInstanceState };
+export type { CustomTypeOptions, OnyxCollection, OnyxEntry, OnyxUpdate, ConnectOptions, NullishDeep, KeyValueMapping, OnyxKey, Selector, WithOnyxInstanceState, UseOnyxResult, OnyxValue, FetchStatus, };

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

@@ -0,0 +1,14 @@
+/**
+ *  This is used to keep multiple browser tabs in sync, therefore only needed on web
+ *  On native platforms, we omit this syncing logic by setting this to mock implementation.
+ */
+declare const InstanceSync: {
+    shouldBeUsed: boolean;
+    init: (...args: any[]) => void;
+    setItem: (...args: any[]) => void;
+    removeItem: (...args: any[]) => void;
+    removeItems: (...args: any[]) => void;
+    mergeItem: (...args: any[]) => void;
+    clear: <T extends () => void>(callback: T) => Promise<void>;
+};
+export default InstanceSync;

package/dist/storage/InstanceSync/index.js

@@ -0,0 +1,20 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const noop_1 = __importDefault(require("lodash/noop"));
+/**
+ *  This is used to keep multiple browser tabs in sync, therefore only needed on web
+ *  On native platforms, we omit this syncing logic by setting this to mock implementation.
+ */
+const InstanceSync = {
+    shouldBeUsed: false,
+    init: noop_1.default,
+    setItem: noop_1.default,
+    removeItem: noop_1.default,
+    removeItems: noop_1.default,
+    mergeItem: noop_1.default,
+    clear: (callback) => Promise.resolve(callback()),
+};
+exports.default = InstanceSync;

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

@@ -0,0 +1,27 @@
+/**
+ * The InstancesSync object provides data-changed events like the ones that exist
+ * when using LocalStorage APIs in the browser. These events are great because multiple tabs can listen for when
+ * 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 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 const InstanceSync: {
+    shouldBeUsed: boolean;
+    /**
+     * @param {Function} onStorageKeyChanged Storage synchronization mechanism keeping all opened tabs in sync
+     */
+    init: (onStorageKeyChanged: OnStorageKeyChanged, store: StorageProvider) => void;
+    setItem: typeof raiseStorageSyncEvent;
+    removeItem: typeof raiseStorageSyncEvent;
+    removeItems: typeof raiseStorageSyncManyKeysEvent;
+    mergeItem: typeof raiseStorageSyncEvent;
+    clear: (clearImplementation: () => void) => Promise<void>;
+};
+export default InstanceSync;

package/dist/storage/InstanceSync/index.web.js

@@ -0,0 +1,59 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const NoopProvider_1 = __importDefault(require("../providers/NoopProvider"));
+const SYNC_ONYX = 'SYNC_ONYX';
+/**
+ * Raise an event through `localStorage` to let other tabs know a value changed
+ * @param {String} onyxKey
+ */
+function raiseStorageSyncEvent(onyxKey) {
+    global.localStorage.setItem(SYNC_ONYX, onyxKey);
+    global.localStorage.removeItem(SYNC_ONYX);
+}
+function raiseStorageSyncManyKeysEvent(onyxKeys) {
+    onyxKeys.forEach((onyxKey) => {
+        raiseStorageSyncEvent(onyxKey);
+    });
+}
+let storage = NoopProvider_1.default;
+const InstanceSync = {
+    shouldBeUsed: true,
+    /**
+     * @param {Function} onStorageKeyChanged Storage synchronization mechanism keeping all opened tabs in sync
+     */
+    init: (onStorageKeyChanged, store) => {
+        storage = store;
+        // This listener will only be triggered by events coming from other tabs
+        global.addEventListener('storage', (event) => {
+            // Ignore events that don't originate from the SYNC_ONYX logic
+            if (event.key !== SYNC_ONYX || !event.newValue) {
+                return;
+            }
+            const onyxKey = event.newValue;
+            storage.getItem(onyxKey).then((value) => onStorageKeyChanged(onyxKey, value));
+        });
+    },
+    setItem: raiseStorageSyncEvent,
+    removeItem: raiseStorageSyncEvent,
+    removeItems: raiseStorageSyncManyKeysEvent,
+    mergeItem: raiseStorageSyncEvent,
+    clear: (clearImplementation) => {
+        let allKeys;
+        // The keys must be retrieved before storage is cleared or else the list of keys would be empty
+        return storage
+            .getAllKeys()
+            .then((keys) => {
+            allKeys = keys;
+        })
+            .then(() => clearImplementation())
+            .then(() => {
+            // Now that storage is cleared, the storage sync event can happen which is a more atomic action
+            // for other browser tabs
+            raiseStorageSyncManyKeysEvent(allKeys);
+        });
+    },
+};
+exports.default = InstanceSync;

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

@@ -1,23 +1,25 @@
 /// <reference types="jest" />
-import type { KeyValuePairList } from '../providers/types';
-declare const idbKeyvalMockSpy: {
-    idbKeyvalSet: jest.Mock<Promise<any>, [key: any, value: any]>;
-    setItem: jest.Mock<Promise<void | import("react-native-quick-sqlite").QueryResult>, [key: string, value: IDBValidKey]>;
-    getItem: jest.Mock<Promise<IDBValidKey | null>, [key: string]>;
+declare const StorageMock: {
+    init: jest.Mock<void, []>;
+    getItem: jest.Mock<Promise<unknown>, [key: any]>;
+    multiGet: jest.Mock<Promise<import("../providers/types").KeyValuePairList>, [keys: import("../providers/types").KeyList]>;
+    setItem: jest.Mock<Promise<void | import("react-native-quick-sqlite").QueryResult>, [key: any, value: unknown]>;
+    multiSet: jest.Mock<Promise<void | import("react-native-quick-sqlite").BatchQueryResult>, [pairs: import("../providers/types").KeyValuePairList]>;
+    mergeItem: jest.Mock<Promise<void | import("react-native-quick-sqlite").BatchQueryResult>, [key: any, changes: unknown, modifiedData: unknown]>;
+    multiMerge: jest.Mock<Promise<import("react-native-quick-sqlite").BatchQueryResult | IDBValidKey[]>, [pairs: import("../providers/types").KeyValuePairList]>;
     removeItem: jest.Mock<Promise<void | import("react-native-quick-sqlite").QueryResult>, [key: string]>;
     removeItems: jest.Mock<Promise<void | import("react-native-quick-sqlite").QueryResult>, [keys: import("../providers/types").KeyList]>;
     clear: jest.Mock<Promise<void | import("react-native-quick-sqlite").QueryResult>, []>;
     getAllKeys: jest.Mock<Promise<import("../providers/types").KeyList>, []>;
-    multiGet: jest.Mock<Promise<KeyValuePairList>, [keys: import("../providers/types").KeyList]>;
-    multiSet: jest.Mock<Promise<void | import("react-native-quick-sqlite").BatchQueryResult>, [pairs: KeyValuePairList]>;
-    multiMerge: jest.Mock<Promise<import("react-native-quick-sqlite").BatchQueryResult | IDBValidKey[]>, [pairs: KeyValuePairList]>;
-    mergeItem: jest.Mock<Promise<void | import("react-native-quick-sqlite").BatchQueryResult>, [key: string, changes: IDBValidKey, modifiedData: IDBValidKey]>;
-    getStorageMap: jest.Mock<Record<string, IDBValidKey>, []>;
-    setInitialMockData: jest.Mock<void, [data: any]>;
     getDatabaseSize: jest.Mock<Promise<{
         bytesUsed: number;
         bytesRemaining: number;
     }>, []>;
-    setMemoryOnlyKeys: jest.Mock<void, []>;
+    keepInstancesSync: jest.Mock<any, any>;
+    mockSet: (key: string, value: unknown) => Promise<unknown>;
+    getMockStore: jest.Mock<{
+        [x: string]: unknown;
+    }, []>;
+    setMockStore: jest.Mock<void, [data: any]>;
 };
-export default idbKeyvalMockSpy;
+export default StorageMock;

package/dist/storage/__mocks__/index.js

@@ -1,85 +1,47 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const utils_1 = __importDefault(require("../../utils"));
-let storageMapInternal = {};
-const set = jest.fn((key, value) => {
-    storageMapInternal[key] = value;
-    return Promise.resolve(value);
+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;
 });
-const idbKeyvalMock = {
-    setItem(key, value) {
-        return set(key, value);
-    },
-    multiSet(pairs) {
-        const setPromises = pairs.map(([key, value]) => this.setItem(key, value));
-        return new Promise((resolve) => {
-            Promise.all(setPromises).then(() => resolve(storageMapInternal));
-        });
-    },
-    getItem(key) {
-        return Promise.resolve(storageMapInternal[key]);
-    },
-    multiGet(keys) {
-        const getPromises = keys.map((key) => new Promise((resolve) => {
-            this.getItem(key).then((value) => resolve([key, value]));
-        }));
-        return Promise.all(getPromises);
-    },
-    multiMerge(pairs) {
-        pairs.forEach(([key, value]) => {
-            const existingValue = storageMapInternal[key];
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            const newValue = utils_1.default.fastMerge(existingValue, value);
-            set(key, newValue);
-        });
-        return Promise.resolve(storageMapInternal);
-    },
-    mergeItem(key, _changes, modifiedData) {
-        return this.setItem(key, modifiedData);
-    },
-    removeItem(key) {
-        delete storageMapInternal[key];
-        return Promise.resolve();
-    },
-    removeItems(keys) {
-        keys.forEach((key) => {
-            delete storageMapInternal[key];
-        });
-        return Promise.resolve();
-    },
-    clear() {
-        storageMapInternal = {};
-        return Promise.resolve();
-    },
-    getAllKeys() {
-        return Promise.resolve(Object.keys(storageMapInternal));
-    },
-    getDatabaseSize() {
-        return Promise.resolve({ bytesRemaining: 0, bytesUsed: 99999 });
-    },
-    // eslint-disable-next-line @typescript-eslint/no-empty-function
-    setMemoryOnlyKeys() { },
+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;
 };
-const idbKeyvalMockSpy = {
-    idbKeyvalSet: set,
-    setItem: jest.fn(idbKeyvalMock.setItem),
-    getItem: jest.fn(idbKeyvalMock.getItem),
-    removeItem: jest.fn(idbKeyvalMock.removeItem),
-    removeItems: jest.fn(idbKeyvalMock.removeItems),
-    clear: jest.fn(idbKeyvalMock.clear),
-    getAllKeys: jest.fn(idbKeyvalMock.getAllKeys),
-    multiGet: jest.fn(idbKeyvalMock.multiGet),
-    multiSet: jest.fn(idbKeyvalMock.multiSet),
-    multiMerge: jest.fn(idbKeyvalMock.multiMerge),
-    mergeItem: jest.fn(idbKeyvalMock.mergeItem),
-    getStorageMap: jest.fn(() => storageMapInternal),
-    setInitialMockData: jest.fn((data) => {
-        storageMapInternal = data;
-    }),
-    getDatabaseSize: jest.fn(idbKeyvalMock.getDatabaseSize),
-    setMemoryOnlyKeys: jest.fn(idbKeyvalMock.setMemoryOnlyKeys),
+Object.defineProperty(exports, "__esModule", { value: true });
+const MemoryOnlyProvider_1 = __importStar(require("../providers/MemoryOnlyProvider"));
+const init = jest.fn(MemoryOnlyProvider_1.default.init);
+init();
+const StorageMock = {
+    init,
+    getItem: jest.fn(MemoryOnlyProvider_1.default.getItem),
+    multiGet: jest.fn(MemoryOnlyProvider_1.default.multiGet),
+    setItem: jest.fn(MemoryOnlyProvider_1.default.setItem),
+    multiSet: jest.fn(MemoryOnlyProvider_1.default.multiSet),
+    mergeItem: jest.fn(MemoryOnlyProvider_1.default.mergeItem),
+    multiMerge: jest.fn(MemoryOnlyProvider_1.default.multiMerge),
+    removeItem: jest.fn(MemoryOnlyProvider_1.default.removeItem),
+    removeItems: jest.fn(MemoryOnlyProvider_1.default.removeItems),
+    clear: jest.fn(MemoryOnlyProvider_1.default.clear),
+    getAllKeys: jest.fn(MemoryOnlyProvider_1.default.getAllKeys),
+    getDatabaseSize: jest.fn(MemoryOnlyProvider_1.default.getDatabaseSize),
+    keepInstancesSync: jest.fn(),
+    mockSet: MemoryOnlyProvider_1.mockSet,
+    getMockStore: jest.fn(() => MemoryOnlyProvider_1.mockStore),
+    setMockStore: jest.fn((data) => (0, MemoryOnlyProvider_1.setMockStore)(data)),
 };
-exports.default = idbKeyvalMockSpy;
+exports.default = StorageMock;

package/dist/storage/index.d.ts

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

package/dist/storage/index.js

@@ -1,7 +1,175 @@
 "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 WebStorage_1 = __importDefault(require("./WebStorage"));
-exports.default = WebStorage_1.default;
+const Logger = __importStar(require("../Logger"));
+const platforms_1 = __importDefault(require("./platforms"));
+const InstanceSync_1 = __importDefault(require("./InstanceSync"));
+const MemoryOnlyProvider_1 = __importDefault(require("./providers/MemoryOnlyProvider"));
+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 = MemoryOnlyProvider_1.default;
+}
+/**
+ * Runs a piece of code and degrades performance if certain errors are thrown
+ */
+function tryOrDegradePerformance(fn, waitForInitialization = true) {
+    return new Promise((resolve, reject) => {
+        const promise = waitForInitialization ? initPromise : Promise.resolve();
+        promise.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);
+                    }
+                    // catch the error if DB connection can not be established/DB can not be created
+                    if (error.message.includes('IDBKeyVal store could not be created')) {
+                        degradePerformance(error);
+                    }
+                }
+                reject(error);
+            }
+        });
+    });
+}
+const Storage = {
+    /**
+     * Returns the storage provider currently in use
+     */
+    getStorageProvider() {
+        return provider;
+    },
+    /**
+     * Initializes all providers in the list of storage providers
+     * and enables fallback providers if necessary
+     */
+    init() {
+        tryOrDegradePerformance(provider.init, false).finally(() => {
+            finishInitalization();
+        });
+    },
+    /**
+     * Get the value of a given key or return `null` if it's not available
+     */
+    getItem: (key) => tryOrDegradePerformance(() => provider.getItem(key)),
+    /**
+     * Get multiple key-value pairs for the give array of keys in a batch
+     */
+    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) => 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) => tryOrDegradePerformance(() => provider.multiSet(pairs)),
+    /**
+     * Merging an existing value with a new one
+     */
+    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) => tryOrDegradePerformance(() => provider.multiMerge(pairs)),
+    /**
+     * Removes given key and its value
+     */
+    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) => tryOrDegradePerformance(() => {
+        const promise = provider.removeItems(keys);
+        if (shouldKeepInstancesSync) {
+            return promise.then(() => InstanceSync_1.default.removeItems(keys));
+        }
+        return promise;
+    }),
+    /**
+     * Clears everything
+     */
+    clear: () => tryOrDegradePerformance(() => {
+        if (shouldKeepInstancesSync) {
+            return InstanceSync_1.default.clear(() => provider.clear());
+        }
+        return provider.clear();
+    }),
+    /**
+     * Returns all available keys
+     */
+    getAllKeys: () => tryOrDegradePerformance(() => provider.getAllKeys()),
+    /**
+     * Gets the total bytes of the store
+     */
+    getDatabaseSize: () => tryOrDegradePerformance(() => provider.getDatabaseSize()),
+    /**
+     * @param onStorageKeyChanged - Storage synchronization mechanism keeping all opened tabs in sync (web only)
+     */
+    keepInstancesSync(onStorageKeyChanged) {
+        // If InstanceSync shouldn't be used, it means we're on a native platform and we don't need to keep instances in sync
+        if (!InstanceSync_1.default.shouldBeUsed)
+            return;
+        shouldKeepInstancesSync = true;
+        InstanceSync_1.default.init(onStorageKeyChanged, this);
+    },
+};
+exports.default = Storage;

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

@@ -0,0 +1,2 @@
+import WebStorage from '../providers/IDBKeyValProvider';
+export default WebStorage;

package/dist/storage/{NativeStorage.js → platforms/index.js}

@@ -3,5 +3,5 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-const SQLiteStorage_1 = __importDefault(require("./providers/SQLiteStorage"));
-exports.default = SQLiteStorage_1.default;
+const IDBKeyValProvider_1 = __importDefault(require("../providers/IDBKeyValProvider"));
+exports.default = IDBKeyValProvider_1.default;

package/dist/storage/platforms/index.native.d.ts

@@ -0,0 +1,2 @@
+import NativeStorage from '../providers/SQLiteProvider';
+export default NativeStorage;

package/dist/storage/{index.native.js → platforms/index.native.js}

@@ -3,5 +3,5 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-const NativeStorage_1 = __importDefault(require("./NativeStorage"));
-exports.default = NativeStorage_1.default;
+const SQLiteProvider_1 = __importDefault(require("../providers/SQLiteProvider"));
+exports.default = SQLiteProvider_1.default;

package/dist/storage/providers/{IDBKeyVal.js → IDBKeyValProvider.js}

@@ -7,24 +7,30 @@ const idb_keyval_1 = require("idb-keyval");
 const utils_1 = __importDefault(require("../../utils"));
 // We don't want to initialize the store while the JS bundle loads as idb-keyval will try to use global.indexedDB
 // which might not be available in certain environments that load the bundle (e.g. electron main process).
-let customStoreInstance;
-function getCustomStore() {
-    if (!customStoreInstance) {
-        customStoreInstance = (0, idb_keyval_1.createStore)('OnyxDB', 'keyvaluepairs');
-    }
-    return customStoreInstance;
-}
+let idbKeyValStore;
 const provider = {
-    setItem: (key, value) => (0, idb_keyval_1.set)(key, value, getCustomStore()),
-    multiGet: (keysParam) => (0, idb_keyval_1.getMany)(keysParam, getCustomStore()).then((values) => values.map((value, index) => [keysParam[index], value])),
-    multiMerge: (pairs) => getCustomStore()('readwrite', (store) => {
+    /**
+     * The name of the provider that can be printed to the logs
+     */
+    name: 'IDBKeyValProvider',
+    /**
+     * Initializes the storage provider
+     */
+    init() {
+        const newIdbKeyValStore = (0, idb_keyval_1.createStore)('OnyxDB', 'keyvaluepairs');
+        if (newIdbKeyValStore == null)
+            throw Error('IDBKeyVal store could not be created');
+        idbKeyValStore = newIdbKeyValStore;
+    },
+    setItem: (key, value) => (0, idb_keyval_1.set)(key, value, idbKeyValStore),
+    multiGet: (keysParam) => (0, idb_keyval_1.getMany)(keysParam, idbKeyValStore).then((values) => values.map((value, index) => [keysParam[index], value])),
+    multiMerge: (pairs) => idbKeyValStore('readwrite', (store) => {
         // Note: we are using the manual store transaction here, to fit the read and update
         // of the items in one transaction to achieve best performance.
         const getValues = Promise.all(pairs.map(([key]) => (0, idb_keyval_1.promisifyRequest)(store.get(key))));
         return getValues.then((values) => {
             const upsertMany = pairs.map(([key, value], index) => {
                 const prev = values[index];
-                // eslint-disable-next-line @typescript-eslint/no-explicit-any
                 const newValue = utils_1.default.fastMerge(prev, value);
                 return (0, idb_keyval_1.promisifyRequest)(store.put(newValue, key));
             });
@@ -35,16 +41,14 @@ const provider = {
         // Since Onyx also merged the existing value with the changes, we can just set the value directly
         return provider.setItem(key, modifiedData);
     },
-    multiSet: (pairs) => (0, idb_keyval_1.setMany)(pairs, getCustomStore()),
-    clear: () => (0, idb_keyval_1.clear)(getCustomStore()),
-    // eslint-disable-next-line @typescript-eslint/no-empty-function
-    setMemoryOnlyKeys: () => { },
-    getAllKeys: () => (0, idb_keyval_1.keys)(getCustomStore()),
-    getItem: (key) => (0, idb_keyval_1.get)(key, getCustomStore())
+    multiSet: (pairs) => (0, idb_keyval_1.setMany)(pairs, idbKeyValStore),
+    clear: () => (0, idb_keyval_1.clear)(idbKeyValStore),
+    getAllKeys: () => (0, idb_keyval_1.keys)(idbKeyValStore),
+    getItem: (key) => (0, idb_keyval_1.get)(key, idbKeyValStore)
         // idb-keyval returns undefined for missing items, but this needs to return null so that idb-keyval does the same thing as SQLiteStorage.
         .then((val) => (val === undefined ? null : val)),
-    removeItem: (key) => (0, idb_keyval_1.del)(key, getCustomStore()),
-    removeItems: (keysParam) => (0, idb_keyval_1.delMany)(keysParam, getCustomStore()),
+    removeItem: (key) => (0, idb_keyval_1.del)(key, idbKeyValStore),
+    removeItems: (keysParam) => (0, idb_keyval_1.delMany)(keysParam, idbKeyValStore),
     getDatabaseSize() {
         if (!window.navigator || !window.navigator.storage) {
             throw new Error('StorageManager browser API unavailable');

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

@@ -0,0 +1,9 @@
+import type StorageProvider from './types';
+import type { OnyxKey, OnyxValue } from '../../types';
+type Store = Record<OnyxKey, OnyxValue<OnyxKey>>;
+declare let store: Store;
+declare const set: (key: OnyxKey, value: OnyxValue<OnyxKey>) => Promise<unknown>;
+declare const provider: StorageProvider;
+declare const setMockStore: (data: Store) => void;
+export default provider;
+export { store as mockStore, set as mockSet, setMockStore };