@buoy-gg/network 7.0.13 → 7.0.15

package/lib/module/network/components/response-editor/deleteNestedDataByPath.js

@@ -0,0 +1,51 @@
+"use strict";
+
+/**
+ * Deletes nested data by path
+ *
+ * @param {unknown} oldData Data to be updated
+ * @param {Array<string>} deletePath Path to the data to be deleted
+ * @returns newData without the deleted items by path
+ */
+export const deleteNestedDataByPath = (oldData, deletePath) => {
+  if (oldData instanceof Map) {
+    const newData = new Map(oldData);
+    if (deletePath.length === 1) {
+      newData.delete(deletePath[0]);
+      return newData;
+    }
+    const [head, ...tail] = deletePath;
+    newData.set(head, deleteNestedDataByPath(newData.get(head), tail));
+    return newData;
+  }
+  if (oldData instanceof Set) {
+    const setAsArray = deleteNestedDataByPath(Array.from(oldData), deletePath);
+    return new Set(setAsArray);
+  }
+  if (Array.isArray(oldData)) {
+    const newData = [...oldData];
+    if (deletePath.length === 1) {
+      return newData.filter((_, idx) => idx.toString() !== deletePath[0]);
+    }
+    const [head, ...tail] = deletePath;
+
+    // @ts-expect-error NAS
+    newData[head] = deleteNestedDataByPath(newData[head], tail);
+    return newData;
+  }
+  if (oldData instanceof Object) {
+    const newData = {
+      ...oldData
+    };
+    if (deletePath.length === 1) {
+      // @ts-expect-error NAS
+      delete newData[deletePath[0]];
+      return newData;
+    }
+    const [head, ...tail] = deletePath;
+    // @ts-expect-error NAS
+    newData[head] = deleteNestedDataByPath(newData[head], tail);
+    return newData;
+  }
+  return oldData;
+};

package/lib/module/network/components/response-editor/editorContext.js

@@ -0,0 +1,29 @@
+"use strict";
+
+import { createContext, useContext } from "react";
+
+/**
+ * What the ported Explorer needs in place of React Query's cache.
+ *
+ * In the original, every edit ends at
+ * `queryClient.setQueryData(activeQuery.queryKey, newData)` and `activeQuery`
+ * doubles as the "is this editable" gate — so the whole tree is wired to one
+ * specific store. Here that becomes two values in context: the ROOT document
+ * (every op rebuilds the whole thing from the root, so each row needs it) and a
+ * single `onChange`.
+ *
+ * Context rather than props because Explorer recurses per node and already
+ * threads `activeQuery` down every level; swapping one drilled prop for another
+ * would have meant the same plumbing at every call site, and a row deep in a
+ * response is exactly where you don't want a missed prop.
+ */
+
+export const ResponseEditorContext = /*#__PURE__*/createContext(null);
+
+/**
+ * Null outside a provider, which is how the tree stays READ-ONLY by default —
+ * the same role `activeQuery === undefined` played in the original.
+ */
+export function useResponseEditor() {
+  return useContext(ResponseEditorContext);
+}

package/lib/module/network/components/response-editor/updateNestedDataByPath.js

