react-native-onyx 3.0.117 → 3.0.119

package/API.md

@@ -63,6 +63,19 @@ Any existing collection members not included in the new data will be removed.</p
 Live RAM-only values and writes that have not reached storage are not included.
 Treat the returned object and its nested values as read-only.</p>
 </dd>
+<dt><a href="#get">get(key)</a> ⇒</dt>
+<dd><p>Reads the current value of an Onyx key once, without subscribing. Use <code>useOnyx()</code> or
+<code>Onyx.connectWithoutView()</code> when the value has to stay current.</p>
+<p>The read is served from the cache, which <code>init()</code> fills with the whole store, so it returns what a
+subscription to the same key would deliver. The value is the cached one rather than a copy, so treat
+it as read-only.</p>
+</dd>
+<dt><a href="#multiGet">multiGet(keys)</a> ⇒</dt>
+<dd><p>Reads several Onyx keys at once, without subscribing. Use <code>useOnyx()</code> or <code>Onyx.connectWithoutView()</code> when
+the values have to stay current.</p>
+<p>Values come back in the order of the keys given, and each is what get() returns for its key. To read a
+whole collection, pass the collection key rather than listing its members.</p>
+</dd>
 </dl>
 
 <a name="init"></a>
@@ -280,3 +293,49 @@ Live RAM-only values and writes that have not reached storage are not included.
 Treat the returned object and its nested values as read-only.
 
 **Kind**: global function  
+<a name="get"></a>
+
+## get(key) ⇒
+Reads the current value of an Onyx key once, without subscribing. Use `useOnyx()` or
+`Onyx.connectWithoutView()` when the value has to stay current.
+
+The read is served from the cache, which `init()` fills with the whole store, so it returns what a
+subscription to the same key would deliver. The value is the cached one rather than a copy, so treat
+it as read-only.
+
+**Kind**: global function  
+**Returns**: The current value, or `undefined` if the key has none.  
+
+| Param | Description |
+| --- | --- |
+| key | ONYXKEY to read, either a collection key or a single key |
+
+**Example**  
+```js
+const report = await Onyx.get(`${ONYXKEYS.COLLECTION.REPORT}${reportID}`);
+const allReports = await Onyx.get(ONYXKEYS.COLLECTION.REPORT);
+```
+<a name="multiGet"></a>
+
+## multiGet(keys) ⇒
+Reads several Onyx keys at once, without subscribing. Use `useOnyx()` or `Onyx.connectWithoutView()` when
+the values have to stay current.
+
+Values come back in the order of the keys given, and each is what get() returns for its key. To read a
+whole collection, pass the collection key rather than listing its members.
+
+**Kind**: global function  
+**Returns**: The values in the order of their keys, each `undefined` where a key has no value.  
+
+| Param | Description |
+| --- | --- |
+| keys | ONYXKEYS to read, in any mix of collection keys and single keys |
+
+**Example**  
+```js
+const [session, wallet, report] = await Onyx.multiGet([
+    ONYXKEYS.SESSION,
+    ONYXKEYS.WALLET,
+    `${ONYXKEYS.COLLECTION.REPORT}${reportID}`,
+]);
+```

package/dist/Onyx.d.ts

