@effect-app/infra 4.0.0-beta.25 → 4.0.0-beta.250

package/test/router-generator.test.ts

@@ -0,0 +1,187 @@
+import { type MakeContext, type MakeErrors, makeRouter } from "@effect-app/infra/routing"
+import { expectTypeOf, it } from "@effect/vitest"
+import { InvalidStateError, makeRpcClient, UnauthorizedError } from "effect-app/client"
+import * as Context from "effect-app/Context"
+import * as Effect from "effect-app/Effect"
+import * as Layer from "effect-app/Layer"
+import { DefaultGenericMiddlewares } from "effect-app/middleware"
+import { makeAllDSL, makeOneDSL } from "effect-app/Model"
+import { type FixEnv } from "effect-app/Pure"
+import * as RpcX from "effect-app/rpc"
+import { MiddlewareMaker } from "effect-app/rpc"
+import * as S from "effect-app/Schema"
+import { type TypeTestId } from "effect-app/TypeTest"
+import { type ConfigError } from "effect/Config"
+import { type RpcSerialization } from "effect/unstable/rpc/RpcSerialization"
+import { DefaultGenericMiddlewaresLive, DevModeMiddlewareLive } from "../src/routing/middleware.js"
+import { AllowAnonymous, AllowAnonymousLive, RequestContextMap, RequireRoles, RequireRolesLive, Some, SomeElse, SomeService, Test, TestLive } from "./fixtures.js"
+
+// Inline minimal context provider (provides `Some`)
+class CtxProvider extends RpcX.RpcMiddleware.Tag<CtxProvider, { provides: Some }>()("CtxProvider") {
+  static Default = Layer.make(this, {
+    *make() {
+      return Effect.fnUntraced(function*(effect) {
+        return yield* Effect.provideService(effect, Some, Some.of({ a: 1 }))
+      })
+    }
+  })
+}
+
+// Provides `SomeElse` so AllowAnonymous's requirement is met.
+class SomeElseProvider extends RpcX.RpcMiddleware.Tag<SomeElseProvider, { provides: SomeElse }>()("SomeElseProvider") {
+  static Default = Layer.make(this, {
+    *make() {
+      return Effect.fnUntraced(function*(effect) {
+        return yield* Effect.provideService(effect, SomeElse, SomeElse.of({ b: 2 }))
+      })
+    }
+  })
+}
+
+class mw extends MiddlewareMaker
+  .Tag<mw>()("mw", RequestContextMap)
+  .middleware(RequireRoles, Test)
+  .middleware(AllowAnonymous)
+  .middleware(CtxProvider)
+  .middleware(...DefaultGenericMiddlewares, SomeElseProvider)
+{
+  static Default = this.layer.pipe(
+    Layer.provide([
+      RequireRolesLive,
+      TestLive,
+      AllowAnonymousLive,
+      CtxProvider.Default,
+      SomeElseProvider.Default,
+      DefaultGenericMiddlewaresLive,
+      DevModeMiddlewareLive,
+      SomeService.Default
+    ])
+  )
+}
+
+const { TaggedRequestFor } = makeRpcClient(mw)
+const Req = TaggedRequestFor("GenRouter")
+
+class GetThing extends Req.Query<GetThing>()("GetThing", { id: S.String }, {
+  success: S.String,
+  error: UnauthorizedError
+}) {}
+class DoThing extends Req.Command<DoThing>()("DoThing", { id: S.String }, { success: S.Void }) {}
+
+const Resource = { GetThing, DoThing }
+
+const { Router, matchAll } = makeRouter(mw.Default)
+
+class ThingRepo extends Context.Service<ThingRepo>()("ThingRepo", {
+  make: Effect.succeed({ get: (id: string) => Effect.succeed(id + "!") })
+}) {
+  static Default = Layer.effect(this, this.make)
+}
+
+// Case under test:
+// `match({})` is given handlers as **shorthand generator methods** (`*GetThing(req) { ... }`).
+// tsgo (>= 7 dev) infers `TNext = unknown` for these shorthand generators while TS6 infers `never`.
+// `HandlerWithInputGen` in routing.ts must accept both — see the structural fix.
+const router = Router(Resource)({
+  dependencies: [ThingRepo.Default],
+  *effect(match) {
+    const repo = yield* ThingRepo
+
+    if (Math.random() > 0.5) return yield* new InvalidStateError("nope")
+
+    return match({
+      *GetThing(req) {
+        const some = yield* Some
+        if (req.id === "boom") {
+          return yield* Effect.fail(new UnauthorizedError())
+        }
+        return yield* repo.get(req.id + String(some.a))
+      },
+      *DoThing(_req) {
+        yield* Effect.succeed(1)
+      }
+    })
+  }
+})
+
+// Same scenario but using the `raw:` variant — exercises the `raw` path of `HandlerWithInputGen`.
+const routerRaw = Router({ GetThing })({
+  *effect(match) {
+    return match({
+      GetThing: {
+        *raw(req) {
+          const some = yield* Some
+          return yield* Effect.succeed(req.id + String(some.a))
+        }
+      }
+    })
+  }
+})
+
+it("router with generator-method handlers compiles", () => {
+  expectTypeOf(router).toMatchTypeOf<
+    Layer.Layer<never, ConfigError | InvalidStateError, SomeService | RpcSerialization>
+  >()
+  expectTypeOf(routerRaw).toMatchTypeOf<Layer.Layer<never, ConfigError, SomeService | RpcSerialization>>()
+})
+
+// Type-level assertions: verify generator yields propagate to MakeErrors / MakeContext
+type Errors = MakeErrors<typeof router[TypeTestId]>
+type Ctx = MakeContext<typeof router[TypeTestId]>
+expectTypeOf<Errors>().toEqualTypeOf<InvalidStateError>()
+expectTypeOf<Ctx>().toEqualTypeOf<ThingRepo>()
+
+const matched = matchAll({ router })
+expectTypeOf(matched).toMatchTypeOf<
+  Layer.Layer<never, ConfigError | InvalidStateError, SomeService | RpcSerialization>
+>()
+
+// ---------------------------------------------------------------------------
+// DSL R-inference regression
+// ---------------------------------------------------------------------------
+// `OneDSL`/`OneDSLExt.update`/`.modify` previously annotated the callback's
+// effect R as `FixEnv<R, Evt, S1, S2>`. That deadlocked inference of `R`
+// (TS6 → `never`, tsgo → `unknown`), causing yielded effects to leak
+// `unknown` in the R slot when consumed by generator handlers.
+// The fix uses bare `R` in the callback and `FixEnv<R, …>` only on the return.
+class Item extends S.Class<Item>("Item")({ id: S.String, label: S.String }) {}
+class Dep extends Context.Service<Dep>()("Dep", { make: Effect.succeed({ tag: "dep" as const }) }) {}
+
+type Evt = { _tag: "Updated"; id: string }
+
+const Items$ = makeAllDSL<Item, Evt>()
+const Item$ = makeOneDSL<Item, Evt>()
+
+// Callback body uses generator syntax (TNext = unknown under tsgo) and yields
+// a service-dependent effect — R must be inferred as `Dep` (plus the
+// canonical PureEnvEnv contributed by FixEnv on the return).
+const oneUpdate = Item$.update((item) =>
+  Effect.gen(function*() {
+    const dep = yield* Dep
+    return new Item({ id: item.id, label: item.label + dep.tag })
+  })
+)
+
+const allUpdate = Items$.update((items) =>
+  Effect.gen(function*() {
+    const dep = yield* Dep
+    return items.map((_) => new Item({ id: _.id, label: _.label + dep.tag }))
+  })
+)
+
+const oneModify = Item$.modify((item, _dsl) =>
+  Effect.gen(function*() {
+    const dep = yield* Dep
+    return { ...item, tag: dep.tag }
+  })
+)
+
+// `R` should be `FixEnv<Dep, Evt, …>` — never collapsed to `unknown`/`never`.
+// The regression manifested as `unknown` here, breaking `Dep` assignability.
+expectTypeOf(oneUpdate).toMatchTypeOf<Effect.Effect<Item, never, FixEnv<Dep, Evt, Item, Item>>>()
+expectTypeOf(allUpdate).toMatchTypeOf<
+  Effect.Effect<readonly Item[], never, FixEnv<Dep, Evt, readonly Item[], readonly Item[]>>
+>()
+expectTypeOf(oneModify).toMatchTypeOf<
+  Effect.Effect<{ tag: "dep"; id: string; label: string }, never, FixEnv<Dep, Evt, Item, Item>>
+>()