@@ -0,0 +1,56 @@
+"use strict";
+
+/**
+ * updates nested data by path
+ *
+ * @param {JsonValue} oldData Data to be updated
+ * @param {Array<string>} updatePath Path to the data to be updated
+ * @param {JsonValue} value New value
+ */
+export const updateNestedDataByPath = (oldData, updatePath, value) => {
+  if (updatePath.length === 0) {
+    return value;
+  }
+  if (oldData instanceof Map) {
+    const newData = new Map(oldData);
+    if (updatePath.length === 1) {
+      newData.set(updatePath[0], value);
+      return newData;
+    }
+    const [head, ...tail] = updatePath;
+    const currentValue = newData.get(head);
+    newData.set(head, updateNestedDataByPath(currentValue ?? null, tail, value));
+    return newData;
+  }
+  if (oldData instanceof Set) {
+    const setAsArray = updateNestedDataByPath(Array.from(oldData), updatePath, value);
+    return new Set(Array.isArray(setAsArray) ? setAsArray : []);
+  }
+  if (Array.isArray(oldData)) {
+    const newData = [...oldData];
+    if (updatePath.length === 1) {
+      // @ts-expect-error NAS
+      newData[updatePath[0]] = value;
+      return newData;
+    }
+    const [head, ...tail] = updatePath;
+    // @ts-expect-error NAS
+    newData[head] = updateNestedDataByPath(newData[head], tail, value);
+    return newData;
+  }
+  if (oldData instanceof Object) {
+    const newData = {
+      ...oldData
+    };
+    if (updatePath.length === 1) {
+      // @ts-expect-error NAS
+      newData[updatePath[0]] = value;
+      return newData;
+    }
+    const [head, ...tail] = updatePath;
+    // @ts-expect-error NAS
+    newData[head] = updateNestedDataByPath(newData[head], tail, value);
+    return newData;
+  }
+  return oldData;
+};

package/lib/module/network/hooks/useOverrideRules.js

@@ -0,0 +1,32 @@
+"use strict";
+
+import { useCallback, useSyncExternalStore } from "react";
+import { overrideRulesStore } from "../overrides/overrideRulesStore";
+import { isSpent } from "../overrides/resolveOverride";
+/**
+ * Read + mutate the override rule list.
+ *
+ * `useSyncExternalStore` over the store's own subscribe/getState, which already
+ * hands out a stable state object per mutation (see `rebuild`) — so this can't
+ * tear and doesn't need a selector to stay cheap.
+ */
+export function useOverrideRules() {
+  const state = useSyncExternalStore(useCallback(listener => overrideRulesStore.subscribe(listener), []), () => overrideRulesStore.getState(), () => overrideRulesStore.getState());
+  const setEnabled = useCallback(enabled => overrideRulesStore.setEnabled(enabled), []);
+  const upsertRule = useCallback(draft => overrideRulesStore.upsertRule(draft), []);
+  const setRuleEnabled = useCallback((id, enabled) => overrideRulesStore.setRuleEnabled(id, enabled), []);
+  const removeRule = useCallback(id => overrideRulesStore.removeRule(id), []);
+  const clearRules = useCallback(() => overrideRulesStore.clearRules(), []);
+  return {
+    enabled: state.enabled,
+    rules: state.rules,
+    autoPaused: state.autoPaused,
+    activeCount: overrideRulesStore.activeCount(),
+    setEnabled,
+    upsertRule,
+    setRuleEnabled,
+    removeRule,
+    clearRules,
+    isRuleSpent: isSpent
+  };
+}

package/lib/module/network/overrides/applyToFetch.js

