@buoy-gg/network 7.0.40 → 7.0.42

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

@@ -1,152 +1 @@
-"use strict";
-
-/**
- * Decide whether a request is overridden — the whole decision, in one pure
- * function.
- *
- * Pure on purpose: this is the piece worth unit-testing, and it runs inside the
- * app's own `XMLHttpRequest.send()`, so it must be cheap, total, and incapable
- * of throwing. Everything that could surprise (defaults, clamping, content-type
- * inference) is resolved HERE, so `applyToXhr` never makes a decision — it just
- * performs the outcome.
- */
-
-import { ruleMatches } from "./matchRule";
-import { STATUS_MAX, STATUS_MIN } from "./types";
-
-/**
- * Traffic that must never be overridden, whatever the user's rules say.
- *
- * A `*` pattern is a completely reasonable thing for a developer to write
- * ("break everything and see what the app does"), and without this it would
- * also break Buoy's own licence checks — turning "I tested an error state" into
- * "the dev tools stopped working and I don't know why". Metro/debugger traffic
- * is already excluded upstream by `networkListener.shouldIgnoreUrl`.
- */
-const NEVER_OVERRIDE = [/(^|\.)keygen\.sh/i, /^https?:\/\/(www\.)?buoy\.gg\/api\/license(\/|$)/i];
-function isProtectedUrl(url) {
-  return NEVER_OVERRIDE.some(pattern => pattern.test(url));
-}
-
-/**
- * Guess a `content-type` when the rule didn't set one.
- *
- * Getting this wrong is not cosmetic: a client that trusts the header (axios's
- * default transform, any `response.json()` wrapper) will hand the app a string
- * where it expected an object, and the override looks broken rather than the
- * header looking wrong.
- */
-function inferContentType(body) {
-  const trimmed = body.trim();
-  if (trimmed === "") return "text/plain; charset=utf-8";
-  if (trimmed.startsWith("{") || trimmed.startsWith("[")) {
-    try {
-      JSON.parse(trimmed);
-      return "application/json";
-    } catch {
-      // Looks like JSON, isn't. Fall through — mislabelling it would be worse.
-    }
-  }
-  return "text/plain; charset=utf-8";
-}
-function hasHeader(headers, name) {
-  const wanted = name.toLowerCase();
-  return Object.keys(headers).some(key => key.toLowerCase() === wanted);
-}
-
-/** Normalize a matched rule into the exact instructions the interceptor needs. */
-function toOutcome(rule) {
-  const delayMs = Math.max(0, rule.delayMs ?? 0);
-  if (rule.kind === "delay") {
-    return {
-      kind: "delay",
-      rule,
-      delayMs
-    };
-  }
-  if (rule.kind === "fail") {
-    return {
-      kind: "fail",
-      rule,
-      delayMs,
-      failKind: rule.failKind ?? "network"
-    };
-  }
-  const body = rule.body ?? "";
-  const headers = {
-    ...(rule.headers ?? {})
-  };
-  if (!hasHeader(headers, "content-type")) {
-    headers["content-type"] = inferContentType(body);
-  }
-  return {
-    kind: "respond",
-    rule,
-    delayMs,
-    // Clamped, not rejected: whatwg-fetch's Response constructor THROWS outside
-    // [200, 599], which would crash the app's own fetch instead of overriding
-    // it. The editor constrains the input; this guarantees it.
-    status: Math.min(STATUS_MAX, Math.max(STATUS_MIN, rule.status ?? 200)),
-    statusText: rule.statusText ?? "",
-    headers,
-    body
-  };
-}
-
-/** A rule that has burned through its `times` budget no longer applies. */
-export function isSpent(rule) {
-  return typeof rule.times === "number" && rule.hits >= rule.times;
-}
-
-/**
- * Is this rule in a phase where it should actually fire?
- *
- * Only `alternate` can answer no. It reads the CURRENT `seen` count, before
- * this match is recorded, so an untouched rule (`seen === 0`) lets the first
- * request through and overrides the second.
- */
-export function shouldApply(rule) {
-  if (!rule.alternate) return true;
-  return rule.seen % 2 === 1;
-}
-
-/**
- * The first enabled rule whose pattern covers this request, phase ignored.
- *
- * Separate from `resolveOverride` because an alternating rule has to advance
- * its phase on the requests it deliberately skips — the caller needs the rule
- * back even when the answer is "not this time".
- */
-export function findMatchingRule(url, method, rules) {
-  if (rules.length === 0) return null;
-  // Chrome skips OPTIONS too (`NetworkPersistenceManager.ts:953`). A faked
-  // preflight fails CORS in a way that looks nothing like the rule you wrote.
-  if (method.toUpperCase() === "OPTIONS") return null;
-  if (isProtectedUrl(url)) return null;
-  for (const rule of rules) {
-    if (!rule.enabled) continue;
-    if (isSpent(rule)) continue;
-    if (!ruleMatches(rule, url, method)) continue;
-    return rule;
-  }
-  return null;
-}
-
-/**
- * First ENABLED matching rule wins outright — no merging across rules.
- *
- * Chrome cascades header overrides from the most general path segment to the
- * most specific, but that only exists because its rules are directory-nested
- * files. A flat list with a cascade would be a rule whose effect you cannot see
- * by reading it, which is exactly the wrong trade on a phone screen.
- *
- * @param url    Full request URL, query string included.
- * @param method HTTP method as the caller sent it (case-insensitive).
- * @param rules  Ordered rule list; earlier entries win.
- */
-export function resolveOverride(url, method, rules) {
-  const rule = findMatchingRule(url, method, rules);
-  if (!rule || !shouldApply(rule)) return null;
-  return toOutcome(rule);
-}
-export { toOutcome };
+"use strict";import{ruleMatches as s}from"./matchRule";import{STATUS_MAX as a,STATUS_MIN as u}from"./types";const f=[/(^|\.)keygen\.sh/i,/^https?:\/\/(www\.)?buoy\.gg\/api\/license(\/|$)/i];function c(t){return f.some(n=>n.test(t))}function p(t){const n=t.trim();if(n==="")return"text/plain; charset=utf-8";if(n.startsWith("{")||n.startsWith("[")){try{JSON.parse(n);return"application/json"}catch{}}return"text/plain; charset=utf-8"}function d(t,n){const e=n.toLowerCase();return Object.keys(t).some(i=>i.toLowerCase()===e)}function o(t){const n=Math.max(0,t.delayMs??0);if(t.kind==="delay"){return{kind:"delay",rule:t,delayMs:n}}if(t.kind==="fail"){return{kind:"fail",rule:t,delayMs:n,failKind:t.failKind??"network"}}const e=t.body??"";const i={...t.headers??{}};if(!d(i,"content-type")){i["content-type"]=p(e)}return{kind:"respond",rule:t,delayMs:n,status:Math.min(a,Math.max(u,t.status??200)),statusText:t.statusText??"",headers:i,body:e}}export function isSpent(t){return typeof t.times==="number"&&t.hits>=t.times}export function shouldApply(t){if(!t.alternate)return true;return t.seen%2===1}export function findMatchingRule(t,n,e,i){if(e.length===0)return null;if(n.toUpperCase()==="OPTIONS")return null;if(c(t))return null;for(const r of e){if(!r.enabled)continue;if(isSpent(r))continue;if(!s(r,t,n,i))continue;return r}return null}export function resolveOverride(t,n,e,i){const r=findMatchingRule(t,n,e,i);if(!r||!shouldApply(r))return null;return o(r)}export{o as toOutcome};

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

