@gjermundgaraba/effect-actions 0.20.0 → 0.21.0

package/examples/kitchen-sink/test/identity/session.test.ts

@@ -1,27 +1,29 @@
 import { describe, expect, it } from "@effect/vitest";
-import { Array, Effect, flow, Layer } from "effect";
-import { HttpClient, HttpClientRequest } from "effect/http";
-import { RpcClient, RpcSerialization, RpcServer } from "effect/rpc";
 import * as Action from "@gjermundgaraba/effect-actions/Action";
 import * as ActionHttp from "@gjermundgaraba/effect-actions/ActionHttp";
 import * as ActionRpc from "@gjermundgaraba/effect-actions/ActionRpc";
 import * as Testing from "@gjermundgaraba/effect-actions/Testing";
+import { Array, Effect, flow, Layer } from "effect";
+import { HttpClient, HttpClientRequest } from "effect/http";
+import { RpcClient, RpcSerialization, RpcServer } from "effect/rpc";
+
 import { Http } from "../../src/Api.js";
 import { QuotaExceeded } from "../../src/identity/Identity.js";
 import { memory } from "../../src/memory.js";
 import { publicRoutes, rpc } from "../../src/routes.js";
 import { Rpc } from "../../src/Rpc.js";
 import { WorkspaceRegistry } from "../../src/workspaces/registry.js";
+import { services } from "../support/services.js";
 
 // The web app's rpcs in memory. The server serves them over a WebSocket; here the same layer
 // is given Effect's HTTP protocol, which a client reaches through `Testing.layer`.
 const server = rpc.pipe(
   Layer.provide(RpcServer.layerProtocolHttp({ path: "/rpc" })),
-  Layer.provide(RpcSerialization.layerJson),
+  Layer.provide(RpcSerialization.layerJson)
 );
 
 const protocol = RpcClient.layerProtocolHttp({ url: "/rpc" }).pipe(
-  Layer.provide(RpcSerialization.layerJson),
+  Layer.provide(RpcSerialization.layerJson)
 );
 
 const socket = protocol.pipe(Layer.provide(Testing.layer(server)));
@@ -34,38 +36,50 @@ const served = socket.pipe(Layer.provideMerge(memory));
 // with the `HttpClient` the rpc client's protocol is given.
 const servedWithHttp = protocol.pipe(
   Layer.provideMerge(Testing.layer(Layer.merge(server, publicRoutes))),
-  Layer.provide(memory),
+  Layer.provide(services())
 );
 
 // Each call carries its caller's session cookie, as a browser attaches it, so one client
 // serves several callers. Authentication is per message.
-const as = (session: string) => RpcClient.withHeaders({ cookie: `tracker_session=${session}` });
+const as = (session: string) =>
+  RpcClient.withHeaders({ cookie: `tracker_session=${session}` });
 
 describe("a session cookie, over RPC", () => {
   it.effect("authenticates each message", () =>
     Effect.gen(function* () {
       const client = yield* ActionRpc.client(Rpc);
-      const issue = yield* client.createIssue({ title: "Crash", body: "" }).pipe(as("ada-at-acme"));
+
+      const issue = yield* client
+        .createIssue({ title: "Crash", body: "" })
+        .pipe(as("ada-at-acme"));
 
       expect(issue.id).toBe("ACME-1");
       expect(yield* client.whoAmI().pipe(as("grace-at-globex"))).toMatchObject({
         workspace: "globex",
       });
-      expect(yield* client.listIssues().pipe(as("grace-at-globex"))).toEqual({ issues: [] });
-    }).pipe(Effect.scoped, Effect.provide(served)),
+      expect(
+        yield* client.listIssues().pipe(as("grace-at-globex"))
+      ).toStrictEqual({
+        issues: [],
+      });
+    }).pipe(Effect.scoped, Effect.provide(served))
   );
 
