effect 4.0.4 → 4.0.6

package/src/graphql/GraphQLResolver.ts

@@ -9,12 +9,16 @@
  * in separate batches. Compose `RequestResolver.setDelay` and
  * `RequestResolver.batchN` with `.pipe` to control batching.
  *
+ * Lookups with different protocol URLs are batched separately, and
+ * `RequestResolver.batchN` limits each URL's batches. 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"
@@ -24,6 +28,7 @@ import * as internalGraphQL from "../internal/graphql.ts"
 import * as MutableHashMap from "../MutableHashMap.ts"
 import * as Request from "../Request.ts"
 import * as RequestResolver from "../RequestResolver.ts"
+import * as Tracer from "../Tracer.ts"
 import type * as Types from "../Types.ts"
 import type * as GraphQL from "./GraphQL.ts"
 import type { OperationMethod, PartialResult } from "./GraphQLClient.ts"
@@ -62,10 +67,13 @@ type BatchKey<Op extends GraphQL.Any> = [GraphQL.Services<Op>] extends [never] ?
 
 interface KeyRequest<K, A, E, R> extends Request.Request<A, E, R> {
   readonly key: K
+  /** The protocol URL {@link request} resolved for this lookup, if it could. */
+  readonly url: string | undefined
 }
 
-// Requests are structural, so two requests with equal keys are one request.
-const makeRequest = <K, A, E, R>(key: K): KeyRequest<K, A, E, R> => Request.of<KeyRequest<K, A, E, R>>()({ key })
+// Requests are structural, so two requests with equal keys and URLs are one request.
+const makeRequest = <K, A, E, R>(key: K, url: string | undefined): KeyRequest<K, A, E, R> =>
+  Request.of<KeyRequest<K, A, E, R>>()({ key, url })
 
 // -----------------------------------------------------------------------------
 // Running