@@ -1,86 +1 @@
-"use strict";
-
-import { TIER_LIMITS } from "@buoy-gg/shared-ui";
-
-/**
- * Network response overrides — the rule model.
- *
- * This is Buoy's answer to Chrome DevTools' "Local Overrides", reshaped for
- * mobile. Two deliberate differences from Chrome are worth knowing, because
- * they explain the whole shape of this file:
- *
- * 1. Chrome's rules ARE a directory tree — a body override is a file at
- *    `<host>/<path>`, header overrides live in per-directory `.headers` files,
- *    and its general→specific header cascade exists only to hang off that
- *    nesting. We have no filesystem, so rules are a flat ordered list and the
- *    FIRST enabled match wins outright. That's what Charles/Proxyman/MSW do,
- *    and it's what a developer can reason about on a phone screen.
- *
- * 2. Chrome CANNOT change a status code. `NetworkManager.ts` computes
- *    `responseCode = isBodyOverridden ? 200 : (responseStatusCode || 200)`, so
- *    overriding a body forces 200, and there is no latency or failure
- *    simulation at all. Chrome's feature is "serve different bytes". Forcing a
- *    500, a timeout or a 3s stall is the entire mobile use case, so `status`,
- *    `delayMs` and `kind: "fail"` below are the point of the exercise.
- */
-
-/**
- * What a rule does when it matches.
- *
- * - `respond` — synthesize a response. The request never leaves the device.
- * - `fail`    — synthesize a transport failure (offline / timeout). Also never
- *               leaves the device.
- * - `delay`   — let the real request run, just late. Pure latency injection.
- */
-
-/**
- * Which transport failure to fake.
- *
- * `network` surfaces the way a real offline request does — `fetch` rejects with
- * `TypeError: Network request failed`. This is also how you simulate "status 0":
- * you can't, via `respond`, because whatwg-fetch's `Response` constructor throws
- * a RangeError outside 200–599 (see STATUS_MIN/STATUS_MAX).
- */
-
-/**
- * Status codes a synthesized response may use.
- *
- * NOT an arbitrary product decision: React Native's `fetch` is the whatwg-fetch
- * polyfill, whose `Response` constructor throws
- * `RangeError: The status provided is outside the range [200, 599]`. A rule set
- * to 0 would therefore crash the app's own fetch call rather than override it.
- * Use `kind: "fail"` for connection-level failures.
- */
-export const STATUS_MIN = 200;
-export const STATUS_MAX = 599;
-
-/** Bounds the persisted list so a runaway UI can't fill storage. */
-export const MAX_RULES = 50;
-
-/**
- * @deprecated Read the live limit with `useLimit("network.overrideRules")` —
- * this only reports the FREE tier's value. Kept because it is part of the
- * package's public exports.
- */
-export const FREE_TIER_RULE_LIMIT = TIER_LIMITS["network.overrideRules"].free;
-
-/**
- * Stamped onto the `NetworkEvent` a rule affected, so the list can badge the
- * row and the detail view can offer "edit / disable the rule that did this".
- */
-
-/**
- * A matched rule, normalized into exactly what the interceptor needs — defaults
- * resolved, status clamped, content-type inferred. Keeping normalization in the
- * resolver means `applyToXhr` never has to make a decision.
- */
-
-/** The marker recorded for an outcome. */
-export function markForOutcome(outcome) {
-  return {
-    ruleId: outcome.rule.id,
-    ruleName: outcome.rule.name,
-    kind: outcome.kind,
-    delayMs: outcome.delayMs || undefined
-  };
-}
+"use strict";import{TIER_LIMITS as r}from"@buoy-gg/shared-ui";export const STATUS_MIN=200;export const STATUS_MAX=599;export const MAX_RULES=50;export const FREE_TIER_RULE_LIMIT=r["network.overrideRules"].free;export function markForOutcome(e){return{ruleId:e.rule.id,ruleName:e.rule.name,kind:e.kind,delayMs:e.delayMs||void 0}}