-  it.effect("fails a call without a session, or with an unknown one, as a typed refusal", () =>
-    Effect.gen(function* () {
-      const client = yield* ActionRpc.client(Rpc);
+  it.effect(
+    "fails a call without a session, or with an unknown one, as a typed refusal",
+    () =>
+      Effect.gen(function* () {
+        const client = yield* ActionRpc.client(Rpc);
 
-      expect(yield* Effect.flip(client.whoAmI())).toBeInstanceOf(Action.Unauthenticated);
+        expect(yield* Effect.flip(client.whoAmI())).toBeInstanceOf(
+          Action.Unauthenticated
+        );
 
-      const unknown = yield* Effect.flip(client.whoAmI().pipe(as("stolen")));
+        const unknown = yield* Effect.flip(client.whoAmI().pipe(as("stolen")));
 
-      expect(unknown).toBeInstanceOf(Action.Unauthenticated);
-      expect(unknown.message).toBe("Unknown demo session.");
-    }).pipe(Effect.scoped, Effect.provide(served)),
+        expect(unknown).toBeInstanceOf(Action.Unauthenticated);
+        expect(unknown.message).toBe("Unknown demo session.");
+      }).pipe(Effect.scoped, Effect.provide(served))
   );
 
   it.effect("is refused once its workspace is suspended, as a token is", () =>
@@ -75,36 +89,44 @@ describe("a session cookie, over RPC", () => {
 
       yield* registry.setSuspended("acme", true);
 
-      const refused = yield* Effect.flip(client.whoAmI().pipe(as("ada-at-acme")));
+      const refused = yield* Effect.flip(
+        client.whoAmI().pipe(as("ada-at-acme"))
+      );
 
       expect(refused).toBeInstanceOf(Action.Forbidden);
       expect(refused.message).toBe("This workspace is suspended.");
-      expect(yield* client.whoAmI().pipe(as("grace-at-globex"))).toMatchObject({ id: "grace" });
-    }).pipe(Effect.scoped, Effect.provide(served)),
+      expect(yield* client.whoAmI().pipe(as("grace-at-globex"))).toMatchObject({
+        id: "grace",
+      });
+    }).pipe(Effect.scoped, Effect.provide(served))
   );
 
-  it.effect("spends the one request quota its member also spends over HTTP", () =>
-    Effect.gen(function* () {
-      const rpcs = yield* ActionRpc.client(Rpc);
-
-      const http = yield* ActionHttp.client(Http, {
-        transformClient: HttpClient.mapRequest(
-          flow(
-            HttpClientRequest.bearerToken("ada"),
-            HttpClientRequest.setHeader("x-workspace", "acme"),
+  it.effect(
+    "spends the one request quota its member also spends over HTTP",
+    () =>
+      Effect.gen(function* () {
+        const rpcs = yield* ActionRpc.client(Rpc);
+
+        const http = yield* ActionHttp.client(Http, {
+          transformClient: HttpClient.mapRequest(
+            flow(
+              HttpClientRequest.bearerToken("ada"),
+              HttpClientRequest.setHeader("x-workspace", "acme")
+            )
           ),
-        ),
-      });
-
-      // Sixty requests as ada in acme, half on each surface: each middleware counts, and the
-      // next request is refused on either.
-      yield* Effect.forEach(Array.range(1, 30), () => http.whoAmI());
-      yield* Effect.forEach(Array.range(1, 30), () => rpcs.whoAmI().pipe(as("ada-at-acme")));
-
-      expect(yield* Effect.flip(rpcs.whoAmI().pipe(as("ada-at-acme")))).toBeInstanceOf(
-        QuotaExceeded,
-      );
-      expect(yield* Effect.flip(http.whoAmI())).toBeInstanceOf(QuotaExceeded);
-    }).pipe(Effect.scoped, Effect.provide(servedWithHttp)),
+        });
+
+        // Sixty requests as ada in acme, half on each surface: each middleware counts, and the
+        // next request is refused on either.
+        yield* Effect.forEach(Array.range(1, 30), () => http.whoAmI());
+        yield* Effect.forEach(Array.range(1, 30), () =>
+          rpcs.whoAmI().pipe(as("ada-at-acme"))
+        );
+
+        expect(
+          yield* Effect.flip(rpcs.whoAmI().pipe(as("ada-at-acme")))
+        ).toBeInstanceOf(QuotaExceeded);
+        expect(yield* Effect.flip(http.whoAmI())).toBeInstanceOf(QuotaExceeded);
+      }).pipe(Effect.scoped, Effect.provide(servedWithHttp))
   );
 });

package/examples/kitchen-sink/test/issues/assistant.test.ts

@@ -1,7 +1,8 @@
 import { describe, expect, it } from "@effect/vitest";
+import * as Action from "@gjermundgaraba/effect-actions/Action";
 import { Effect, Layer, Stream } from "effect";
 import { LanguageModel } from "effect/ai";