@@ -228,216 +236,13 @@ export const request: {
   <K, A, E, R>(key: K, resolver: RequestResolver.RequestResolver<KeyRequest<K, A, E, R>>): Effect.Effect<A, E, R>
 } = dual(
   2,
-  <K, A, E, R>(key: K, resolver: RequestResolver.RequestResolver<KeyRequest<K, A, E, R>>): Effect.Effect<A, E, R> =>
-    Effect.request(makeRequest<// -----------------------------------------------------------------------------
-    // Running
-    // -----------------------------------------------------------------------------
-
-    /**
-     * Looks up a key with an {@link ordered}, {@link findById} or {@link aliased}
-     * resolver, using `request(resolver)(key)` or `request(key, resolver)`.
-     *
-     * **Details**
-     *
-     * Concurrent lookups are batched. Keys equal under `Equal` and `Hash`
-     * are sent once per batch and share the result.
-     *
-     * **Example** (Looking up repositories by id)
-     *
-     * ```ts import.meta.vitest
-     * import { Effect, Layer, Schema, Stream } from "effect"
-     * import { GraphQL, GraphQLClient, GraphQLGroup, GraphQLProtocol, GraphQLResolver } from "effect/graphql"
-     *
-     * const RepoNodes = GraphQL.query("RepoNodes", {
-     *   document: "query RepoNodes($ids:[ID!]!){nodes(ids:$ids){... on Repository{name}}}",
-     *   variables: { ids: Schema.Array(Schema.String) },
-     *   result: Schema.Struct({ nodes: Schema.Array(Schema.NullOr(Schema.Struct({ name: Schema.String }))) })
-     * })
-     *
-     * let calls = 0
-     * const Scripted = Layer.succeed(GraphQLProtocol.GraphQLProtocol, {
-     *   execute: (request) => {
-     *     calls++
-     *     const { ids } = request.variables as { ids: Array<string> }
-     *     return Effect.succeed({ body: { data: { nodes: ids.map((id) => ({ name: `repo-${id}` })) } } })
-     *   },
-     *   subscribe: () => Stream.empty
-     * })
-     *
-     * const program = Effect.gen(function*() {
-     *   const client = yield* GraphQLClient.make(GraphQLGroup.make(RepoNodes))
-     *   const getRepo = GraphQLResolver.request(GraphQLResolver.ordered(client.RepoNodes, {
-     *     variables: (ids: ReadonlyArray<string>) => ({ ids }),
-     *     path: ["nodes"]
-     *   }))
-     *   const repos = yield* Effect.forEach(["1", "2", "1"], getRepo, { concurrency: "unbounded" })
-     *   return [repos.map((repo) => repo.name), calls]
-     * })
-     *
-     * await Effect.runPromise(program.pipe(Effect.provide(Scripted))) // => [["repo-1", "repo-2", "repo-1"], 1]
-     * ```
-     *
-     * @stability experimental
-     * @category running
-     * @since 4.0.0
-     */
-    K, // -----------------------------------------------------------------------------
-    // Running
-    // -----------------------------------------------------------------------------
-
-    /**
-     * Looks up a key with an {@link ordered}, {@link findById} or {@link aliased}
-     * resolver, using `request(resolver)(key)` or `request(key, resolver)`.
-     *
-     * **Details**
-     *
-     * Concurrent lookups are batched. Keys equal under `Equal` and `Hash`
-     * are sent once per batch and share the result.
-     *
-     * **Example** (Looking up repositories by id)
-     *
-     * ```ts import.meta.vitest
-     * import { Effect, Layer, Schema, Stream } from "effect"
-     * import { GraphQL, GraphQLClient, GraphQLGroup, GraphQLProtocol, GraphQLResolver } from "effect/graphql"
-     *
-     * const RepoNodes = GraphQL.query("RepoNodes", {
-     *   document: "query RepoNodes($ids:[ID!]!){nodes(ids:$ids){... on Repository{name}}}",
-     *   variables: { ids: Schema.Array(Schema.String) },
-     *   result: Schema.Struct({ nodes: Schema.Array(Schema.NullOr(Schema.Struct({ name: Schema.String }))) })
-     * })
-     *
-     * let calls = 0
-     * const Scripted = Layer.succeed(GraphQLProtocol.GraphQLProtocol, {
-     *   execute: (request) => {
-     *     calls++
-     *     const { ids } = request.variables as { ids: Array<string> }
-     *     return Effect.succeed({ body: { data: { nodes: ids.map((id) => ({ name: `repo-${id}` })) } } })
-     *   },
-     *   subscribe: () => Stream.empty
-     * })
-     *
-     * const program = Effect.gen(function*() {
-     *   const client = yield* GraphQLClient.make(GraphQLGroup.make(RepoNodes))
-     *   const getRepo = GraphQLResolver.request(GraphQLResolver.ordered(client.RepoNodes, {
-     *     variables: (ids: ReadonlyArray<string>) => ({ ids }),
-     *     path: ["nodes"]
-     *   }))
-     *   const repos = yield* Effect.forEach(["1", "2", "1"], getRepo, { concurrency: "unbounded" })
-     *   return [repos.map((repo) => repo.name), calls]
-     * })
-     *
-     * await Effect.runPromise(program.pipe(Effect.provide(Scripted))) // => [["repo-1", "repo-2", "repo-1"], 1]
-     * ```
-     *
-     * @stability experimental
-     * @category running
-     * @since 4.0.0
-     */
-    A, // -----------------------------------------------------------------------------
-    // Running
-    // -----------------------------------------------------------------------------
-
-    /**
-     * Looks up a key with an {@link ordered}, {@link findById} or {@link aliased}
-     * resolver, using `request(resolver)(key)` or `request(key, resolver)`.
-     *
-     * **Details**
-     *
-     * Concurrent lookups are batched. Keys equal under `Equal` and `Hash`
-     * are sent once per batch and share the result.
-     *
-     * **Example** (Looking up repositories by id)
-     *
-     * ```ts import.meta.vitest
-     * import { Effect, Layer, Schema, Stream } from "effect"
-     * import { GraphQL, GraphQLClient, GraphQLGroup, GraphQLProtocol, GraphQLResolver } from "effect/graphql"
-     *
-     * const RepoNodes = GraphQL.query("RepoNodes", {
-     *   document: "query RepoNodes($ids:[ID!]!){nodes(ids:$ids){... on Repository{name}}}",
-     *   variables: { ids: Schema.Array(Schema.String) },
-     *   result: Schema.Struct({ nodes: Schema.Array(Schema.NullOr(Schema.Struct({ name: Schema.String }))) })
-     * })
-     *
-     * let calls = 0
-     * const Scripted = Layer.succeed(GraphQLProtocol.GraphQLProtocol, {
-     *   execute: (request) => {
-     *     calls++
-     *     const { ids } = request.variables as { ids: Array<string> }
-     *     return Effect.succeed({ body: { data: { nodes: ids.map((id) => ({ name: `repo-${id}` })) } } })
-     *   },
-     *   subscribe: () => Stream.empty
-     * })
-     *
-     * const program = Effect.gen(function*() {
-     *   const client = yield* GraphQLClient.make(GraphQLGroup.make(RepoNodes))
-     *   const getRepo = GraphQLResolver.request(GraphQLResolver.ordered(client.RepoNodes, {
-     *     variables: (ids: ReadonlyArray<string>) => ({ ids }),
-     *     path: ["nodes"]
-     *   }))
-     *   const repos = yield* Effect.forEach(["1", "2", "1"], getRepo, { concurrency: "unbounded" })
-     *   return [repos.map((repo) => repo.name), calls]
-     * })
-     *
-     * await Effect.runPromise(program.pipe(Effect.provide(Scripted))) // => [["repo-1", "repo-2", "repo-1"], 1]
-     * ```
-     *
-     * @stability experimental
-     * @category running
-     * @since 4.0.0
-     */
-    E, // -----------------------------------------------------------------------------
-    // Running
-    // -----------------------------------------------------------------------------
-
-    /**
-     * Looks up a key with an {@link ordered}, {@link findById} or {@link aliased}
-     * resolver, using `request(resolver)(key)` or `request(key, resolver)`.
-     *
-     * **Details**
-     *
-     * Concurrent lookups are batched. Keys equal under `Equal` and `Hash`
-     * are sent once per batch and share the result.
-     *
-     * **Example** (Looking up repositories by id)
-     *
-     * ```ts import.meta.vitest
-     * import { Effect, Layer, Schema, Stream } from "effect"
-     * import { GraphQL, GraphQLClient, GraphQLGroup, GraphQLProtocol, GraphQLResolver } from "effect/graphql"
-     *
-     * const RepoNodes = GraphQL.query("RepoNodes", {
-     *   document: "query RepoNodes($ids:[ID!]!){nodes(ids:$ids){... on Repository{name}}}",
-     *   variables: { ids: Schema.Array(Schema.String) },
-     *   result: Schema.Struct({ nodes: Schema.Array(Schema.NullOr(Schema.Struct({ name: Schema.String }))) })
-     * })
-     *
-     * let calls = 0
-     * const Scripted = Layer.succeed(GraphQLProtocol.GraphQLProtocol, {
-     *   execute: (request) => {
-     *     calls++
-     *     const { ids } = request.variables as { ids: Array<string> }
-     *     return Effect.succeed({ body: { data: { nodes: ids.map((id) => ({ name: `repo-${id}` })) } } })
-     *   },
-     *   subscribe: () => Stream.empty
-     * })
-     *
-     * const program = Effect.gen(function*() {
-     *   const client = yield* GraphQLClient.make(GraphQLGroup.make(RepoNodes))
-     *   const getRepo = GraphQLResolver.request(GraphQLResolver.ordered(client.RepoNodes, {
-     *     variables: (ids: ReadonlyArray<string>) => ({ ids }),
-     *     path: ["nodes"]
-     *   }))
-     *   const repos = yield* Effect.forEach(["1", "2", "1"], getRepo, { concurrency: "unbounded" })
-     *   return [repos.map((repo) => repo.name), calls]
-     * })
-     *
-     * await Effect.runPromise(program.pipe(Effect.provide(Scripted))) // => [["repo-1", "repo-2", "repo-1"], 1]
-     * ```
-     *
-     * @stability experimental
-     * @category running
-     * @since 4.0.0
-     */
-    R>(key), resolver)
+  <K, A, E, R>(key: K, resolver: RequestResolver.RequestResolver<KeyRequest<K, A, E, R>>): Effect.Effect<A, E, R> => {
+    // Resolved in the caller's fiber, so the URL is part of the pending batch's key.
+    const resolveUrl = urlResolvers.get(resolver.batchKey)
+    return resolveUrl === undefined
+      ? queue(makeRequest<K, A, E, R>(key, undefined), resolver)
+      : Effect.flatMap(resolveUrl, (url) => queue(makeRequest<K, A, E, R>(key, url), resolver))
+  }
 )
 
 // -----------------------------------------------------------------------------