@@ -0,0 +1,72 @@
+"use strict";
+
+/**
+ * Perform an override outcome against `fetch`.
+ *
+ * WHY THIS EXISTS — and why "XHR is the single choke point" is WRONG:
+ *
+ * In bare React Native, `Libraries/Network/fetch.js` is `require('whatwg-fetch')`,
+ * so `fetch` really is a polyfill over XMLHttpRequest and hooking XHR alone
+ * would cover everything. But **Expo replaces it**: `expo/src/winter/runtime.native.ts`
+ * installs `expo/fetch` — a NATIVE fetch over `ExpoFetchModule` — as
+ * `globalThis.fetch` unless `EXPO_PUBLIC_USE_RN_FETCH=1`. Those requests never
+ * construct an XMLHttpRequest, so an XHR-only override silently does nothing on
+ * the majority of real apps.
+ *
+ * Verified the hard way on Expo SDK 56 / RN 0.85.3: rule matched, engine
+ * healthy, interceptor installed, and the request still came back a real 200.
+ *
+ * So overrides hook BOTH layers. `axios` still needs the XHR path (it uses
+ * XMLHttpRequest on every platform), and this covers `fetch` on both flavours.
+ */
+
+export const sleep = ms => ms > 0 ? new Promise(resolve => setTimeout(resolve, ms)) : Promise.resolve();
+
+/**
+ * Can we build a `Response` in this runtime?
+ *
+ * React Native installs the whatwg-fetch `Response` global via `setUpXHR`, and
+ * Expo deliberately keeps it (it only swaps `fetch`). Feature-detected anyway:
+ * without it, the honest thing is to let the request run for real.
+ */
+export function canSynthesizeResponse() {
+  return typeof Response === "function";
+}
+
+/**
+ * Build the fake `Response` an overridden `fetch` resolves with.
+ *
+ * Note the status range: whatwg-fetch's `Response` constructor THROWS
+ * `RangeError` outside [200, 599], which would crash the caller instead of
+ * overriding it. `resolveOverride` clamps before we ever get here.
+ */
+export function synthesizeResponse(url, outcome) {
+  const response = new Response(outcome.body, {
+    status: outcome.status,
+    statusText: outcome.statusText,
+    headers: outcome.headers
+  });
+  // `Response.url` is not settable through the constructor, and consumers do
+  // read it (redirect checks, cache keys). whatwg-fetch stores it as a plain
+  // property, so assigning is both possible and correct.
+  try {
+    Object.defineProperty(response, "url", {
+      value: url,
+      configurable: true
+    });
+  } catch {
+    // Sealed implementation — an empty url is cosmetic, not worth failing over.
+  }
+  return response;
+}
+
+/**
+ * The error a failed `fetch` rejects with.
+ *
+ * These are the exact messages whatwg-fetch produces for a dead connection and
+ * a timeout, so app code that string-matches on them (plenty does) behaves the
+ * same way it would against a real failure.
+ */
+export function synthesizeFetchError(outcome) {
+  return new TypeError(outcome.failKind === "timeout" ? "Network request timed out" : "Network request failed");
+}

package/lib/module/network/overrides/applyToXhr.js