-import * as Action from "@gjermundgaraba/effect-actions/Action";
+
 import { CurrentMember } from "../../src/identity/Identity.js";
 import { members } from "../../src/identity/members.js";
 import { layer, toolkit, triage } from "../../src/issues/assistant.js";
@@ -12,8 +13,18 @@ import { memory } from "../../src/memory.js";
 const model = LanguageModel.make({
   generateText: () =>
     Effect.succeed([
-      { type: "tool-call", id: "1", name: "getIssue", params: { id: "ACME-1" } },
-      { type: "tool-call", id: "2", name: "closeIssue", params: { id: "ACME-1" } },
+      {
+        type: "tool-call",
+        id: "1",
+        name: "getIssue",
+        params: { id: "ACME-1" },
+      },
+      {
+        type: "tool-call",
+        id: "2",
+        name: "closeIssue",
+        params: { id: "ACME-1" },
+      },
     ] as const),
   streamText: () => Stream.empty,
 });
@@ -32,44 +43,52 @@ describe("the assistant's tools", () => {
 
       const turn = yield* triage("Close what is done.").pipe(
         asAda,
-        Effect.provideServiceEffect(LanguageModel.LanguageModel, model),
+        Effect.provideServiceEffect(LanguageModel.LanguageModel, model)
       );
 
-      expect(turn.toolResults.map(({ name }) => name)).toEqual(["getIssue"]);
+      expect(turn.toolResults.map(({ name }) => name)).toStrictEqual([
+        "getIssue",
+      ]);
       expect(
         turn.content.flatMap((part) =>
-          part.type === "tool-approval-request" ? [part.toolCallId] : [],
-        ),
-      ).toEqual(["2"]);
-      expect(yield* tracker.getIssue({ id: "ACME-1" }).pipe(asAda)).toMatchObject({
+          part.type === "tool-approval-request" ? [part.toolCallId] : []
+        )
+      ).toStrictEqual(["2"]);
+      expect(
+        yield* tracker.getIssue({ id: "ACME-1" }).pipe(asAda)
+      ).toMatchObject({
         status: "open",
       });
-    }).pipe(Effect.provide(services)),
+    }).pipe(Effect.provide(services))
   );
 
-  it.effect("offers the listed actions alone, and runs `authorize` for a call made by hand", () =>
-    Effect.gen(function* () {
-      const tools = yield* toolkit;
+  it.effect(
+    "offers the listed actions alone, and runs `authorize` for a call made by hand",
+    () =>
+      Effect.gen(function* () {
+        const tools = yield* toolkit;
 
-      expect(Object.keys(tools.tools)).toEqual([
-        "listIssues",
-        "getIssue",
-        "commentOnIssue",
-        "closeIssue",
-      ]);
+        expect(Object.keys(tools.tools)).toStrictEqual([
+          "listIssues",
+          "getIssue",
+          "commentOnIssue",
+          "closeIssue",
+        ]);
 
-      // `tools.handle` is a caller that is not a model's turn: it asks no approval, and takes
-      // the arguments as JSON. The implementation's `authorize` runs all the same.
-      const refused = yield* tools
-        .handle("closeIssue", { id: "ACME-1" })
-        .pipe(
-          Effect.flatMap(Stream.runCollect),
-          Effect.provideService(CurrentMember, members.linus),
-        );
+        // `tools.handle` is a caller that is not a model's turn: it asks no approval, and takes
+        // the arguments as JSON. The implementation's `authorize` runs all the same.
+        const refused = yield* tools
+          .handle("closeIssue", { id: "ACME-1" })
+          .pipe(
+            Effect.flatMap(Stream.runCollect),
+            Effect.provideService(CurrentMember, members.linus)
+          );
 
-      expect(refused.map(({ isFailure, result }) => [isFailure, result])).toEqual([
-        [true, new Action.Forbidden({ scopes: ["issues:write"] })],
-      ]);
-    }).pipe(Effect.provide(services)),
+        expect(
+          refused.map(({ isFailure, result }) => [isFailure, result])
+        ).toStrictEqual([
+          [true, new Action.Forbidden({ scopes: ["issues:write"] })],
+        ]);
+      }).pipe(Effect.provide(services))
   );
 });

package/examples/kitchen-sink/test/issues/events.test.ts

