effect 4.0.4 → 4.0.5

package/src/graphql/GraphQLClient.ts

@@ -378,15 +378,18 @@ const makeMethod = <Op extends GraphQL.Any>(
   // Type boundary: a middleware sees the errors of the middleware further in
   // as `Types.unhandled` (as in `RpcMiddleware`), and none of their
   // requirements. Those errors are part of `GraphQL.Error<Op>`, so the chain
-  // restates its type here. Force POST only at the transport boundary.
+  // restates its type here. Force POST and the resolved URL apply only at the
+  // transport boundary.
   const execute = (
     index: number,
     request: GraphQLRequest,
-    forcePost: boolean
+    forcePost: boolean,
+    resolvedUrl: internalGraphQL.ResolvedUrl
   ): Effect.Effect<ExecutionResult, GraphQL.Error<Op>, GraphQLMiddleware.Requires<GraphQL.Middleware<Op>>> =>
     index === chain.length
       ? protocol.execute(request).pipe(
         forcePost ? Effect.provideService(internalGraphQL.ForcePost, true) : identity,
+        resolvedUrl === undefined ? identity : Effect.provideService(internalGraphQL.ResolvedUrl, resolvedUrl),
         Effect.mapError(fail),
         Effect.flatMap(decodeResponse)
       )
@@ -394,12 +397,21 @@ const makeMethod = <Op extends GraphQL.Any>(
         operation,
         request,
         next: (request) =>
-          execute(index + 1, request, forcePost) as Effect.Effect<
+          execute(index + 1, request, forcePost, resolvedUrl) as Effect.Effect<
             ExecutionResult,
             GraphQLClientError | Types.unhandled
           >
       }) as Effect.Effect<ExecutionResult, GraphQL.Error<Op>, GraphQLMiddleware.Requires<GraphQL.Middleware<Op>>>
 
