react-native-onyx 3.0.101 → 3.0.103

package/dist/CircuitBreaker/AbstractCircuitBreaker.d.ts

@@ -4,7 +4,7 @@ import type { CircuitBreakerOptions, CircuitBreakerState } from './types';
  *
  * - **closed**: requests are allowed; failures are counted.
  * - **open**: requests are rejected until {@link resetTimeoutMs} elapses.
- * - **half-open**: the recovery-probe state. After the open timeout, the breaker admits exactly ONE
+ * - **halfOpen**: the recovery-probe state. After the open timeout, the breaker admits exactly ONE
  *   probe request: success means the dependency recovered, so the circuit closes. Failure means it's
  *   still down, so the circuit reopens. This single-request probe prevents a "thundering herd" where
  *   every caller fails loudly when the service hasn't recovered yet.
@@ -51,23 +51,23 @@ declare abstract class AbstractCircuitBreaker {
     /**
      * Whether a request may proceed.
      *
-     * Returns `false` while open. In half-open, the FIRST caller is admitted as the recovery probe and
+     * Returns `false` while open. In halfOpen, the FIRST caller is admitted as the recovery probe and
      * `isProbeInFlight` is latched so every subsequent caller is rejected until that probe resolves
      * (via {@link recordSuccess} → close, or {@link recordFailure} → reopen). That single-probe gate is
-     * the whole point of half-open: it tests recovery with one request instead of letting a herd of
+     * the whole point of halfOpen: it tests recovery with one request instead of letting a herd of
      * waiting callers stampede a dependency that may still be down.
      */
     isAllowed(): boolean;
     /**
-     * Record a failed request. May open the circuit from closed or half-open.
+     * Record a failed request. May open the circuit from closed or halfOpen.
      * @returns `true` when the circuit is open after recording (the request must not proceed).
      */
     recordFailure(): boolean;
-    /** Record a successful request. Closes the circuit from half-open and clears failure counts. */
+    /** Record a successful request. Closes the circuit from halfOpen and clears failure counts. */
     recordSuccess(): void;
     /**
      * The current state WITHOUT advancing recovery — a pure query, safe to call without side effects.
-     * The open→half-open transition is applied only at the admission point ({@link isAllowed}); by the
+     * The open→halfOpen transition is applied only at the admission point ({@link isAllowed}); by the
      * time a caller queries state after being admitted, that transition has already happened.
      */
     peekState(): CircuitBreakerState;
@@ -81,9 +81,9 @@ declare abstract class AbstractCircuitBreaker {
     private trip;
     private close;
     /**
-     * Lazily advance open → half-open once the reset timeout has elapsed. This is checked on read
+     * Lazily advance open → halfOpen once the reset timeout has elapsed. This is checked on read
      * (via {@link getCurrentState}) rather than on a timer, so there's nothing to schedule or clean up:
-     * the transition simply becomes visible to the next caller after the window. Entering half-open
+     * the transition simply becomes visible to the next caller after the window. Entering halfOpen
      * clears `isProbeInFlight` so the next admitted request becomes the recovery probe.
      */
     private maybeRecover;

package/dist/CircuitBreaker/AbstractCircuitBreaker.js

@@ -10,7 +10,7 @@ const types_1 = require("./types");
  *
  * - **closed**: requests are allowed; failures are counted.
  * - **open**: requests are rejected until {@link resetTimeoutMs} elapses.
- * - **half-open**: the recovery-probe state. After the open timeout, the breaker admits exactly ONE
+ * - **halfOpen**: the recovery-probe state. After the open timeout, the breaker admits exactly ONE
  *   probe request: success means the dependency recovered, so the circuit closes. Failure means it's
  *   still down, so the circuit reopens. This single-request probe prevents a "thundering herd" where
  *   every caller fails loudly when the service hasn't recovered yet.
@@ -53,10 +53,10 @@ class AbstractCircuitBreaker {
     /**
      * Whether a request may proceed.
      *
-     * Returns `false` while open. In half-open, the FIRST caller is admitted as the recovery probe and
+     * Returns `false` while open. In halfOpen, the FIRST caller is admitted as the recovery probe and
      * `isProbeInFlight` is latched so every subsequent caller is rejected until that probe resolves
      * (via {@link recordSuccess} → close, or {@link recordFailure} → reopen). That single-probe gate is
-     * the whole point of half-open: it tests recovery with one request instead of letting a herd of
+     * the whole point of halfOpen: it tests recovery with one request instead of letting a herd of
      * waiting callers stampede a dependency that may still be down.
      */
     isAllowed() {
@@ -64,7 +64,7 @@ class AbstractCircuitBreaker {
         if (currentState === 'open') {
             return false;
         }
-        if (currentState === 'half-open') {
+        if (currentState === 'halfOpen') {
             if (this.isProbeInFlight) {
                 return false;
             }
@@ -73,14 +73,14 @@ class AbstractCircuitBreaker {
         return true;
     }
     /**
-     * Record a failed request. May open the circuit from closed or half-open.
+     * Record a failed request. May open the circuit from closed or halfOpen.
      * @returns `true` when the circuit is open after recording (the request must not proceed).
      */
     recordFailure() {
         if (this.machine.state === 'open') {
             return true;
         }
-        if (this.machine.state === 'half-open') {
+        if (this.machine.state === 'halfOpen') {
             this.trip();
             return true;
         }
@@ -91,9 +91,9 @@ class AbstractCircuitBreaker {
         }
         return false;
     }
-    /** Record a successful request. Closes the circuit from half-open and clears failure counts. */
+    /** Record a successful request. Closes the circuit from halfOpen and clears failure counts. */
     recordSuccess() {
-        if (this.machine.state === 'half-open') {
+        if (this.machine.state === 'halfOpen') {
             this.close();
             return;
         }
@@ -103,7 +103,7 @@ class AbstractCircuitBreaker {
     }
     /**
      * The current state WITHOUT advancing recovery — a pure query, safe to call without side effects.
-     * The open→half-open transition is applied only at the admission point ({@link isAllowed}); by the
+     * The open→halfOpen transition is applied only at the admission point ({@link isAllowed}); by the
      * time a caller queries state after being admitted, that transition has already happened.
      */
     peekState() {
@@ -137,7 +137,7 @@ class AbstractCircuitBreaker {
     }
     close() {
         var _a;
-        // close() only ever runs from half-open (see recordSuccess), and half-open → closed is the one
+        // close() only ever runs from halfOpen (see recordSuccess), and halfOpen → closed is the one
         // legal closing transition — so go through transition() to keep the illegal open → closed jump
         // an error rather than silently constructing a fresh closed machine.
         this.machine = this.machine.transition('closed');
@@ -147,9 +147,9 @@ class AbstractCircuitBreaker {
         (_a = this.onClose) === null || _a === void 0 ? void 0 : _a.call(this);
     }
     /**
-     * Lazily advance open → half-open once the reset timeout has elapsed. This is checked on read
+     * Lazily advance open → halfOpen once the reset timeout has elapsed. This is checked on read
      * (via {@link getCurrentState}) rather than on a timer, so there's nothing to schedule or clean up:
-     * the transition simply becomes visible to the next caller after the window. Entering half-open
+     * the transition simply becomes visible to the next caller after the window. Entering halfOpen
      * clears `isProbeInFlight` so the next admitted request becomes the recovery probe.
      */
     maybeRecover() {
@@ -159,7 +159,7 @@ class AbstractCircuitBreaker {
         if (Date.now() - this.openedAt < this.resetTimeoutMs) {
             return;
         }
-        this.machine = this.machine.transition('half-open');
+        this.machine = this.machine.transition('halfOpen');
         this.isProbeInFlight = false;
     }
 }

package/dist/CircuitBreaker/types.d.ts

@@ -5,7 +5,7 @@
  * - **open**: tripped; requests are rejected outright so a known-bad dependency isn't hammered.
  * - **half-open**: a trial state entered after the open timeout — see {@link CIRCUIT_BREAKER_TRANSITIONS}.
  */
-type CircuitBreakerState = 'closed' | 'open' | 'half-open';
+type CircuitBreakerState = 'closed' | 'open' | 'halfOpen';
 /**
  * Legal state transitions. The flow is closed → open → half-open → (closed | open).
  *
@@ -23,8 +23,8 @@ type CircuitBreakerState = 'closed' | 'open' | 'half-open';
  */
 declare const CIRCUIT_BREAKER_TRANSITIONS: {
     readonly closed: readonly ["open"];
-    readonly open: readonly ["half-open"];
-    readonly 'half-open': readonly ["closed", "open"];
+    readonly open: readonly ["halfOpen"];
+    readonly halfOpen: readonly ["closed", "open"];
 };
 type CircuitBreakerOptions = {
     /** Time in milliseconds the circuit stays open before moving to half-open. */

package/dist/CircuitBreaker/types.js

@@ -18,7 +18,7 @@ exports.CIRCUIT_BREAKER_TRANSITIONS = void 0;
  */
 const CIRCUIT_BREAKER_TRANSITIONS = {
     closed: ['open'],
-    open: ['half-open'],
-    'half-open': ['closed', 'open'],
+    open: ['halfOpen'],
+    halfOpen: ['closed', 'open'],
 };
 exports.CIRCUIT_BREAKER_TRANSITIONS = CIRCUIT_BREAKER_TRANSITIONS;

package/dist/OnyxUtils.js

@@ -1020,13 +1020,28 @@ function updateSnapshots(data, mergeFn) {
         return [];
     const promises = [];
     const snapshotCollection = getCachedCollection(snapshotCollectionKey);
+    // Multiset entries are keyless but update every key of their payload, so expand them into
+    // per-key entries to keep cached snapshots in sync with the real Onyx data.
+    const flattenedData = data.flatMap((entry) => {
+        if (entry.onyxMethod === METHOD.MULTI_SET && typeof entry.key !== 'string' && entry.value && typeof entry.value === 'object' && !Array.isArray(entry.value)) {
+            return Object.entries(entry.value).map(([key, value]) => ({ onyxMethod: METHOD.SET, key, value }));
+        }
+        return entry;
+    });
     for (const [snapshotEntryKey, snapshotEntryValue] of Object.entries(snapshotCollection)) {
         // Snapshots may not be present in cache. We don't know how to update them so we skip.
         if (!snapshotEntryValue) {
             continue;
         }
         let updatedData = {};
-        for (const { key, value } of data) {
+        for (const { key, value, onyxMethod } of flattenedData) {
+            if (typeof key !== 'string') {
+                // clear entries legitimately carry no key, and malformed multiset payloads are already logged by update() itself
+                if (onyxMethod !== METHOD.CLEAR && onyxMethod !== METHOD.MULTI_SET) {
+                    Logger.logHmmm(`Invalid ${typeof key} key (method: ${onyxMethod}, key: ${String(key).slice(0, 50)}) provided in Onyx update. Skipping snapshot update for this entry.`);
+                }
+                continue;
+            }
             // snapshots are normal keys so we want to skip update if they are written to Onyx
             if (OnyxKeys_1.default.isCollectionMemberKey(snapshotCollectionKey, key)) {
                 continue;

package/dist/StorageCircuitBreaker.js

@@ -97,7 +97,7 @@ class StorageCircuitBreaker extends AbstractCircuitBreaker_1.default {
         // failure that triggered it must not re-trip the circuit. Let it proceed; the probe's outcome
         // is the verdict — recordWriteSuccess (retry landed) closes, recordProbeFailure (retry failed,
         // re-entering retryOperation) reopens.
-        if (this.peekState() === 'half-open') {
+        if (this.peekState() === 'halfOpen') {
             return false;
         }
         return this.recordFailure();

package/package.json

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