package/test/routing-interruptibility.test.ts

@@ -0,0 +1,66 @@
+import { describe, expect, it } from "@effect/vitest"
+import { ConfigureInterruptibilityMiddleware } from "effect-app/middleware"
+import * as S from "effect-app/Schema"
+import * as Effect from "effect/Effect"
+import * as Fiber from "effect/Fiber"
+import * as Layer from "effect/Layer"
+import * as Ref from "effect/Ref"
+import { Rpc, RpcGroup, RpcTest } from "effect/unstable/rpc"
+import { applyRequestTypeInterruptibility } from "../src/routing.js"
+import { ConfigureInterruptibilityMiddlewareLive, RequestType } from "../src/routing/middleware.js"
+
+const InterruptibilityRpcs = RpcGroup.make(
+  Rpc
+    .make("doCommand", { success: S.Void })
+    .annotate(RequestType, "command")
+    .middleware(ConfigureInterruptibilityMiddleware),
+  Rpc
+    .make("doQuery", { success: S.Void })
+    .annotate(RequestType, "query")
+    .middleware(ConfigureInterruptibilityMiddleware)
+)
+
+const makeImplLayer = (commandDone: Ref.Ref<boolean>, queryDone: Ref.Ref<boolean>) =>
+  InterruptibilityRpcs.toLayer({
+    doCommand: () =>
+      applyRequestTypeInterruptibility(
+        "command",
+        Effect.sleep("120 millis").pipe(Effect.andThen(Ref.set(commandDone, true)))
+      ),
+    doQuery: () =>
+      applyRequestTypeInterruptibility(
+        "query",
+        Effect.sleep("120 millis").pipe(Effect.andThen(Ref.set(queryDone, true)))
+      )
+  })
+
+describe("routing interruptibility", () => {
+  it.live(
+    "e2e: command continues after client interrupt, query does not",
+    () =>
+      Effect.gen(function*() {
+        const commandDone = yield* Ref.make(false)
+        const queryDone = yield* Ref.make(false)
+
+        const client = yield* RpcTest
+          .makeClient(InterruptibilityRpcs)
+          .pipe(
+            Effect.provide(
+              Layer.mergeAll(makeImplLayer(commandDone, queryDone), ConfigureInterruptibilityMiddlewareLive)
+            )
+          )
+
+        const commandFiber = yield* Effect.forkDetach(client.doCommand())
+        yield* Effect.sleep("20 millis")
+        yield* Fiber.interrupt(commandFiber)
+        yield* Effect.sleep("180 millis")
+        expect(yield* Ref.get(commandDone)).toBe(true)
+
+        const queryFiber = yield* Effect.forkDetach(client.doQuery())
+        yield* Effect.sleep("20 millis")
+        yield* Fiber.interrupt(queryFiber)
+        yield* Effect.sleep("180 millis")
+        expect(yield* Ref.get(queryDone)).toBe(false)
+      })
+  )
+})