+  // Hands a resolver batch's URL to the transport only, so calls made by
+  // middleware resolve their own.
+  const run = (request: GraphQLRequest, forcePost: boolean) =>
+    internalGraphQL.ResolvedUrl.use((resolved) =>
+      resolved === undefined
+        ? execute(0, request, forcePost, undefined)
+        : execute(0, request, forcePost, resolved).pipe(Effect.provideService(internalGraphQL.ResolvedUrl, undefined))
+    )
+
   const subscribe = (
     index: number,
     request: GraphQLRequest
@@ -441,7 +453,7 @@ const makeMethod = <Op extends GraphQL.Any>(
     Exclude<GraphQL.Services<Op>, R2>
   > {
     return buildRequest(variables, options).pipe(
-      Effect.flatMap((request) => execute(0, request, false)),
+      Effect.flatMap((request) => run(request, false)),
       Effect.flatMap(
         (result): Effect.Effect<
           GraphQL.Result<Op> | PartialResult<GraphQL.Result<Op>>,
@@ -452,7 +464,7 @@ const makeMethod = <Op extends GraphQL.Any>(
       Effect.provideContext(callContext(options))
     )
   }
-  internalGraphQL.rawExecutors.set(method, (request) => execute(0, request, true))
+  internalGraphQL.rawExecutors.set(method, { execute: (request) => run(request, true), url: protocol.url })
   return Object.assign(method, { operation })
 }
 

package/src/graphql/GraphQLProtocol.ts

@@ -20,6 +20,7 @@ import * as Duration from "../Duration.ts"
 import * as Effect from "../Effect.ts"
 import * as Sse from "../encoding/Sse.ts"
 import * as Fiber from "../Fiber.ts"
+import { constant } from "../Function.ts"
 import * as Headers from "../http/Headers.ts"
 import * as HttpClient from "../http/HttpClient.ts"
 import * as HttpClientError from "../http/HttpClientError.ts"
@@ -152,8 +153,33 @@ export class GraphQLProtocol extends Context.Service<GraphQLProtocol, {
     readonly status?: number | undefined
     readonly headers?: Headers.Headers | undefined
   }, TransportError>
+  /**
+   * Resolves the transport URL for resolver batching. Set by `layerHttp`;
+   * optional for custom transports.
+   */
+  readonly url?:
+    | ((options: { readonly kind: Kind; readonly operationName: string }) => Effect.Effect<string>)
+    | undefined
 }>()("effect/graphql/GraphQLProtocol") {}
 
+/**
+ * The URL of an HTTP transport: fixed, resolved for each operation from the
+ * calling context, `kind` and `operationName`, or an `Effect` with no errors
+ * or requirements. See {@link layerHttp}.
+ *
+ * @stability experimental
+ * @category models
+ * @since 4.0.0
+ */
+export type Url =
+  | string
+  | Effect.Effect<string>
+  | ((options: {
+    readonly context: Context.Context<never>
+    readonly kind: Kind
+    readonly operationName: string
+  }) => string)
+
 const graphqlResponseContentType = "application/graphql-response+json"
 const jsonContentType = "application/json"
 const eventStreamContentType = "text/event-stream"
@@ -318,7 +344,7 @@ const sseEvents = (
   })
 
 interface HttpOptions<R = never> {
-  readonly url: string
+  readonly url: Url
   readonly queryMethod?: "GET" | "POST" | undefined
   readonly subscriptions?: {
     readonly webSocket: WebSocketOptions<R>
@@ -330,23 +356,29 @@ const makeHttpWith = <R>(options: HttpOptions<R>): Effect.Effect<
   never,
   HttpClient.HttpClient | Socket.WebSocketConstructor | Scope.Scope | R
 > => {
+  const resolve = urlResolver(options.url)
+  // A resolver batch carries the URL it was grouped by.
+  const urlOf = (request: GraphQLRequest) =>
+    internalGraphQL.ResolvedUrl.use((resolved) =>
+      resolved?.resolve === resolve ? Effect.succeed(resolved.url) : resolve(request)
+    )
   const http = Clock.clockWith((clock) =>
     HttpClient.HttpClient.useSync((client) => {
       const execute = (request: GraphQLRequest) =>
-        Effect.flatMap(Effect.service(internalGraphQL.ForcePost), (forcePost) => {
+        Effect.flatMap(Effect.zip(Effect.service(internalGraphQL.ForcePost), urlOf(request)), ([forcePost, url]) => {
           const toRequest = options.queryMethod === "GET" && request.kind === "query" && !forcePost
             ? getRequest
             : postRequest
           return client.execute(
-            toRequest(options.url, request, `${graphqlResponseContentType}, ${jsonContentType}`)
+            toRequest(url, request, `${graphqlResponseContentType}, ${jsonContentType}`)
           ).pipe(
             Effect.flatMap(readAnswer),
             fromHttpClientError(clock)
           )
         })
       const subscribe = (request: GraphQLRequest) =>
-        Stream.unwrap(Effect.suspend(() =>
-          client.execute(postRequest(options.url, request, eventStreamContentType)).pipe(
+        Stream.unwrap(Effect.flatMap(urlOf(request), (url) =>
+          client.execute(postRequest(url, request, eventStreamContentType)).pipe(
             Effect.flatMap((response) => {
               const contentType = contentTypeOf(response)
               if (contentType.includes(eventStreamContentType) && response.status >= 200 && response.status < 300) {
@@ -357,9 +389,8 @@ const makeHttpWith = <R>(options: HttpOptions<R>): Effect.Effect<
               return Effect.map(readAnswer(response), Stream.succeed)
             }),
             fromHttpClientError(clock)
-          )
-        ))
-      return GraphQLProtocol.of({ execute, subscribe })
+          )))
+      return GraphQLProtocol.of({ execute, subscribe, url: resolve })
     })
   )
   const webSocket = options.subscriptions?.webSocket
@@ -368,10 +399,17 @@ const makeHttpWith = <R>(options: HttpOptions<R>): Effect.Effect<
     : Effect.zipWith(
       http,
       makeWebSocket(webSocket),
-      (http, ws) => GraphQLProtocol.of({ execute: http.execute, subscribe: ws.subscribe })
+      (http, ws) => GraphQLProtocol.of({ execute: http.execute, subscribe: ws.subscribe, url: http.url })
     )
 }
 
+const urlResolver = (url: Url): NonNullable<GraphQLProtocol["Service"]["url"]> => {
+  if (typeof url === "string") return constant(Effect.succeed(url))
+  if (Effect.isEffect(url)) return constant(url)
+  return ({ kind, operationName }) =>
+    Effect.contextWith((context: Context.Context<never>) => Effect.succeed(url({ context, kind, operationName })))
+}
+
 /**
  * Builds the HTTP transport as an effect, for composing transports by hand.
  * Most code uses {@link layerHttp}.
@@ -380,9 +418,9 @@ const makeHttpWith = <R>(options: HttpOptions<R>): Effect.Effect<
  *
  * Takes the same options as {@link layerHttp}, including `queryMethod`.
  * Without `subscriptions`, subscriptions use graphql-sse distinct mode on
- * `url`. With `subscriptions.webSocket`, they go over graphql-ws instead, and
- * the effect also builds the graphql-ws transport, so it needs a
- * `Socket.WebSocketConstructor` and a `Scope`.
+ * `url`. With `subscriptions.webSocket`, `url` must be a string, subscriptions
+ * go over graphql-ws instead, and the effect also builds the graphql-ws
+ * transport, so it needs a `Socket.WebSocketConstructor` and a `Scope`.
  *
  * @stability experimental
  * @category constructors
@@ -397,9 +435,9 @@ export const makeHttp: {
    *
    * Takes the same options as {@link layerHttp}, including `queryMethod`.
    * Without `subscriptions`, subscriptions use graphql-sse distinct mode on
-   * `url`. With `subscriptions.webSocket`, they go over graphql-ws instead, and
-   * the effect also builds the graphql-ws transport, so it needs a
-   * `Socket.WebSocketConstructor` and a `Scope`.
+   * `url`. With `subscriptions.webSocket`, `url` must be a string, subscriptions
+   * go over graphql-ws instead, and the effect also builds the graphql-ws
+   * transport, so it needs a `Socket.WebSocketConstructor` and a `Scope`.
    *
    * @stability experimental
    * @category constructors
@@ -433,9 +471,9 @@ export const makeHttp: {
    *
    * Takes the same options as {@link layerHttp}, including `queryMethod`.
    * Without `subscriptions`, subscriptions use graphql-sse distinct mode on
-   * `url`. With `subscriptions.webSocket`, they go over graphql-ws instead, and
-   * the effect also builds the graphql-ws transport, so it needs a
-   * `Socket.WebSocketConstructor` and a `Scope`.
+   * `url`. With `subscriptions.webSocket`, `url` must be a string, subscriptions
+   * go over graphql-ws instead, and the effect also builds the graphql-ws
+   * transport, so it needs a `Socket.WebSocketConstructor` and a `Scope`.
    *
    * @stability experimental
    * @category constructors
@@ -443,7 +481,7 @@ export const makeHttp: {
    */
   (
     options: {
-      readonly url: string
+      readonly url: Url
       readonly queryMethod?: "GET" | "POST" | undefined
       readonly subscriptions?: undefined
     }
@@ -498,6 +536,28 @@ export const makeHttp: {
  * With `subscriptions: { webSocket }`, subscriptions go over graphql-ws as in
  * {@link layerWebSocket}, and the layer needs a `Socket.WebSocketConstructor`.
  *
+ * To route each query, mutation and graphql-sse subscription, `url` can be a
+ * function of the calling fiber's context (including the call's `context`
+ * option), `kind` and `operationName`, or an `Effect<string>` with no errors
+ * or requirements that runs in that context. Use a defaulted
+ * `Context.Reference` to select the server. Reading a missing service with
+ * `Context.get` is a defect, not a `TransportError`. Neither form can be
+ * combined with `subscriptions.webSocket`: the socket URL is fixed at
+ * connection time.
+ *
+ * **Gotchas**
+ *
+ * `GraphQLResolver` resolves each lookup's URL once, before middleware run and
+ * before the batched request exists, then sends each batch to the URL it was
+ * grouped by. A single call resolves it in the transport, after middleware.
+ * So the URL must depend only on the context and the operation, and
+ * middleware must not change `kind` or `operationName` or provide services
+ * the URL reads.
+ *
+ * `RequestResolver.withCache` and `RequestResolver.persisted` key on the lookup,
+ * not the URL, so results can leak across servers. For caching, use a separate
+ * client and resolver per server, for example with `LayerMap`.
+ *
  * **Example** (Building a client over HTTP)
  *
  * ```ts import.meta.vitest
@@ -571,6 +631,56 @@ export const makeHttp: {
  * await Effect.runPromise(program) // => { viewer: { login: "GET draft-token" } }
  * ```
  *
+ * **Example** (One client for github.com, GHE.com and GitHub Enterprise Server)
+ *
+ * ```ts import.meta.vitest
+ * import { Context, Effect, Layer, Schema } from "effect"
+ * import { GraphQL, GraphQLClient, GraphQLGroup, GraphQLProtocol } from "effect/graphql"
+ * import { HttpClient, HttpClientResponse } from "effect/http"
+ *
+ * const Viewer = GraphQL.query("Viewer", {
+ *   document: "query Viewer{viewer{login}}",
+ *   result: Schema.Struct({ viewer: Schema.Struct({ login: Schema.String }) })
+ * })
+ *
+ * const GitHubHost = Context.Reference<string>("GitHubHost", { defaultValue: () => "github.com" })
+ *
+ * const Protocol = GraphQLProtocol.layerHttp({
+ *   url: ({ context }) => {
+ *     const host = Context.get(context, GitHubHost)
+ *     if (host === "github.com") return "https://api.github.com/graphql"
+ *     if (host.endsWith(".ghe.com")) return `https://api.${host}/graphql`
+ *     return `https://${host}/api/graphql`
+ *   }
+ * })
+ *
+ * // Echo the request URL instead of calling GitHub.
+ * const FakeServer = Layer.succeed(
+ *   HttpClient.HttpClient,
+ *   HttpClient.make((request, url) =>
+ *     Effect.succeed(HttpClientResponse.fromWeb(
+ *       request,
+ *       new Response(JSON.stringify({ data: { viewer: { login: url.href } } }), {
+ *         headers: { "content-type": "application/graphql-response+json" }
+ *       })
+ *     ))
+ *   )
+ * )
+ *
+ * const program = Effect.gen(function*() {
+ *   const client = yield* GraphQLClient.make(GraphQLGroup.make(Viewer))
+ *   const dotcom = yield* client.Viewer()
+ *   const cloud = yield* client.Viewer().pipe(Effect.provideService(GitHubHost, "acme.ghe.com"))
+ *   const server = yield* client.Viewer(undefined, { context: Context.make(GitHubHost, "github.example.com") })
+ *   return [dotcom, cloud, server].map((result) => result.viewer.login)
+ * }).pipe(
+ *   Effect.provide(Protocol),
+ *   Effect.provide(FakeServer)
+ * )
+ *
+ * await Effect.runPromise(program) // => ["https://api.github.com/graphql", "https://api.acme.ghe.com/graphql", "https://github.example.com/api/graphql"]
+ * ```
+ *
  * **Example** (Subscriptions over graphql-ws, everything else over POST)
  *
  * ```ts import.meta.vitest
@@ -641,6 +751,28 @@ export const layerHttp: {
    * With `subscriptions: { webSocket }`, subscriptions go over graphql-ws as in
    * {@link layerWebSocket}, and the layer needs a `Socket.WebSocketConstructor`.
    *
+   * To route each query, mutation and graphql-sse subscription, `url` can be a
+   * function of the calling fiber's context (including the call's `context`
+   * option), `kind` and `operationName`, or an `Effect<string>` with no errors
+   * or requirements that runs in that context. Use a defaulted
+   * `Context.Reference` to select the server. Reading a missing service with
+   * `Context.get` is a defect, not a `TransportError`. Neither form can be
+   * combined with `subscriptions.webSocket`: the socket URL is fixed at
+   * connection time.
+   *
+   * **Gotchas**
+   *
+   * `GraphQLResolver` resolves each lookup's URL once, before middleware run and
+   * before the batched request exists, then sends each batch to the URL it was
+   * grouped by. A single call resolves it in the transport, after middleware.
+   * So the URL must depend only on the context and the operation, and
+   * middleware must not change `kind` or `operationName` or provide services
+   * the URL reads.
+   *
+   * `RequestResolver.withCache` and `RequestResolver.persisted` key on the lookup,
+   * not the URL, so results can leak across servers. For caching, use a separate
+   * client and resolver per server, for example with `LayerMap`.
+   *
    * **Example** (Building a client over HTTP)
    *
    * ```ts import.meta.vitest
@@ -714,6 +846,56 @@ export const layerHttp: {
    * await Effect.runPromise(program) // => { viewer: { login: "GET draft-token" } }
    * ```
    *
+   * **Example** (One client for github.com, GHE.com and GitHub Enterprise Server)
+   *
+   * ```ts import.meta.vitest
+   * import { Context, Effect, Layer, Schema } from "effect"
+   * import { GraphQL, GraphQLClient, GraphQLGroup, GraphQLProtocol } from "effect/graphql"
+   * import { HttpClient, HttpClientResponse } from "effect/http"
+   *
+   * const Viewer = GraphQL.query("Viewer", {
+   *   document: "query Viewer{viewer{login}}",
+   *   result: Schema.Struct({ viewer: Schema.Struct({ login: Schema.String }) })
+   * })
+   *
+   * const GitHubHost = Context.Reference<string>("GitHubHost", { defaultValue: () => "github.com" })
+   *
+   * const Protocol = GraphQLProtocol.layerHttp({
+   *   url: ({ context }) => {
+   *     const host = Context.get(context, GitHubHost)
+   *     if (host === "github.com") return "https://api.github.com/graphql"
+   *     if (host.endsWith(".ghe.com")) return `https://api.${host}/graphql`
+   *     return `https://${host}/api/graphql`
+   *   }
+   * })
+   *
+   * // Echo the request URL instead of calling GitHub.
+   * const FakeServer = Layer.succeed(
+   *   HttpClient.HttpClient,
+   *   HttpClient.make((request, url) =>
+   *     Effect.succeed(HttpClientResponse.fromWeb(
+   *       request,
+   *       new Response(JSON.stringify({ data: { viewer: { login: url.href } } }), {
+   *         headers: { "content-type": "application/graphql-response+json" }
+   *       })
+   *     ))
+   *   )
+   * )
+   *
+   * const program = Effect.gen(function*() {
+   *   const client = yield* GraphQLClient.make(GraphQLGroup.make(Viewer))
+   *   const dotcom = yield* client.Viewer()
+   *   const cloud = yield* client.Viewer().pipe(Effect.provideService(GitHubHost, "acme.ghe.com"))
+   *   const server = yield* client.Viewer(undefined, { context: Context.make(GitHubHost, "github.example.com") })
+   *   return [dotcom, cloud, server].map((result) => result.viewer.login)
+   * }).pipe(
+   *   Effect.provide(Protocol),
+   *   Effect.provide(FakeServer)
+   * )
+   *
+   * await Effect.runPromise(program) // => ["https://api.github.com/graphql", "https://api.acme.ghe.com/graphql", "https://github.example.com/api/graphql"]
+   * ```
+   *
    * **Example** (Subscriptions over graphql-ws, everything else over POST)
    *
    * ```ts import.meta.vitest
@@ -799,6 +981,28 @@ export const layerHttp: {
    * With `subscriptions: { webSocket }`, subscriptions go over graphql-ws as in
    * {@link layerWebSocket}, and the layer needs a `Socket.WebSocketConstructor`.
    *
+   * To route each query, mutation and graphql-sse subscription, `url` can be a
+   * function of the calling fiber's context (including the call's `context`
+   * option), `kind` and `operationName`, or an `Effect<string>` with no errors
+   * or requirements that runs in that context. Use a defaulted
+   * `Context.Reference` to select the server. Reading a missing service with
+   * `Context.get` is a defect, not a `TransportError`. Neither form can be
+   * combined with `subscriptions.webSocket`: the socket URL is fixed at
+   * connection time.
+   *
+   * **Gotchas**
+   *
+   * `GraphQLResolver` resolves each lookup's URL once, before middleware run and
+   * before the batched request exists, then sends each batch to the URL it was
+   * grouped by. A single call resolves it in the transport, after middleware.
+   * So the URL must depend only on the context and the operation, and
+   * middleware must not change `kind` or `operationName` or provide services
+   * the URL reads.
+   *
+   * `RequestResolver.withCache` and `RequestResolver.persisted` key on the lookup,
+   * not the URL, so results can leak across servers. For caching, use a separate
+   * client and resolver per server, for example with `LayerMap`.
+   *
    * **Example** (Building a client over HTTP)
    *
    * ```ts import.meta.vitest
@@ -872,6 +1076,56 @@ export const layerHttp: {
    * await Effect.runPromise(program) // => { viewer: { login: "GET draft-token" } }
    * ```
    *
+   * **Example** (One client for github.com, GHE.com and GitHub Enterprise Server)
+   *
+   * ```ts import.meta.vitest
+   * import { Context, Effect, Layer, Schema } from "effect"
+   * import { GraphQL, GraphQLClient, GraphQLGroup, GraphQLProtocol } from "effect/graphql"
+   * import { HttpClient, HttpClientResponse } from "effect/http"
+   *
+   * const Viewer = GraphQL.query("Viewer", {
+   *   document: "query Viewer{viewer{login}}",
+   *   result: Schema.Struct({ viewer: Schema.Struct({ login: Schema.String }) })
+   * })
+   *
+   * const GitHubHost = Context.Reference<string>("GitHubHost", { defaultValue: () => "github.com" })
+   *
+   * const Protocol = GraphQLProtocol.layerHttp({
+   *   url: ({ context }) => {
+   *     const host = Context.get(context, GitHubHost)
+   *     if (host === "github.com") return "https://api.github.com/graphql"
+   *     if (host.endsWith(".ghe.com")) return `https://api.${host}/graphql`
+   *     return `https://${host}/api/graphql`
+   *   }
+   * })
+   *
+   * // Echo the request URL instead of calling GitHub.
+   * const FakeServer = Layer.succeed(
+   *   HttpClient.HttpClient,
+   *   HttpClient.make((request, url) =>
+   *     Effect.succeed(HttpClientResponse.fromWeb(
+   *       request,
+   *       new Response(JSON.stringify({ data: { viewer: { login: url.href } } }), {
+   *         headers: { "content-type": "application/graphql-response+json" }
+   *       })
+   *     ))
+   *   )
+   * )
+   *
+   * const program = Effect.gen(function*() {
+   *   const client = yield* GraphQLClient.make(GraphQLGroup.make(Viewer))
+   *   const dotcom = yield* client.Viewer()
+   *   const cloud = yield* client.Viewer().pipe(Effect.provideService(GitHubHost, "acme.ghe.com"))
+   *   const server = yield* client.Viewer(undefined, { context: Context.make(GitHubHost, "github.example.com") })
+   *   return [dotcom, cloud, server].map((result) => result.viewer.login)
+   * }).pipe(
+   *   Effect.provide(Protocol),
+   *   Effect.provide(FakeServer)
+   * )
+   *
+   * await Effect.runPromise(program) // => ["https://api.github.com/graphql", "https://api.acme.ghe.com/graphql", "https://github.example.com/api/graphql"]
+   * ```
+   *
    * **Example** (Subscriptions over graphql-ws, everything else over POST)
    *
    * ```ts import.meta.vitest