@@ -556,6 +361,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 +495,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 +639,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 +647,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 +698,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 +721,95 @@ 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.
+ * URL resolvers by resolver `batchKey`, which `RequestResolver.batchN` and
+ * `setDelay` keep, so {@link request} can resolve a lookup's URL before it is
+ * queued.
  */
-const makeResolver = <A extends Request.Any>(
+const urlResolvers = new WeakMap<Function, Effect.Effect<string>>()
+
+/**
+ * Groups pending entries by URL and `batchKey`, so collection limits apply to
+ * each group. A URL that `request` couldn't resolve, for example after
+ * `RequestResolver.grouped` replaced the key, is resolved here in the entry's
+ * context, and the batch is split again. Each batch runs in its first entry's
+ * context, under any span opened around the batch, carrying the URL it was
+ * grouped by, so the transport doesn't resolve it again.
+ */
+const makeResolver = <A extends KeyRequest<any, any, any, 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 resolveUrl = resolve?.({ kind: method.operation.kind, operationName: method.operation.name })
+  // Arrays are compared structurally, so equal keys share a batch.
+  const keyOf = (entry: Request.Entry<A>, url: string | undefined) => [url, batchKey?.(entry.context)] as const
+  const urlOf = (entry: Request.Entry<A>) =>
+    entry.request.url !== undefined || resolveUrl === undefined
+      ? Effect.succeed(entry.request.url)
+      : runIn(resolveUrl, entry.context)
+  const resolver = RequestResolver.makeGrouped<A, unknown>({
+    key: (entry) => keyOf(entry, entry.request.url),
+    resolver: (entries) =>
+      Effect.contextWith((current: Context.Context<never>) => {
+        const span = batchSpan(current)
+        return Effect.flatMap(Effect.forEach(entries, urlOf, { concurrency: "unbounded" }), (urls) => {
+          const batches = MutableHashMap.empty<
+            readonly [string | undefined, unknown],
+            Arr.NonEmptyArray<Request.Entry<A>>
+          >()
+          entries.forEach((entry, i) => {
+            const key = keyOf(entry, urls[i])
+            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]) => {
+            let context: Context.Context<any> = entries[0].context
+            if (url !== undefined) context = Context.add(context, internalGraphQL.ResolvedUrl, { resolve, url })
+            if (span !== undefined) context = Context.add(context, Tracer.ParentSpan, span)
+            return runIn(runAll(entries), context)
+          }, { concurrency: "unbounded", discard: true })
+        })
+      })
+  })
+  if (resolveUrl !== undefined) urlResolvers.set(resolver.batchKey, resolveUrl)
+  return resolver
+}
+
+// Replaces, rather than merges into, the batch fiber's context, which may
+// belong to a lookup with other services or `Context.Reference` values.
+const runIn = <A, E>(effect: Effect.Effect<A, E, any>, context: Context.Context<any>): Effect.Effect<A, E> =>
+  Effect.updateContext(effect, (_: Context.Context<never>) => context)
+
+// The caller's span when it queued a lookup. A batch fiber inherits it from the
+// caller that started or filled the batch, even if that caller was interrupted.
+const QueuedSpan = Context.Reference<Tracer.AnySpan | undefined>("effect/graphql/GraphQLResolver/QueuedSpan", {
+  defaultValue: () => undefined
+})
+
+const queue = <K, A, E, R>(
+  request: KeyRequest<K, A, E, R>,
+  resolver: RequestResolver.RequestResolver<KeyRequest<K, A, E, R>>
+): Effect.Effect<A, E, R> =>
+  Effect.contextWith((context: Context.Context<never>) =>
+    Effect.provideService(
+      Effect.request(request, resolver),
+      QueuedSpan,
+      Context.getOrUndefined(context, Tracer.ParentSpan)
+    )
+  )
+
+// A span opened around the batch, such as `RequestResolver.withSpan`'s, rather
+// than the one the batch fiber inherited from a caller.
+const batchSpan = (context: Context.Context<never>) => {
+  const span = Context.getOrUndefined(context, Tracer.ParentSpan)
+  return span === Context.get(context, QueuedSpan) ? undefined : span
+}
 
 /**
- * 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 +841,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

@@ -6,6 +6,9 @@
  * runtimes, and Node.js environments where `globalThis.fetch` is available, or
  * anywhere a compatible fetch function can be supplied.
  *
+ * Requests with an `Upgrade` header fail with `TransportError` before anything
+ * is sent because fetch cannot hand over the connection.
+ *
  * @stability unstable
  * @since 4.0.0
  */