package/lib/module/network/sync/networkBodyResolver.js

@@ -1,34 +1 @@
-"use strict";
-
-import { createContext, useContext } from "react";
-
-/**
- * The full request/response bodies for a single network event, fetched on
- * demand. Either field may be `null` when the event genuinely has no body.
- */
-
-/**
- * Resolves request/response bodies that were omitted from a synced snapshot.
- *
- * Large bodies (see `networkSyncAdapter`) are stripped from the list snapshot
- * so they aren't re-streamed every ~200ms; the detail view fetches them lazily
- * through this resolver when a request is opened.
- *
- * On the device this is never provided — bodies are always inline — so the
- * detail view simply falls back to the inline data. The desktop dashboard
- * provides a resolver that fetches the body over the devtool protocol.
- */
-import { jsx as _jsx } from "react/jsx-runtime";
-const NetworkBodyResolverContext = /*#__PURE__*/createContext(null);
-export function NetworkBodyResolverProvider({
-  resolver,
-  children
-}) {
-  return /*#__PURE__*/_jsx(NetworkBodyResolverContext.Provider, {
-    value: resolver,
-    children: children
-  });
-}
-export function useNetworkBodyResolver() {
-  return useContext(NetworkBodyResolverContext);
-}
+"use strict";import{createContext as t,useContext as n}from"react";import{jsx as s}from"react/jsx-runtime";const e=t(null);export function NetworkBodyResolverProvider({resolver:o,children:r}){return s(e.Provider,{value:o,children:r})}export function useNetworkBodyResolver(){return n(e)}