@@ -0,0 +1,273 @@
+import { describe, expect, it } from "@effect/vitest";
+import * as Action from "@gjermundgaraba/effect-actions/Action";
+import * as Event from "@gjermundgaraba/effect-actions/Event";
+import * as Testing from "@gjermundgaraba/effect-actions/Testing";
+import { Effect, Fiber, Layer, Queue, Schema, Stream } from "effect";
+import { HttpClient, HttpClientRequest } from "effect/http";
+import { RateLimiter } from "effect/persistence";
+import { TestClock } from "effect/testing";
+
+import type { members } from "../../src/identity/members.js";
+import { issueEvents } from "../../src/issues/events.js";
+import { issues } from "../../src/issues/handlers.js";
+import { IssueChanged } from "../../src/issues/Issues.js";
+import { IssueStore } from "../../src/issues/store.js";
+import { publicRoutes } from "../../src/routes.js";
+import { as } from "../support/as.js";
+import { services } from "../support/services.js";
+
+const inProcess = Layer.mergeAll(
+  IssueStore.layerMemory,
+  RateLimiter.layer.pipe(Layer.provide(RateLimiter.layerStoreMemory)),
+  Event.layerMemory
+);
+
+// The changes a member's watch receives, as data, while `act` changes issues.
+const watched = <E, R>(
+  member: keyof typeof members,
+  input: typeof IssueChanged.input.Type,
+  count: number,
+  act: (
+    client: Action.Client<[typeof issues, typeof issueEvents]>
+  ) => Effect.Effect<void, E, R>
+) =>
+  Effect.gen(function* () {
+    const client = yield* Action.client([issues, issueEvents]);
+
+    const watching = yield* client.watch(IssueChanged, input).pipe(
+      Stream.filter((received) => received._tag === "Occurrence"),
+      Stream.map((occurrence) => occurrence.data),
+      Stream.take(count),
+      Stream.runCollect,
+      as(member),
+      Effect.forkChild
+    );
+
+    // Lets the forked watch run up to its subscription first: started after `act`, it would wait
+    // for changes already made.
+    yield* TestClock.adjust("0 millis");
+    yield* act(client);
+
+    return yield* Fiber.join(watching);
+  });
+
+describe("issue.changed", () => {
+  it.effect(
+    "gives a member the changes of their own workspace alone, as they happen",
+    () =>
+      Effect.gen(function* () {
+        const changes = yield* watched("linus", {}, 2, (client) =>
+          Effect.gen(function* () {
+            const filed = yield* client
+              .createIssue({ title: "Crash", body: "" })
+              .pipe(as("ada"));
+
+            yield* client
+              .createIssue({ title: "Elsewhere", body: "" })
+              .pipe(as("grace"));
+            yield* client
+              .commentOnIssue({ id: filed.id, text: "Seen it." })
+              .pipe(as("ada"));
+          })
+        );
+
+        expect(changes).toStrictEqual([
+          {
+            workspace: "acme",
+            id: "ACME-1",
+            title: "Crash",
+            status: "open",
+            change: "filed",
+          },
+          {
+            workspace: "acme",
+            id: "ACME-1",
+            title: "Crash",
+            status: "open",
+            change: "commented",
+            comment: { author: "ada", text: "Seen it." },
+          },
+        ]);
+      }).pipe(Effect.provide(inProcess))
+  );
+
+  it.effect("filters by status and leaves the comment out where asked", () =>
+    Effect.gen(function* () {
+      const changes = yield* watched(
+        "linus",
+        { status: "closed", comments: false },
+        2,
+        (client) =>
+          Effect.gen(function* () {
+            const filed = yield* client
+              .createIssue({ title: "Crash", body: "" })
+              .pipe(as("ada"));
+
+            yield* client
+              .commentOnIssue({ id: filed.id, text: "Seen it." })
+              .pipe(as("ada"));
+            yield* client.closeIssue({ id: filed.id }).pipe(as("ada"));
+            // Closing it again changes nothing, and nothing is sent.
+            yield* client.closeIssue({ id: filed.id }).pipe(as("ada"));
+            yield* client
+              .commentOnIssue({ id: filed.id, text: "Fixed." })
+              .pipe(as("ada"));
+          })
+      );
+
+      expect(changes).toStrictEqual([
+        {
+          workspace: "acme",
+          id: "ACME-1",
+          title: "Crash",
+          status: "closed",
+          change: "closed",
+        },
+        {
+          workspace: "acme",
+          id: "ACME-1",
+          title: "Crash",
+          status: "closed",
+          change: "commented",
+        },
+      ]);
+    }).pipe(Effect.provide(inProcess))
+  );
+
+  it.effect("refuses a member without the read scope", () =>
+    Effect.gen(function* () {
+      const client = yield* Action.client([issues, issueEvents]);
+
+      expect(
+        yield* Effect.flip(
+          Stream.runDrain(client.watch(IssueChanged)).pipe(as("kay"))
+        )
+      ).toStrictEqual(
+        new Action.Forbidden({
+          message: "Requires issues:read.",
+          scopes: ["issues:read"],
+        })
+      );
+    }).pipe(Effect.provide(inProcess))
+  );
+});
+
+// The subscriber's secret: `whsec_` and 24 to 64 random bytes in base64.
+const secret = `whsec_${Buffer.from(crypto.getRandomValues(new Uint8Array(32))).toString("base64")}`;
+
+const Delivered = Schema.fromJsonString(
+  Schema.Record(Schema.String, Schema.Json)
+);
+
+// linus's server: it echoes the verification's challenge, which proves it asked for these
+// deliveries, and acknowledges each delivery with a 2xx.
+const subscriber =
+  (received: Queue.Enqueue<typeof Delivered.Type>) =>
+  async (request: Request) => {
+    const body = Schema.decodeSync(Delivered)(await request.text());
+
+    Queue.offerUnsafe(received, body);
+
+    return body["type"] === "verification"
+      ? Response.json({ challenge: body["challenge"] })
+      : new Response(null);
+  };
+
+const signedIn = (token: string, workspace: string) =>
+  HttpClient.mapRequest((request) =>
+    request.pipe(
+      HttpClientRequest.bearerToken(token),
+      HttpClientRequest.setHeader("x-workspace", workspace)
+    )
+  );
+
+describe("issue.changed by webhook", () => {
+  it.effect(
+    "POSTs each change of the subscriber's workspace, as the subscriber sees it",
+    () =>
+      Effect.flatMap(Queue.unbounded<typeof Delivered.Type>(), (received) =>
+        Effect.gen(function* () {
+          const http = yield* HttpClient.HttpClient;
+
+          yield* http.pipe(signedIn("linus", "acme")).execute(
+            HttpClientRequest.post(
+              "/api/v1/events/issue.changed/subscribe"
+            ).pipe(
+              HttpClientRequest.bodyJsonUnsafe({
+                input: { comments: false },
+                delivery: { url: "https://hooks.example.com/linus", secret },
+              })
+            )
+          );
+
+          const verification = yield* Queue.take(received);
+
+          for (const [token, workspace, url, body] of [
+            [
+              "grace",
+              "globex",
+              "/api/v1/createIssue",
+              { title: "From grace", body: "" },
+            ],
+            [
+              "ada",
+              "acme",
+              "/api/v1/createIssue",
+              { title: "From ada", body: "" },
+            ],
+            [
+              "ada",
+              "acme",
+              "/api/v1/commentOnIssue",
+              { id: "ACME-1", text: "Seen it." },
+            ],
+          ] as const) {
+            yield* http
+              .pipe(signedIn(token, workspace))
+              .execute(
+                HttpClientRequest.post(url).pipe(
+                  HttpClientRequest.bodyJsonUnsafe(body)
+                )
+              );
+          }
+
+          const deliveries = [
+            yield* Queue.take(received),
+            yield* Queue.take(received),
+          ];
+
+          expect(verification).toMatchObject({ type: "verification" });
+          expect(
+            deliveries.map(({ name, data }) => ({ name, data }))
+          ).toStrictEqual([
+            {
+              name: "issue.changed",
+              data: {
+                workspace: "acme",
+                id: "ACME-1",
+                title: "From ada",
+                status: "open",
+                change: "filed",
+              },
+            },
+            {
+              name: "issue.changed",
+              data: {
+                workspace: "acme",
+                id: "ACME-1",
+                title: "From ada",
+                status: "open",
+                change: "commented",
+              },
+            },
+          ]);
+        }).pipe(
+          Effect.provide(
+            Testing.layer(publicRoutes).pipe(
+              Layer.provide(services(Testing.layer(subscriber(received))))
+            )
+          )
+        )
+      )
+  );
+});