@@ -0,0 +1,185 @@
+"use strict";
+
+/**
+ * Perform an override outcome against a React Native XMLHttpRequest.
+ *
+ * WHY THIS IS POSSIBLE AT ALL: React Native's XMLHttpRequest
+ * (`react-native/Libraries/Network/XMLHttpRequest.js`) is pure JavaScript.
+ * `readyState`, `status`, `responseHeaders` and `responseURL` are plain
+ * writable fields, and `setResponseHeaders()` / `setReadyState()` are real
+ * methods — `setReadyState(DONE)` dispatches the correct terminal event off
+ * internal flags (`_aborted` → abort, `_hasError` + `_timedOut` → timeout,
+ * `_hasError` → error, otherwise load; always loadend). So a response can be
+ * synthesized end to end without touching native code.
+ *
+ * WHY XHR IS THE ONLY PLACE WE HOOK: `react-native/Libraries/Network/fetch.js`
+ * is `require('whatwg-fetch')` — RN's `fetch` IS the polyfill over
+ * XMLHttpRequest. Overriding here therefore covers `fetch`, `axios` and raw
+ * XHR through one code path, and the fake response flows back up through the
+ * polyfill so the tool records it without any extra plumbing.
+ *
+ * Verified field-for-field on React Native 0.81.4 and 0.85.3.
+ *
+ * Four non-obvious behaviours are handled below; each one is a real bug if you
+ * skip it, and each is commented at the line that fixes it.
+ */
+
+const HEADERS_RECEIVED = 2;
+const LOADING = 3;
+const DONE = 4;
+
+/**
+ * The private surface of RN's XMLHttpRequest that we drive.
+ *
+ * Typed explicitly rather than reached for with `any` so that if a future React
+ * Native renames one of these, the compiler points at every use — and so the
+ * blast radius of "we depend on RN internals" is one interface.
+ */
+
+const internalsOf = xhr => xhr;
+let warnedUnsupported = false;
+
+/**
+ * Can this XMLHttpRequest be driven by hand?
+ *
+ * The whole technique rests on RN internals, so it is feature-detected rather
+ * than assumed: on a browser XMLHttpRequest (react-native-web) these methods
+ * don't exist and `status` is a read-only getter. There, overrides no-op and
+ * the request goes out for real — degraded, but never broken.
+ */
+export function canSynthesize(xhr) {
+  const internals = internalsOf(xhr);
+  return typeof internals.setReadyState === "function" && typeof internals.setResponseHeaders === "function";
+}
+function warnUnsupported() {
+  if (warnedUnsupported) return;
+  warnedUnsupported = true;
+  if (typeof __DEV__ !== "undefined" && __DEV__) {
+    console.warn("[Buoy] Network overrides need React Native's XMLHttpRequest and this " + "environment provides a different one — requests will run normally.");
+  }
+}
+
+/** Synthesize a successful response. */
+function respond(xhr, url, outcome) {
+  const internals = internalsOf(xhr);
+
+  // `_reset()` does `delete this.responseURL`, so `'responseURL' in xhr` is
+  // FALSE on a fresh request — and whatwg-fetch reads exactly that to populate
+  // `Response.url` (fetch.js:558). Without this line every overridden fetch
+  // response would silently carry `url: ""`.
+  internals.responseURL = url;
+  internals.status = outcome.status;
+  // RN has no `statusText` field at all (real requests report `undefined`), so
+  // this is a new own property. Harmless, and it makes the tool's list read
+  // correctly instead of showing a bare number.
+  internals.statusText = outcome.statusText;
+  internals.setResponseHeaders?.(outcome.headers);
+  // HEADERS_RECEIVED also stamps the interceptor's existing `_ttfb`, so an
+  // overridden request reports its injected latency like a real one.
+  internals.setReadyState?.(HEADERS_RECEIVED);
+  if (internals._aborted) return;
+
+  // whatwg-fetch sets `responseType = 'blob'` before every send
+  // (fetch.js:599-606), which would make RN's `response` getter demand a native
+  // Blob descriptor from BlobManager. But the polyfill reads the response
+  // exactly once — `'response' in xhr ? xhr.response : xhr.responseText`
+  // (fetch.js:559) — and never re-reads `responseType`. Handing back text is
+  // therefore both sufficient and strictly simpler: no Blob, no FileReader, no
+  // native round trip, and `.json()` becomes a synchronous JSON.parse.
+  //
+  // Assign the FIELD, not the property: the `responseType` setter throws once
+  // `_sent` is true (XMLHttpRequest.js:215), and we set `_sent` above.
+  internals._responseType = "text";
+  internals._response = outcome.body;
+  internals._cachedResponse = undefined; // force the getter to recompute
+  internals.setReadyState?.(LOADING);
+  if (internals._aborted) return;
+  internals.setReadyState?.(DONE); // dispatches 'load' then 'loadend'
+}
+
+/** Synthesize a transport failure — offline or timeout. */
+function fail(xhr, outcome) {
+  const internals = internalsOf(xhr);
+  const timedOut = outcome.failKind === "timeout";
+
+  // These two flags are the entire difference between the 'error' and
+  // 'timeout' events — see `setReadyState` in XMLHttpRequest.js. whatwg-fetch
+  // turns them into `TypeError: Network request failed` and
+  // `TypeError: Network request timed out` respectively, which is exactly what
+  // the app would see from a real dead connection.
+  internals._hasError = true;
+  internals._timedOut = timedOut;
+  internals._responseType = "text";
+  internals._response = timedOut ? "Request timed out (Buoy override)" : "Network request failed (Buoy override)";
+  internals._cachedResponse = undefined;
+  internals.setReadyState?.(DONE);
+}
+
+/**
+ * Apply an outcome to a request that has NOT been sent yet.
+ *
+ * Returns `false` when this environment can't be driven by hand, in which case
+ * the caller must send the request normally.
+ *
+ * @param passThrough Sends the real request. Only used by `kind: "delay"`.
+ */
+export function runOverride(xhr, url, outcome, passThrough) {
+  if (!canSynthesize(xhr)) {
+    warnUnsupported();
+    return false;
+  }
+  const internals = internalsOf(xhr);
+
+  // Claim the request as sent, for all three kinds.
+  //
+  // We skip RN's own `send()`, which is what normally sets this — and `abort()`
+  // branches on it: with `_sent` false it treats the request as never started,
+  // silently `_reset()`s, and dispatches NOTHING. The app's fetch promise would
+  // then never settle (a hang), and for a synthesized response our own timer
+  // would afterwards fire 'load' on a reset object, resolving a fetch the app
+  // had already aborted. Claiming it means abort() dispatches DONE + 'abort'
+  // and whatwg-fetch rejects with AbortError, as it should.
+  internals._sent = true;
+  if (outcome.kind !== "delay") {
+    // Buoy's own `open()` swizzle overwrites RN's private `_requestId` with a
+    // string id. RN normally clobbers it back with the native numeric id inside
+    // `send()` — which we're skipping — so it would survive here, and
+    // `abort()` would hand that string to `RCTNetworking.abortRequest()`.
+    // Nulling it makes abort a clean no-op on the native side.
+    internals._requestId = null;
+  }
+  let timer = null;
+  const onAbort = () => {
+    if (timer !== null) {
+      clearTimeout(timer);
+      timer = null;
+    }
+  };
+  xhr.addEventListener("abort", onAbort);
+  const fire = () => {
+    timer = null;
+    xhr.removeEventListener("abort", onAbort);
+    // The real guard. `_aborted` is set unconditionally by `abort()` and
+    // survives its `_reset()`, so this is true whether or not the 'abort' event
+    // was ever dispatched.
+    if (internals._aborted) return;
+    if (outcome.kind === "delay") {
+      // Hand the state machine back before RN's `send()` sees it: it throws
+      // 'Request has already been sent' on a truthy `_sent`.
+      internals._sent = false;
+      passThrough();
+      return;
+    }
+    if (outcome.kind === "fail") {
+      fail(xhr, outcome);
+      return;
+    }
+    respond(xhr, url, outcome);
+  };
+
+  // ALWAYS asynchronous, even at 0ms. Callers legitimately attach handlers
+  // after `send()` returns (axios does), and a synchronous response would fire
+  // 'load' before they exist.
+  timer = setTimeout(fire, outcome.delayMs);
+  return true;
+}

