graphql tessts

Author: aarne

packages/bridge-core/src/ExecutionTree.ts

@@ -150,6 +150,8 @@ export class ExecutionTree implements TreeContext {
     new Map();
   /** Promise that resolves when all critical `force` handles have settled. */
   private forcedExecution?: Promise<void>;
+  /** Cached spread data for field-by-field GraphQL resolution. */
+  private spreadCache?: Record<string, unknown>;
   /** Shared trace collector — present only when tracing is enabled. */
   tracer?: TraceCollector;
   /**
@@ -1280,6 +1282,7 @@ export class ExecutionTree implements TreeContext {
     const result = this.resolveWires(matches);
     if (!array) return result;
     const resolved = await result;
+    if (resolved == null || !Array.isArray(resolved)) return resolved;
     const arrayPathKey = path.join(".");
     if (isLoopControlSignal(resolved)) {
       this.recordEmptyArray(arrayPathKey);
@@ -1719,6 +1722,29 @@ export class ExecutionTree implements TreeContext {
         return this;
       }
 
+      // ── Lazy spread resolution ─────────────────────────────────────
+      // When ALL matches are spread wires, resolve them eagerly, cache
+      // the result, then return `this` so GraphQL sub-field resolvers
+      // can pick up both spread properties and explicit wires.
+      if (
+        !array &&
+        matches.every(
+          (w): boolean => "from" in w && "spread" in w && !!w.spread,
+        )
+      ) {
+        const spreadData = await this.resolveWires(matches);
+        if (spreadData != null && typeof spreadData === "object") {
+          const prefix = cleanPath.join(".");
+          this.spreadCache ??= {};
+          if (prefix === "") {
+            Object.assign(this.spreadCache, spreadData as Record<string, unknown>);
+          } else {
+            (this.spreadCache as Record<string, unknown>)[prefix] = spreadData;
+          }
+        }
+        return this;
+      }
+
       const response = this.resolveWires(matches);
 
       if (!array) {
@@ -1727,6 +1753,7 @@ export class ExecutionTree implements TreeContext {
 
       // Array: create shadow trees for per-element resolution
       const resolved = await response;
+      if (resolved == null || !Array.isArray(resolved)) return resolved;
       const arrayPathKey = cleanPath.join(".");
       if (isLoopControlSignal(resolved)) {
         this.recordEmptyArray(arrayPathKey);
@@ -1745,6 +1772,7 @@ export class ExecutionTree implements TreeContext {
         const response = this.resolveWires(defineFieldWires);
         if (!array) return response;
         const resolved = await response;
+        if (resolved == null || !Array.isArray(resolved)) return resolved;
         const definePathKey = cleanPath.join(".");
         if (isLoopControlSignal(resolved)) {
           this.recordEmptyArray(definePathKey);
@@ -1754,6 +1782,29 @@ export class ExecutionTree implements TreeContext {
       }
     }
 
+    // ── Spread cache fallback ─────────────────────────────────────────
+    // If a spread wire was resolved at a parent path, field-by-field GraphQL
+    // resolution consults the cached spread data for fields not covered by
+    // explicit wires.
+    if (cleanPath.length > 0 && this.spreadCache) {
+      // Check for a parent-level spread: e.g. cleanPath=["author"] with
+      // spread cached under "" (root spread), or cleanPath=["info","author"]
+      // with spread cached under "info".
+      const fieldName = cleanPath[cleanPath.length - 1]!;
+      const parentPrefix = cleanPath.slice(0, -1).join(".");
+      const parentSpread =
+        parentPrefix === ""
+          ? this.spreadCache
+          : (this.spreadCache[parentPrefix] as Record<string, unknown> | undefined);
+      if (
+        parentSpread != null &&
+        typeof parentSpread === "object" &&
+        fieldName in parentSpread
+      ) {
+        return (parentSpread as Record<string, unknown>)[fieldName];
+      }
+    }
+
     // Fallback: if this shadow tree has stored element data, resolve the
     // requested field directly from it. This handles passthrough arrays
     // where the bridge maps an inner array (e.g. `.stops <- j.stops`) but

packages/bridge-graphql/src/bridge-transform.ts

@@ -457,7 +457,10 @@ export function bridgeTransform(
             if (scalar) {
               if (result instanceof ExecutionTree) {
                 try {
-                  return result.collectOutput();
+                  const data = result.collectOutput();
+                  const forced = result.getForcedExecution();
+                  if (forced) await forced;
+                  return data;
                 } catch (err) {
                   throw new Error(
                     formatBridgeError(err, {
@@ -470,11 +473,15 @@ export function bridgeTransform(
               }
               if (Array.isArray(result) && result[0] instanceof ExecutionTree) {
                 try {
-                  return await Promise.all(
+                  const firstTree = result[0] as ExecutionTree;
+                  const forced = firstTree.getForcedExecution();
+                  const collected = await Promise.all(
                     result.map((shadow: ExecutionTree) =>
                       shadow.collectOutput(),
                     ),
                   );
+                  if (forced) await forced;
+                  return collected;
                 } catch (err) {
                   throw new Error(
                     formatBridgeError(err, {

packages/bridge/test/path-scoping.test.ts

@@ -435,7 +435,6 @@ regressionTest("path scoping: spread syntax", {
           api: () => ({ name: "Alice", age: 30 }),
         },
         assertData: { name: "Alice", age: 30, extra: "added" },
-        disable: ["graphql"],
         assertTraces: 1,
       },
     },
@@ -446,7 +445,6 @@ regressionTest("path scoping: spread syntax", {
           api: () => ({ data: { x: 1, y: 2 } }),
         },
         assertData: { x: 1, y: 2, source: "api" },
-        disable: ["graphql"],
         assertTraces: 1,
       },
     },
@@ -459,7 +457,6 @@ regressionTest("path scoping: spread syntax", {
         assertData: {
           info: { author: "Bob", year: 2024, verified: true },
         },
-        disable: ["graphql"],
         assertTraces: 1,
       },
     },

packages/bridge/test/scheduling.test.ts

@@ -115,7 +115,6 @@ regressionTest("scheduling: diamond dependency dedup", {
         },
         // geocode + weatherForecast + census + formatGreeting = 4
         assertTraces: 4,
-        disable: ["graphql"],
       },
     },
   },

packages/bridge/test/shared-parity.test.ts

@@ -366,7 +366,6 @@ regressionTest("parity: array mapping", {
         input: {},
         tools: { api: () => ({ list: null }) },
         assertData: { items: null },
-        disable: ["graphql"],
         assertTraces: 1,
       },
       "non-empty items map correctly": {
@@ -665,7 +664,6 @@ regressionTest("parity: force statements", {
           },
         },
         assertError: /audit failed/,
-        disable: ["graphql"],
         assertTraces: 2,
       },
     },
@@ -1734,7 +1732,6 @@ regressionTest("parity: sparse fieldsets — wildcard and chains", {
         },
         fields: ["price"],
         assertData: { price: 99 },
-        disable: ["graphql"],
         assertTraces: 1,
       },
     },
@@ -1900,14 +1897,12 @@ regressionTest("parity: sparse fieldsets — nested and array paths", {
         assertData: [
           { id: 1, provider: "X", price: 50, legs: [{ name: "L1" }] },
         ],
-        disable: ["graphql"],
         assertTraces: 1,
       },
       "empty items returns empty array": {
         input: { from: "A", to: "B" },
         tools: { api: () => ({ items: [] }) },
         assertData: [],
-        disable: ["graphql"],
         assertTraces: 1,
       },
     },
@@ -1934,7 +1929,6 @@ regressionTest("parity: sparse fieldsets — nested and array paths", {
             legs: [{ destination: "Zürich" }, { destination: "Basel" }],
           },
         ],
-        disable: ["graphql"],
         assertTraces: 1,
       },
       "all fields returned when no requestedFields": {
@@ -1958,14 +1952,12 @@ regressionTest("parity: sparse fieldsets — nested and array paths", {
             legs: [{ trainName: "IC1", destination: "Zürich" }],
           },
         ],
-        disable: ["graphql"],
         assertTraces: 1,
       },
       "empty connections returns empty array": {
         input: { from: "Bern", to: "Zürich" },
         tools: { api: () => ({ connections: [] }) },
         assertData: [],
-        disable: ["graphql"],
         assertTraces: 1,
       },
       "connection with empty sections": {
@@ -1978,7 +1970,6 @@ regressionTest("parity: sparse fieldsets — nested and array paths", {
         assertData: [
           { id: 1, provider: "SBB", departureTime: "09:00", legs: [] },
         ],
-        disable: ["graphql"],
         assertTraces: 1,
       },
     },
@@ -2009,7 +2000,6 @@ regressionTest("parity: sparse fieldsets — nested and array paths", {
             legs: [{ destination: { actualTime: "08:32" } }],
           },
         ],
-        disable: ["graphql"],
         assertTraces: 1,
       },
       "all fields returned when no requestedFields": {
@@ -2049,14 +2039,12 @@ regressionTest("parity: sparse fieldsets — nested and array paths", {
             ],
           },
         ],
-        disable: ["graphql"],
         assertTraces: 1,
       },
       "empty connections returns empty array": {
         input: { from: "Bern" },
         tools: { api: () => ({ connections: [] }) },
         assertData: [],
-        disable: ["graphql"],
         assertTraces: 1,
       },
       "connection with empty sections": {
@@ -2067,7 +2055,6 @@ regressionTest("parity: sparse fieldsets — nested and array paths", {
           }),
         },
         assertData: [{ id: 1, provider: "SBB", legs: [] }],
-        disable: ["graphql"],
         assertTraces: 1,
       },
     },