@@ -161,6 +161,42 @@ declare function setCollection<TKey extends CollectionKeyBase>(collectionKey: TK
  * Treat the returned object and its nested values as read-only.
  */
 declare function exportState(): Promise<Record<OnyxKey, OnyxValue<OnyxKey>>>;
+/**
+ * Reads the current value of an Onyx key once, without subscribing. Use `useOnyx()` or
+ * `Onyx.connectWithoutView()` when the value has to stay current.
+ *
+ * The read is served from the cache, which `init()` fills with the whole store, so it returns what a
+ * subscription to the same key would deliver. The value is the cached one rather than a copy, so treat
+ * it as read-only.
+ *
+ * @example
+ * const report = await Onyx.get(`${ONYXKEYS.COLLECTION.REPORT}${reportID}`);
+ * const allReports = await Onyx.get(ONYXKEYS.COLLECTION.REPORT);
+ *
+ * @param key ONYXKEY to read, either a collection key or a single key
+ * @returns The current value, or `undefined` if the key has none.
+ */
+declare function get<TKey extends OnyxKey>(key: TKey): Promise<OnyxValue<TKey>>;
+/**
+ * Reads several Onyx keys at once, without subscribing. Use `useOnyx()` or `Onyx.connectWithoutView()` when
+ * the values have to stay current.
+ *
+ * Values come back in the order of the keys given, and each is what get() returns for its key. To read a
+ * whole collection, pass the collection key rather than listing its members.
+ *
+ * @example
+ * const [session, wallet, report] = await Onyx.multiGet([
+ *     ONYXKEYS.SESSION,
+ *     ONYXKEYS.WALLET,
+ *     `${ONYXKEYS.COLLECTION.REPORT}${reportID}`,
+ * ]);
+ *
+ * @param keys ONYXKEYS to read, in any mix of collection keys and single keys
+ * @returns The values in the order of their keys, each `undefined` where a key has no value.
+ */
+declare function multiGet<const Keys extends readonly OnyxKey[]>(keys: Keys): Promise<{
+    [Index in keyof Keys]: OnyxValue<Keys[Index]>;
+}>;
 declare const Onyx: {
     METHOD: {
         readonly SET: "set";
@@ -182,6 +218,8 @@ declare const Onyx: {
     clear: typeof clear;
     exportState: typeof exportState;
     init: typeof init;
+    get: typeof get;
+    multiGet: typeof multiGet;
     registerLogger: typeof Logger.registerLogger;
 };
 export default Onyx;

package/dist/Onyx.js

@@ -473,6 +473,7 @@ function clear(keysToPreserve = []) {
                 .then(() => storage_1.default.multiSet(defaultKeyValuePairs))
                 .then(() => {
                 DevTools_1.default.clearState(keysToPreserve);
+                OnyxSubscriptionManager_1.default.resetCacheMissReports();
                 // Notify the subscribers for each key/value group so they can receive the new values
                 for (const [key, value] of Object.entries(keyValuesToResetIndividually)) {
                     OnyxUtils_1.default.notifyKey(key, value);
@@ -662,6 +663,45 @@ function exportState() {
         return state;
     }));
 }
+/**
+ * Reads the current value of an Onyx key once, without subscribing. Use `useOnyx()` or
+ * `Onyx.connectWithoutView()` when the value has to stay current.
+ *
+ * The read is served from the cache, which `init()` fills with the whole store, so it returns what a
+ * subscription to the same key would deliver. The value is the cached one rather than a copy, so treat
+ * it as read-only.
+ *
+ * @example
+ * const report = await Onyx.get(`${ONYXKEYS.COLLECTION.REPORT}${reportID}`);
+ * const allReports = await Onyx.get(ONYXKEYS.COLLECTION.REPORT);
+ *
+ * @param key ONYXKEY to read, either a collection key or a single key
+ * @returns The current value, or `undefined` if the key has none.
+ */
+function get(key) {
+    return OnyxUtils_1.default.afterInit(() => { var _a; return Promise.resolve(((_a = OnyxSubscriptionManager_1.default.getState(key)) !== null && _a !== void 0 ? _a : undefined)); });
+}
+/**
+ * Reads several Onyx keys at once, without subscribing. Use `useOnyx()` or `Onyx.connectWithoutView()` when
+ * the values have to stay current.
+ *
+ * Values come back in the order of the keys given, and each is what get() returns for its key. To read a
+ * whole collection, pass the collection key rather than listing its members.
+ *
+ * @example
+ * const [session, wallet, report] = await Onyx.multiGet([
+ *     ONYXKEYS.SESSION,
+ *     ONYXKEYS.WALLET,
+ *     `${ONYXKEYS.COLLECTION.REPORT}${reportID}`,
+ * ]);
+ *
+ * @param keys ONYXKEYS to read, in any mix of collection keys and single keys
+ * @returns The values in the order of their keys, each `undefined` where a key has no value.
+ */
+function multiGet(keys) {
+    // map() widens the key tuple to an array, so the per-slot value types survive only through the cast.
+    return OnyxUtils_1.default.afterInit(() => Promise.resolve(keys.map((key) => { var _a; return (_a = OnyxSubscriptionManager_1.default.getState(key)) !== null && _a !== void 0 ? _a : undefined; })));
+}
 const Onyx = {
     METHOD: OnyxUtils_1.default.METHOD,
     connect,
@@ -676,6 +716,8 @@ const Onyx = {
     clear,
     exportState,
     init,
+    get,
+    multiGet,
     registerLogger: Logger.registerLogger,
 };
 exports.default = Onyx;

package/dist/OnyxSubscriptionManager.d.ts

@@ -48,6 +48,7 @@ declare class OnyxSubscriptionManager {
      * Wipe all subscriptions. Used by tests and `Onyx.clear()` follow-on.
      */
     clearAll(): void;
+    resetCacheMissReports(): void;
     /**
      * True if there are any subscribers for the given key (exact or parent collection).
      */

package/dist/OnyxSubscriptionManager.js

@@ -39,6 +39,29 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const Logger = __importStar(require("./Logger"));
 const OnyxCache_1 = __importDefault(require("./OnyxCache"));
 const OnyxKeys_1 = __importDefault(require("./OnyxKeys"));
+const storage_1 = __importDefault(require("./storage"));
+const reportedCacheMisses = new Set();
+function reportCacheMissIfStorageHasValue(key) {
+    var _a;
+    if (OnyxKeys_1.default.isRamOnlyKey(key) || !OnyxCache_1.default.getAllKeys().has(key) || OnyxCache_1.default.hasNullishStorageKey(key)) {
+        return;
+    }
+    const reportKey = (_a = OnyxKeys_1.default.getCollectionKey(key)) !== null && _a !== void 0 ? _a : key;
+    if (reportedCacheMisses.has(reportKey)) {
+        return;
+    }
+    reportedCacheMisses.add(reportKey);
+    storage_1.default.getItem(key)
+        .then((value) => {
+        if (value === undefined || value === null) {
+            return;
+        }
+        Logger.logHmmm(`Cache held no value for a key storage still has: ${reportKey}`);
+    })
+        .catch((error) => {
+        Logger.logInfo(`Could not check storage for a suspected cache miss on ${reportKey}. Error: ${String(error)}`);
+    });
+}
 /**
  * OnyxSubscriptionManager is a registry for Onyx subscriptions.
  * Subscriptions are stored in `keyListeners`, a flat map keyed by OnyxKey.
@@ -58,7 +81,11 @@ class OnyxSubscriptionManager {
         if (OnyxKeys_1.default.isCollectionKey(key)) {
             return OnyxCache_1.default.getCollectionData(key);
         }
-        return OnyxCache_1.default.get(key);
+        const value = OnyxCache_1.default.get(key);
+        if (value === undefined) {
+            reportCacheMissIfStorageHasValue(key);
+        }
+        return value;
     }
     /**
      * Subscribe to an exact key. For a collection root key this is "collection mode": the
@@ -164,6 +191,10 @@ class OnyxSubscriptionManager {
      */
     clearAll() {
         this.keyListeners.clear();
+        this.resetCacheMissReports();
+    }
+    resetCacheMissReports() {
+        reportedCacheMisses.clear();
     }
     /**
      * True if there are any subscribers for the given key (exact or parent collection).

package/dist/storage/providers/IDBKeyValProvider/classifyError.js

@@ -31,6 +31,10 @@ function classifyIDBError(error) {
     if (message.includes('internal error opening backing store')) {
         return errors_1.StorageErrorClass.FATAL;
     }
+    // Chromium persistence failure with no cause attached, recovered by a fresh connection.
+    if (name === 'unknownerror' && message === 'internal error.') {
+        return errors_1.StorageErrorClass.FATAL;
+    }
     // Transient connection/transport failures — the cached connection is stale and a reopen fixes it:
     // - InvalidStateError: connection closed between getDB() resolving and db.transaction().
     // - AbortError: write transaction aborted (connection close / versionchange / sibling abort).

package/dist/storage/providers/IDBKeyValProvider/createStore.js

@@ -209,6 +209,7 @@ function createStore(dbName, storeName) {
             Logger.logInfo(`IDB heal: backing store error detected — dropping cached connection and reopening (${healAttemptsRemaining} attempts left)`, {
                 dbName,
                 storeName,
+                errorMessage: error instanceof Error ? error.message : String(error),
             });
             dbp = undefined;
             return executeTransaction(txMode, callback).then((result) => {

package/package.json

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