package/lib/module/network/overrides/engine.js

@@ -0,0 +1,64 @@
+"use strict";
+
+/**
+ * The seam between the interceptor and the rule store.
+ *
+ * It exists to keep the import graph acyclic: `networkListener` needs rules,
+ * and the rule store needs the listener (to keep the swizzle installed while a
+ * rule is active). Rather than have them import each other, the store REGISTERS
+ * itself here and the listener asks here. Both sides import only this leaf.
+ *
+ * It's also the single place the production gate lives — see `overrideForRequest`.
+ */
+
+import { findMatchingRule, shouldApply, toOutcome } from "./resolveOverride";
+let hooks = null;
+export function setOverrideHooks(next) {
+  hooks = next;
+}
+
+/**
+ * Diagnostics for the sync adapter's `debugOverrides` action.
+ *
+ * Reads the engine's own view of the world — crucially `hooks`, which is
+ * MODULE state here: if the interceptor and the rule store ever ended up with
+ * separate copies of this file, this is the only place that shows it.
+ */
+export function inspectEngine(url, method) {
+  return {
+    hooksInstalled: hooks !== null,
+    devFlag: typeof __DEV__ === "undefined" ? "undefined" : __DEV__,
+    ruleCount: hooks ? hooks.getRules().length : 0,
+    // Non-recording probe — a diagnostic must not burn a rule's `times` budget
+    // or nudge an alternating rule's phase.
+    matches: hooks ? findMatchingRule(url, method, hooks.getRules()) !== null : false
+  };
+}
+
+/**
+ * Resolve an override for one outgoing request, recording the hit.
+ *
+ * NEVER ACTIVE IN A PRODUCTION BUILD. A shipped app that synthesizes 500s or
+ * silently swallows requests is a catastrophe of a different order than a
+ * broken dev tool, so the gate is here — at the single entry point — rather
+ * than trusted to every call site.
+ */
+export function overrideForRequest(url, method) {
+  if (!hooks) return null;
+  // `__DEV__` is undefined outside React Native (unit tests, the desktop
+  // dashboard's bundle); only an explicit `false` — a real release build —
+  // disables overrides.
+  if (typeof __DEV__ !== "undefined" && !__DEV__) return null;
+  const rules = hooks.getRules();
+  if (rules.length === 0) return null;
+  const rule = findMatchingRule(url, method, rules);
+  if (!rule) return null;
+
+  // Phase is read BEFORE the match is recorded, so a fresh alternating rule
+  // (`seen === 0`) lets this first request through and takes the next one.
+  const applies = shouldApply(rule);
+  hooks.recordMatch(rule.id);
+  if (!applies) return null;
+  hooks.recordHit(rule.id);
+  return toOutcome(rule);
+}