@@ -45,6 +48,8 @@ export const Fetch = Context.Reference<typeof globalThis.fetch>("effect/http/Fet
  *
  * Request-specific method, headers, body, and abort signal are supplied by the client when a request is executed.
  *
+ * @see {@link HttpClient.followRedirects} for following redirects in the client, which needs `{ redirect: "manual" }` here
+ *
  * @stability unstable
  * @category services
  * @since 4.0.0
@@ -54,6 +59,16 @@ export class RequestInit extends Context.Service<RequestInit, globalThis.Request
 ) {}
 
 const fetch: HttpClient.HttpClient = HttpClient.make((request, url, signal, fiber) => {
+  if (request.headers.upgrade !== undefined) {
+    return Effect.fail(
+      new HttpClientError.HttpClientError({
+        reason: new HttpClientError.TransportError({
+          request,
+          description: "fetch cannot send an HTTP upgrade request"
+        })
+      })
+    )
+  }
   const fetch = fiber.getRef(Fetch)
   const options: globalThis.RequestInit = Context.getOrUndefined(fiber.context, RequestInit) ?? {}
   let headers = options.headers
@@ -62,6 +77,8 @@ const fetch: HttpClient.HttpClient = HttpClient.make((request, url, signal, fibe
   if (headers["content-length"]) {
     headers = Headers.remove(headers, "content-length")
   }
+  let uploadController: AbortController | undefined
+  const stopUpload = Effect.sync(() => uploadController?.abort())
   const send = (body: BodyInit | undefined) =>
     Effect.map(
       Effect.tryPromise({
@@ -72,7 +89,7 @@ const fetch: HttpClient.HttpClient = HttpClient.make((request, url, signal, fibe
             headers,
             body,
             duplex: typeof ReadableStream !== "undefined" && body instanceof ReadableStream ? "half" : undefined,
-            signal
+            signal: uploadController ? AbortSignal.any([signal, uploadController.signal]) : signal
           } as any),
         catch: (cause) =>
           new HttpClientError.HttpClientError({
@@ -82,16 +99,47 @@ const fetch: HttpClient.HttpClient = HttpClient.make((request, url, signal, fibe
             })
           })
       }),
-      (response) => HttpClientResponse.fromWeb(request, response)
-    )
+      (response) => {
+        const original = HttpClientResponse.fromWeb(request, response)
+        if (!uploadController) return original
+        if (response.body === null) uploadController.abort()
+        // Finishing or releasing either response reader ends the upload, not
+        // merely receiving headers. Keep the original response and its caches,
+        // and inherit its Web source so `toWeb` hands over the original body.
+        return Object.create(original, {
+          ...Object.fromEntries(
+            (["arrayBuffer", "text", "json", "formData", "urlParamsBody"] as const).map((key) => [key, {
+              get: () =>
+                Effect.ensuring(original[key] as Effect.Effect<unknown, HttpClientError.HttpClientError>, stopUpload)
+            }])
+          ),
+          stream: { get: () => Stream.ensuring(original.stream, stopUpload) }
+        }) as HttpClientResponse.HttpClientResponse
+      }
+    ).pipe(Effect.onError(() => stopUpload))
   switch (request.body._tag) {
     case "Raw":
     case "Uint8Array":
       return send(request.body.body as any)
     case "FormData":
       return send(request.body.formData)
-    case "Stream":
-      return Effect.flatMap(Stream.toReadableStreamEffect(request.body.stream), send)
+    case "Stream": {
+      uploadController = new AbortController()
+      const uploadSignal = AbortSignal.any([signal, uploadController.signal])
+      const stopped = Effect.callback<void>((resume) => {
+        const onAbort = () => resume(Effect.interrupt)
+        if (uploadSignal.aborted) {
+          onAbort()
+          return
+        }
+        uploadSignal.addEventListener("abort", onAbort, { once: true })
+        return Effect.sync(() => uploadSignal.removeEventListener("abort", onAbort))
+      })
+      return Effect.flatMap(
+        Stream.toReadableStreamEffect(Stream.interruptWhen(request.body.stream, stopped)),
+        send
+      )
+    }
   }
   return send(undefined)
 })
@@ -115,12 +163,17 @@ 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.
+ * `fetch` follows redirects itself by default, so `HttpClient.followRedirects`
+ * has no effect unless `RequestInit` sets `redirect: "manual"`. 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

@@ -49,6 +49,12 @@ export const make = <A>(
   options: Partial<Router.RouterConfig> = {}
 ): Router.Router<A> => new RouterImpl(options)
 
+/** @internal */
+export const getMaxParamLengthExceeded = <A>(router: Router.Router<A>): number | undefined => {
+  const impl = router as RouterImpl<A>
+  return impl.maxParamLengthExceeded ? impl.options.maxParamLength : undefined
+}
+
 class RouterImpl<A> implements Router.Router<A> {
   constructor(options: Partial<Router.RouterConfig> = {}) {
     this.options = {
@@ -61,6 +67,7 @@ class RouterImpl<A> implements Router.Router<A> {
   }
 
   readonly options: Router.RouterConfig
+  maxParamLengthExceeded = false
   routes: Array<Route> = []
   trees: Record<string, StaticNode> = Object.create(null)
   staticRoutes: Record<string, Map<string, Handler>> = Object.create(null)
@@ -309,6 +316,7 @@ class RouterImpl<A> implements Router.Router<A> {
   }
 
   find(method: string, path: string): Router.FindResult<A> | undefined {
+    this.maxParamLengthExceeded = false
     let currentNode: Node | undefined = this.trees[method]
     if (currentNode === undefined) return undefined
 
@@ -394,6 +402,7 @@ class RouterImpl<A> implements Router.Router<A> {
             searchParams: QS.parse(querystring)
           } as const
         }
+        this.maxParamLengthExceeded = true
       }
     }
 
@@ -483,6 +492,7 @@ class RouterImpl<A> implements Router.Router<A> {
             const matchedParam = matchedParameters[i] ?? ""
             if (matchedParam.length > maxParamLength) {
               maxParamLengthExceeded = true
+              this.maxParamLengthExceeded = true
               break
             }
           }
@@ -504,6 +514,7 @@ class RouterImpl<A> implements Router.Router<A> {
           }
         } else {
           if (param.length > maxParamLength) {
+            this.maxParamLengthExceeded = true
             if (brothersNodesStack.length === 0) {
               return undefined
             }
@@ -857,7 +868,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