package/examples/kitchen-sink/test/issues/export.test.ts

@@ -0,0 +1,120 @@
+import { describe, expect, it } from "@effect/vitest";
+import * as ActionHttp from "@gjermundgaraba/effect-actions/ActionHttp";
+import * as ActionRpc from "@gjermundgaraba/effect-actions/ActionRpc";
+import * as Testing from "@gjermundgaraba/effect-actions/Testing";
+import { Effect, Exit, Layer, Stream } from "effect";
+import { HttpClient, HttpClientRequest } from "effect/http";
+import { RpcClient, RpcSerialization, RpcServer } from "effect/rpc";
+
+import { Http } from "../../src/Api.js";
+import type { ExportIssues } from "../../src/issues/Issues.js";
+import { RateLimited } from "../../src/issues/Issues.js";
+import { publicRoutes, rpc } from "../../src/routes.js";
+import { Rpc } from "../../src/Rpc.js";
+import { services } from "../support/services.js";
+
+// The public port's routes and the web app's rpcs under one `Testing.layer`, as server.ts
+// serves them under one router.
+const served = RpcClient.layerProtocolHttp({ url: "/rpc" }).pipe(
+  Layer.provide(RpcSerialization.layerJson),
+  Layer.provideMerge(
+    Testing.layer(
+      Layer.merge(
+        publicRoutes,
+        rpc.pipe(
+          Layer.provide(RpcServer.layerProtocolHttp({ path: "/rpc" })),
+          Layer.provide(RpcSerialization.layerJson)
+        )
+      )
+    )
+  ),
+  Layer.provide(services())
+);
+
+const ada = {
+  transformClient: HttpClient.mapRequest((request) =>
+    request.pipe(
+      HttpClientRequest.bearerToken("ada"),
+      HttpClientRequest.setHeader("x-workspace", "acme")
+    )
+  ),
+};
+
+const titles = (exported: ReadonlyArray<{ readonly title: string }>) =>
+  exported.map(({ title }) => title);
+
+describe("exportIssues", () => {
+  it.effect(
+    "streams the issues asked for, oldest first, reporting how far it is, over HTTP and RPC",
+    () =>
+      Effect.gen(function* () {
+        const http = yield* ActionHttp.client(Http, ada);
+        const web = yield* ActionRpc.client(Rpc);
+
+        for (const title of ["First", "Second", "Third"]) {
+          yield* http.createIssue({ title, body: "" });
+        }
+
+        yield* http.closeIssue({ id: "ACME-2" });
+
+        const reported: Array<typeof ExportIssues.progress.Type> = [];
+
+        const overHttp = yield* Stream.runCollect(
+          http.exportIssues(
+            {},
+            {
+              onProgress: (progress) =>
+                Effect.sync(() => reported.push(progress)),
+            }
+          )
+        );
+
+        // The web app's call carries its session cookie, as a browser attaches it.
+        const overRpc = yield* Stream.runCollect(
+          web.exportIssues({ status: "open" })
+        ).pipe(
+          RpcClient.withHeaders({ cookie: "tracker_session=ada-at-acme" })
+        );
+
+        expect([titles(overHttp), titles(overRpc), reported]).toStrictEqual([
+          ["First", "Second", "Third"],
+          ["First", "Third"],
+          [
+            { exported: 1, total: 3 },
+            { exported: 2, total: 3 },
+            { exported: 3, total: 3 },
+          ],
+        ]);
+      }).pipe(Effect.scoped, Effect.provide(served))
+  );
+
+  it.effect(
+    "refuses a third export in a minute before its first issue, a 429",
+    () =>
+      Effect.gen(function* () {
+        const http = yield* ActionHttp.client(Http, ada);
+
+        yield* Stream.runDrain(http.exportIssues({}));
+        yield* Stream.runDrain(http.exportIssues({}));
+
+        const refused = yield* Effect.exit(
+          Stream.runDrain(http.exportIssues({}))
+        );
+
+        const response = yield* HttpClient.execute(
+          HttpClientRequest.post("/api/v1/exportIssues").pipe(
+            HttpClientRequest.bearerToken("ada"),
+            HttpClientRequest.setHeader("x-workspace", "acme"),
+            HttpClientRequest.bodyJsonUnsafe({})
+          )
+        );
+
+        expect(
+          Exit.isFailure(refused) && Exit.findErrorOption(refused)
+        ).toMatchObject({
+          value: new RateLimited({ retryAfterSeconds: 60 }),
+        });
+        expect(response.status).toBe(429);
+      }).pipe(Effect.scoped, Effect.provide(served))
+  );
+});