package/lib/module/network/overrides/matchRule.js

@@ -0,0 +1,75 @@
+"use strict";
+
+/**
+ * Glob matching for override rules — a faithful port of Chrome DevTools'.
+ *
+ * Ported from `NetworkPersistenceManager.ts:1051` + `StringUtilities.ts:9` in
+ * the devtools-frontend source. Ported rather than reinvented on purpose: `*`
+ * globs are the syntax developers already have in their fingers from Chrome's
+ * "Override headers" `applyTo` field, and a pattern that behaves differently
+ * here than it does in the browser would be a quiet trap.
+ */
+
+/**
+ * Chrome's escape set, character for character.
+ *
+ * `*` is deliberately ABSENT — it survives escaping so it can become `.*`
+ * below. Everything else that means something to a regex is neutered.
+ */
+const SPECIAL_CHARACTERS = "[]{}()\\.^$+|-,?";
+
+/**
+ * Escape a glob into regex source: neutralize regex metacharacters, then
+ * promote `*` to `.*`.
+ *
+ * `split`/`join` rather than `replaceAll` — same result, no reliance on how
+ * complete a given Hermes build's ES2021 surface is.
+ */
+export function escapeRegex(pattern) {
+  let result = "";
+  for (let i = 0; i < pattern.length; i++) {
+    const char = pattern.charAt(i);
+    if (SPECIAL_CHARACTERS.indexOf(char) !== -1) {
+      result += "\\";
+    }
+    result += char;
+  }
+  return result.split("*").join(".*");
+}
+
+/**
+ * Compiled patterns, cached by source.
+ *
+ * `resolveOverride` runs on EVERY request the app makes, against every rule.
+ * Recompiling a RegExp per request per rule is pure waste in the one place
+ * this feature is allowed to cost nothing.
+ */
+const compiled = new Map();
+export function compilePattern(pattern) {
+  const cached = compiled.get(pattern);
+  if (cached) return cached;
+  // Anchored, like Chrome's `^${...}$` — a pattern describes the whole URL, so
+  // `pokeapi.co` matches nothing and `*pokeapi.co*` matches everything on that
+  // host. Predictable beats clever; the rule editor writes full URLs for you.
+  const regex = new RegExp(`^${escapeRegex(pattern)}$`);
+  // Unbounded growth isn't possible in practice (patterns come from a capped
+  // rule list), but a user editing a pattern character by character churns
+  // entries, so keep the cache from becoming a leak.
+  if (compiled.size > 200) compiled.clear();
+  compiled.set(pattern, regex);
+  return regex;
+}
+
+/** Does this rule apply to this request? Ignores `enabled` — callers check it. */
+export function ruleMatches(rule, url, method) {
+  if (rule.methods && rule.methods.length > 0) {
+    if (!rule.methods.includes(method.toUpperCase())) return false;
+  }
+  try {
+    return compilePattern(rule.urlPattern).test(url);
+  } catch {
+    // A pattern that can't compile matches nothing rather than throwing inside
+    // the app's `send()`. The rule editor validates; this is the backstop.
+    return false;
+  }
+}