package/test/rpc-context-map-streaming.test.ts

@@ -0,0 +1,262 @@
+/**
+ * E2E test for commit bb3f51d03 — `fix(infra): bind ContextMap to request scope
+ * for SSE streams`.
+ *
+ * Background
+ * ----------
+ *   The RpcServer returns `HttpServerResponse.stream(...)` for streaming RPC
+ *   resources. The body of that response keeps producing chunks AFTER the
+ *   outer Effect that built the response has returned. `RequestContextMiddleware`
+ *   provisions `ContextMapContainer` for the request. The acquireRelease
+ *   inside `ContextMapContainer.layer` calls `clear()` on finalize, wiping
+ *   the etag map and the per-request resolver/store cache.
+ *
+ *   If that layer is built against a sub-scope of the outer Effect (the
+ *   pre-fix behaviour: `Effect.provide(layer)`), the finalizer fires as soon
+ *   as the middleware Effect returns the HttpServerResponse — i.e. between
+ *   "handler done" and "first chunk written" — wiping ContextMap state that
+ *   later chunks still need. In production this surfaces as spurious
+ *   OptimisticConcurrencyException on writes that follow a streaming read.
+ *
+ *   The fix binds the layer to the ambient request scope via
+ *   `provideOnRequestScope`, so `clear()` only runs once the response body
+ *   has fully drained.
+ *
+ * Reproduction strategy
+ * ---------------------
+ *   - Mirror the production wiring: apply `RequestContextMiddleware` to the
+ *     RPC router (see `boilerplate/api/src/router.ts`).
+ *   - The stream handler sets an etag on the ContextMap BEFORE returning the
+ *     Stream value.
+ *   - The Stream emits three values 100ms apart; each emission reads back the
+ *     etag via `getContextMap` and yields 1 if the value is still present,
+ *     0 otherwise.
+ *   - Expectation: [1, 1, 1]. If the layer's `clear()` runs mid-stream the
+ *     later chunks observe an empty map and the assertion fails (typically
+ *     with [1, 0, 0] or [0, 0, 0]).
+ */
+import { NodeHttpServer } from "@effect/platform-node"
+import { expect, it } from "@effect/vitest"
+import { ApiClientFactory, makeRpcClient } from "effect-app/client"
+import { HttpRouter, HttpServer } from "effect-app/http"
+import { DefaultGenericMiddlewares } from "effect-app/middleware"
+import { MiddlewareMaker } from "effect-app/rpc"
+import * as S from "effect-app/Schema"
+import { getContextMap } from "effect-app/Store"
+import * as Effect from "effect/Effect"
+import * as Layer from "effect/Layer"
+import * as Option from "effect/Option"
+import * as Stream from "effect/Stream"
+import { FetchHttpClient } from "effect/unstable/http"
+import { RpcSerialization } from "effect/unstable/rpc"
+import { createServer } from "http"
+import { RequestContextMiddleware } from "../src/internal/RequestContextMiddleware.js"
+import { makeRouter } from "../src/routing.js"
+import { DefaultGenericMiddlewaresLive } from "../src/routing/middleware.js"
+import { AllowAnonymous, AllowAnonymousLive, RequestContextMap, RequireRoles, RequireRolesLive, SomeElseMiddleware, SomeElseMiddlewareLive, SomeService, Test, TestLive } from "./fixtures.js"
+
+// ---------------------------------------------------------------------------
+// Middleware — mirrors AppMiddleware shape used by the other rpc e2e tests.
+// ---------------------------------------------------------------------------
+
+class AppMiddleware extends MiddlewareMaker
+  .Tag<AppMiddleware>()("AppMiddleware", RequestContextMap)
+  .middleware(RequireRoles, Test)
+  .middleware(AllowAnonymous)
+  .middleware(SomeElseMiddleware)
+  .middleware(...DefaultGenericMiddlewares)
+{
+  static Default = this.layer.pipe(
+    Layer.provide(
+      [
+        RequireRolesLive.pipe(Layer.provide(SomeService.Default)),
+        AllowAnonymousLive,
+        TestLive,
+        SomeElseMiddlewareLive,
+        DefaultGenericMiddlewaresLive
+      ] as const
+    )
+  )
+}
+
+const { Router, matchAll } = makeRouter(AppMiddleware.Default)
+
+// ---------------------------------------------------------------------------
+// Resource — single streaming command that exercises ContextMap mid-stream.
+// ---------------------------------------------------------------------------
+
+const { TaggedRequestFor } = makeRpcClient(AppMiddleware)
+const Req = TaggedRequestFor("CtxMap")
+
+class StreamEtag extends Req.Command<StreamEtag>()("StreamEtag", {}, {
+  stream: true,
+  allowAnonymous: true,
+  success: S.Number
+}) {}
+
+// Per-request isolation probes: each handler writes a caller-supplied value to
+// the SHARED key, then emits 3 chunks each re-reading the SHARED key. If two
+// concurrent requests share a ContextMap, the second writer overwrites the
+// first and the first request observes the wrong value mid-stream.
+class StreamWithEtag extends Req.Command<StreamWithEtag>()("StreamWithEtag", {
+  value: S.String
+}, {
+  stream: true,
+  allowAnonymous: true,
+  success: S.String
+}) {}
+
+class ReadEtagOnce extends Req.Query<ReadEtagOnce>()("ReadEtagOnce", {}, {
+  allowAnonymous: true,
+  success: S.String
+}) {}
+
+const Rsc = { StreamEtag, StreamWithEtag, ReadEtagOnce }
+
+// Distinct constants so an assertion failure points squarely at "the etag
+// the handler wrote was no longer there when later chunks ran".
+const ETAG_ID = "ctxmap-test-id"
+const ETAG_VALUE = "v1"
+const SHARED_KEY = "ctxmap-shared-key"
+const MISSING = "<missing>"
+
+const router = Router(Rsc)({
+  *effect(match) {
+    return match({
+      StreamEtag: () =>
+        Effect
+          .gen(function*() {
+            // 1) Acquire the request-scoped ContextMap. Fails (dies) if the
+            //    container is still the default "root" — which would mean
+            //    RequestContextMiddleware did not run for this request.
+            const ctxMap = yield* getContextMap.pipe(Effect.orDie)
+            // 2) Seed an etag BEFORE handing back the Stream. This write is
+            //    what the per-chunk readers below verify.
+            ctxMap.set(ETAG_ID, ETAG_VALUE)
+            // 3) Emit three values 100ms apart so chunks are produced AFTER
+            //    the outer Effect that built the response has returned. Each
+            //    emission re-reads the etag from the request-scoped ContextMap.
+            return Stream.fromIterable([0, 1, 2]).pipe(
+              Stream.mapEffect(() =>
+                Effect.sleep("100 millis").pipe(
+                  Effect.flatMap(() => getContextMap.pipe(Effect.orDie)),
+                  Effect.map((m) => m.get(ETAG_ID) === ETAG_VALUE ? 1 : 0)
+                )
+              )
+            )
+          })
+          .pipe(Stream.unwrap),
+      StreamWithEtag: ({ value }: { readonly value: string }) =>
+        Effect
+          .gen(function*() {
+            const ctxMap = yield* getContextMap.pipe(Effect.orDie)
+            ctxMap.set(SHARED_KEY, value)
+            return Stream.fromIterable([0, 1, 2]).pipe(
+              Stream.mapEffect(() =>
+                Effect.sleep("100 millis").pipe(
+                  Effect.flatMap(() => getContextMap.pipe(Effect.orDie)),
+                  Effect.map((m) => m.get(SHARED_KEY) ?? MISSING)
+                )
+              )
+            )
+          })
+          .pipe(Stream.unwrap),
+      ReadEtagOnce: () => getContextMap.pipe(Effect.orDie, Effect.map((m) => m.get(SHARED_KEY) ?? MISSING))
+    })
+  }
+})
+
+const RpcRouterLayer = matchAll({ router })
+
+// ---------------------------------------------------------------------------
+// HTTP wiring — fresh server on a loopback port per `it.live`. The critical
+// difference vs. rpc-stream-fullstack: we apply `RequestContextMiddleware`
+// here, exactly as the production boilerplate does, so the fix code path
+// is what runs.
+// ---------------------------------------------------------------------------
+
+const NodeServerLayer = NodeHttpServer.layer(() => createServer(), { port: 0 })
+
+const RequestContextMiddlewareLayer = HttpRouter.middleware(RequestContextMiddleware()).layer
+
+const ServerLayer = HttpRouter
+  .serve(
+    RpcRouterLayer.pipe(Layer.provide(RequestContextMiddlewareLayer))
+  )
+  .pipe(
+    Layer.provide(NodeServerLayer),
+    Layer.provide(RpcSerialization.layerNdjson)
+  )
+
+const ClientLayer = Layer
+  .unwrap(
+    Effect.gen(function*() {
+      const server = yield* HttpServer.HttpServer
+      const addr = server.address
+      if (addr._tag !== "TcpAddress") return yield* Effect.die(new Error("expected TcpAddress"))
+      const host = addr.hostname === "0.0.0.0" ? "127.0.0.1" : addr.hostname
+      const url = `http://${host}:${addr.port}`
+      return ApiClientFactory
+        .layer({ url, headers: Option.none() })
+        .pipe(Layer.provide(FetchHttpClient.layer))
+    })
+  )
+  .pipe(Layer.provide(NodeServerLayer))
+
+const TestLayer = Layer.mergeAll(ServerLayer, ClientLayer)
+
+// ---------------------------------------------------------------------------
+// Test
+// ---------------------------------------------------------------------------
+
+it.live(
+  "ContextMap survives mid-stream: etag set in handler is readable by every chunk",
+  Effect.fnUntraced(function*() {
+    const client = yield* ApiClientFactory.makeFor(Layer.empty)(Rsc)
+    const values = yield* Stream.runCollect(client.StreamEtag.handler())
+    // All three chunks emit 1 → the etag was still readable when each chunk
+    // executed. If the layer-bound ContextMap's `clear()` finalizer fired
+    // mid-stream (the pre-fix behaviour), later chunks would emit 0.
+    expect(values).toStrictEqual([1, 1, 1])
+  }, Effect.provide(TestLayer)),
+  { timeout: 10_000 }
+)
+
+it.live(
+  "succeeding requests get a fresh ContextMap: request N+1 cannot see request N's writes",
+  Effect.fnUntraced(function*() {
+    const client = yield* ApiClientFactory.makeFor(Layer.empty)(Rsc)
+    // 1st request writes SHARED_KEY = "first" and drains its stream so its
+    // request scope (and ContextMap) is closed before request 2 starts.
+    const first = yield* Stream.runCollect(client.StreamWithEtag.handler({ value: "first" }))
+    expect(first).toStrictEqual(["first", "first", "first"])
+    // 2nd request must NOT observe the previous request's value at any point.
+    const peek = yield* client.ReadEtagOnce.handler()
+    expect(peek).toBe(MISSING)
+    // 3rd request writes a different value and drains; must not be polluted by request 1.
+    const third = yield* Stream.runCollect(client.StreamWithEtag.handler({ value: "third" }))
+    expect(third).toStrictEqual(["third", "third", "third"])
+  }, Effect.provide(TestLayer)),
+  { timeout: 10_000 }
+)
+
+it.live(
+  "overlapping requests get isolated ContextMaps: concurrent streams see only their own writes",
+  Effect.fnUntraced(function*() {
+    const client = yield* ApiClientFactory.makeFor(Layer.empty)(Rsc)
+    // Two streams in flight at the same time, each writing the SAME key with a
+    // different value. With per-request maps each stream reads back only its
+    // own value across all chunks. With a shared map the later writer's value
+    // would leak into the earlier stream's later chunks.
+    const [a, b] = yield* Effect.all(
+      [
+        Stream.runCollect(client.StreamWithEtag.handler({ value: "alpha" })),
+        Stream.runCollect(client.StreamWithEtag.handler({ value: "beta" }))
+      ],
+      { concurrency: "unbounded" }
+    )
+    expect(a).toStrictEqual(["alpha", "alpha", "alpha"])
+    expect(b).toStrictEqual(["beta", "beta", "beta"])
+  }, Effect.provide(TestLayer)),
+  { timeout: 10_000 }
+)