fix(web): contain flight-data collector errors per source

Co-authored-by: Cursor <cursoragent@cursor.com>

Author: ryansolid

.changeset/contain-flight-collector-errors.md

@@ -0,0 +1,5 @@
+---
+"@solidjs/web": patch
+---
+
+Contain flight-data collector errors per source: a throwing collector no longer fails the mutation response (the client received an error for a mutation that succeeded) or drop the other sources' slices — the failing source is simply omitted and logged.

packages/web/server-functions/src/server.ts

@@ -1025,8 +1025,17 @@ async function foldFlightData(hooks, event, headers, outcome, context = {}) {
   digestOutcome(event, outcome);
   const folded = [];
   for (const [source, hook] of hooks) {
-    const slice = await hook(event, outcome);
-    if (slice !== undefined) folded.push([source, slice]);
+    // Contained per source: one cache's collector failing must not cost the
+    // mutation's outcome or the other caches' slices — without this, a
+    // thrown hook falls into the handler's outer catch and the client
+    // receives an ERROR for a mutation that succeeded. A missing slice just
+    // means that cache revalidates the normal way.
+    try {
+      const slice = await hook(event, outcome);
+      if (slice !== undefined) folded.push([source, slice]);
+    } catch (error) {
+      console.error(`Error collecting flight data for source "${source}"`, error);
+    }
   }
   if (folded.length === 0) return outcome.value;
   const legacy = folded.length === 1 && folded[0][0] === "true";

packages/web/test/server/server-functions-single-flight.spec.tsx

@@ -163,6 +163,37 @@ describe("single-flight server bridge (built server bundle)", () => {
     }
   });
 
+  it("a throwing collector loses only its own slice", async () => {
+    registerServerFunction("sf-bridge-throw-0", async () => "mutated");
+    const unregisterBroken = registerFlightDataSource("broken", () => {
+      throw new Error("collector exploded");
+    });
+    const unregisterQuery = registerFlightDataSource("sq", () => ({ queries: ["fresh"] }));
+    const consoleError = vi.spyOn(console, "error").mockImplementation(() => {});
+    try {
+      const response = await handleServerFunctionRequest(
+        flightRequest("sf-bridge-throw-0", "broken,sq")
+      );
+      // The mutation's outcome and the healthy cache's slice both survive —
+      // a thrown hook must not fall into the handler's error path (the
+      // client would receive an error for a mutation that succeeded) or
+      // take the other sources down with it.
+      expect(response.headers.get(SINGLE_FLIGHT_HEADER)).toBe("sq");
+      expect(await decodeResponse(response)).toEqual({
+        value: "mutated",
+        data: { sq: { queries: ["fresh"] } }
+      });
+      expect(consoleError).toHaveBeenCalledWith(
+        expect.stringContaining('"broken"'),
+        expect.any(Error)
+      );
+    } finally {
+      consoleError.mockRestore();
+      unregisterBroken();
+      unregisterQuery();
+    }
+  });
+
   it("an unrecognized opt-in value still reaches the unnamed hook", async () => {
     // Hand-tagged requests from integrations predating named sources sent
     // arbitrary truthy values; any of them must keep opting in.