@@ -899,7 +1153,7 @@ export const layerHttp: {
    */
   (
     options: {
-      readonly url: string
+      readonly url: Url
       readonly queryMethod?: "GET" | "POST" | undefined
       readonly subscriptions?: undefined
     }

package/src/graphql/GraphQLResolver.ts

@@ -9,12 +9,15 @@
  * in separate batches. Compose `RequestResolver.setDelay` and
  * `RequestResolver.batchN` with `.pipe` to control batching.
  *
+ * Lookups with different protocol URLs are batched separately. See
+ * `GraphQLProtocol.layerHttp` for middleware and caching constraints.
+ *
  * @stability experimental
  * @since 4.0.0
  */
 import * as Arr from "../Array.ts"
 import * as Cause from "../Cause.ts"
-import type * as Context from "../Context.ts"
+import * as Context from "../Context.ts"
 import * as Effect from "../Effect.ts"
 import * as Exit from "../Exit.ts"
 import { dual } from "../Function.ts"
@@ -556,6 +559,7 @@ export const ordered = <
   const path = options.path as ReadonlyArray<string>
   const codec = internalGraphQL.makeCodec(method.operation)
   return makeResolver(
+    method,
     options.batchKey,
     (entries) =>
       Effect.flatMap(callBatch(method, entries, options.variables), ({ keys, targets, result }) => {
@@ -689,6 +693,7 @@ export const findById = <
   const path = options.path as ReadonlyArray<string>
   const codec = internalGraphQL.makeCodec(method.operation)
   return makeResolver(
+    method,
     options.batchKey,
     (entries) =>
       Effect.flatMap(callBatch(method, entries, options.variables), ({ keys, targets, result }) => {
@@ -832,7 +837,7 @@ export const aliased = <Op extends GraphQL.Any>(
   }
   const codec = internalGraphQL.makeCodec(operation)
   // The registered hook uses this operation's middleware errors and services.
-  const execute = internalGraphQL.rawExecutors.get(method) as
+  const execute = internalGraphQL.rawExecutors.get(method)?.execute as
     | ((request: GraphQLRequest) => Effect.Effect<ExecutionResult, GraphQL.Error<Op>, GraphQL.Services<Op>>)
     | undefined
   // Generic conditional parameters prevent calling the strict overload directly.
@@ -840,7 +845,7 @@ export const aliased = <Op extends GraphQL.Any>(
     variables: GraphQL.Variables<Op>
   ) => Effect.Effect<GraphQL.Result<Op>, GraphQL.Error<Op>, GraphQL.Services<Op>>
 
-  return makeResolver<AliasedRequest<Op>>(options?.batchKey, (entries) =>
+  return makeResolver<AliasedRequest<Op>>(method, options?.batchKey, (entries) =>
     Effect.flatMap(
       Effect.forEach(entries, (entry) => Effect.exit(codec.encodeVariables(entry.request.key))),
       (encoded) => {
@@ -891,7 +896,7 @@ export const aliased = <Op extends GraphQL.Any>(
           })
         )
       }
-    ).pipe(Effect.provideContext(entries[0].context))).pipe(RequestResolver.batchN(10))
+    )).pipe(RequestResolver.batchN(10))
 }
 
 type AliasedRequest<Op extends GraphQL.Any> = KeyRequest<
@@ -914,20 +919,46 @@ interface Slice<Op extends GraphQL.Any> {
 const constNoSuchElement = Exit.fail(new Cause.NoSuchElementError())
 
 /**
- * Without `batchKey`, all entries share one batch. With it, each batch holds
- * entries with equal keys, so the first entry's context stands for the batch.
+ * Resolves each entry's URL in its own context, then splits the entries by URL
+ * and `batchKey`. Each batch runs in its first entry's context, carrying the
+ * URL it was grouped by, so the transport doesn't resolve it again.
  */
 const makeResolver = <A extends Request.Any>(
+  method: OperationMethod<any>,
   batchKey: ((context: Context.Context<any>) => unknown) | undefined,
-  runAll: (entries: Arr.NonEmptyArray<Request.Entry<A>>) => Effect.Effect<void, Request.Error<A>>
-): RequestResolver.RequestResolver<A> =>
-  batchKey === undefined
-    ? RequestResolver.make(runAll)
-    : RequestResolver.makeGrouped({ key: (entry) => batchKey(entry.context), resolver: runAll })
+  runAll: (entries: Arr.NonEmptyArray<Request.Entry<A>>) => Effect.Effect<void, Request.Error<A>, any>
+): RequestResolver.RequestResolver<A> => {
+  const resolve = internalGraphQL.rawExecutors.get(method)?.url
+  const operation = { kind: method.operation.kind, operationName: method.operation.name }
+  const urlOf = (entry: Request.Entry<A>) =>
+    resolve === undefined ? Effect.succeed(undefined) : Effect.provideContext(resolve(operation), entry.context)
+  return RequestResolver.make((entries) =>
+    Effect.flatMap(Effect.forEach(entries, urlOf, { concurrency: "unbounded" }), (urls) => {
+      // Arrays are compared structurally, so equal keys share a batch.
+      const batches = MutableHashMap.empty<
+        readonly [string | undefined, unknown],
+        Arr.NonEmptyArray<Request.Entry<A>>
+      >()
+      entries.forEach((entry, i) => {
+        const key = [urls[i], batchKey?.(entry.context)] as const
+        const batch = MutableHashMap.get(batches, key)
+        if (batch._tag === "Some") batch.value.push(entry)
+        else MutableHashMap.set(batches, key, [entry])
+      })
+      return Effect.forEach(batches, ([[url], entries]) => {
+        const context: Context.Context<any> = entries[0].context
+        return Effect.provideContext(
+          runAll(entries),
+          url === undefined ? context : Context.add(context, internalGraphQL.ResolvedUrl, { resolve, url })
+        )
+      }, { concurrency: "unbounded", discard: true })
+    })
+  )
+}
 
 /**
- * Calls the method in the first entry's context with deduplicated keys.
- * Each target completes all entries sharing its key.
+ * Calls the method with deduplicated keys. Each target completes all entries
+ * sharing its key.
  */
 const callBatch = <Op extends GraphQL.Any, K>(
   method: OperationMethod<Op>,
@@ -959,10 +990,7 @@ const callBatch = <Op extends GraphQL.Any, K>(
     variables: GraphQL.Variables<Op>,
     options: { readonly partial: true }
   ) => Effect.Effect<PartialResult<GraphQL.Result<Op>>, GraphQL.Error<Op>, GraphQL.Services<Op>>
-  return call(variables(keys), { partial: true }).pipe(
-    Effect.map((result) => ({ keys, targets, result })),
-    Effect.provideContext(entries[0].context)
-  )
+  return Effect.map(call(variables(keys), { partial: true }), (result) => ({ keys, targets, result }))
 }
 
 // Fails the batch with the response's errors and transport metadata.

package/src/http/FetchHttpClient.ts

@@ -115,12 +115,15 @@ const fetch: HttpClient.HttpClient = HttpClient.make((request, url, signal, fibe
  * **Gotchas**
  *
  * Fetch behavior comes from the runtime's implementation, so CORS, cookies,
- * redirects, abort handling, and streaming support can vary by platform. Stream
- * request bodies are sent as Web streams with `duplex: "half"`, and any
- * `content-length` header is removed before calling `fetch`.
+ * redirects, abort handling, and streaming support can vary by platform. Trace
+ * propagation is on by default, and a browser preflight fails unless the
+ * target allows `b3` and `traceparent`. Stream request bodies are sent as Web
+ * streams with `duplex: "half"`, and any `content-length` header is removed
+ * before calling `fetch`.
  *
  * @see {@link Fetch} for supplying the fetch implementation used by this layer
  * @see {@link RequestInit} for default `RequestInit` options applied before request-specific fields
+ * @see {@link HttpClient.TracerPropagationEnabled} for leaving `b3` and `traceparent` off a browser request
  *
  * @stability unstable
  * @category layers

package/src/http/FindMyWay/internal/router.ts

@@ -857,7 +857,8 @@ function makeCreateParams(
   }
 }
 
-function getClosingParenthensePosition(path: string, idx: number) {
+/** @internal */
+export function getClosingParenthensePosition(path: string, idx: number) {
   // `path.indexOf()` will always return the first position of the closing parenthese,
   // but it's inefficient for grouped or wrong regexp expressions.
   // see issues #62 and #63 for more info