@gjermundgaraba/effect-actions 0.20.0 → 0.21.0

package/examples/build-events/src/notifier.ts

@@ -0,0 +1,48 @@
+import { createServer } from "node:http";
+
+import { NodeHttpServer, NodeRuntime } from "@effect/platform-node";
+import { ByteSize, Config, Effect, Layer } from "effect";
+import { FetchHttpClient, HttpRouter, HttpServerRequest } from "effect/http";
+import { KeyValueStore } from "effect/persistence";
+
+import { Notices } from "./notifier/Notices.js";
+import { notifier } from "./notifier/routes.js";
+
+// Entrypoint of the second service: `BUILDS_TOKEN=grace PUBLIC_URL=https://<its public name>
+// node --import tsx examples/build-events/src/notifier.ts`, with server.ts running. build-events
+// POSTs only to a globally reachable address, so on one machine give it a tunnel's name.
+const server = Layer.unwrap(
+  Effect.gen(function* () {
+    const buildEvents = yield* Config.String("BUILDS_URL").pipe(
+      Config.withDefault("http://127.0.0.1:3000")
+    );
+
+    // Redacted, so a log or an error printing the configuration never shows the token.
+    const token = yield* Config.Redacted("BUILDS_TOKEN");
+    const publicUrl = yield* Config.String("PUBLIC_URL");
+
+    // The loopback default serves this machine alone, which a tunnel reaches; HOST=0.0.0.0 lets
+    // build-events reach it directly.
+    const host = yield* Config.String("HOST").pipe(
+      Config.withDefault("127.0.0.1")
+    );
+
+    const port = yield* Config.Port("PORT").pipe(Config.withDefault(3001));
+
+    return HttpRouter.serve(notifier({ buildEvents, token, publicUrl })).pipe(
+      Layer.provide(NodeHttpServer.layer(createServer, { host, port })),
+      // The receiver's route is public and reads each body whole: a delivery is at most 256 KiB.
+      Layer.provide(
+        Layer.succeed(HttpServerRequest.MaxBodySize, ByteSize.kibibytes(256))
+      ),
+      // DEMO ONLY: notices and the watch's cursor live in this process's memory.
+      Layer.provide([
+        Notices.layerMemory,
+        KeyValueStore.layerMemory,
+        FetchHttpClient.layer,
+      ])
+    );
+  })
+);
+
+Layer.launch(server).pipe(NodeRuntime.runMain());

package/examples/build-events/src/routes.ts

@@ -0,0 +1,71 @@
+import * as ActionHttp from "@gjermundgaraba/effect-actions/ActionHttp";
+import * as ActionMcp from "@gjermundgaraba/effect-actions/ActionMcp";
+import * as ActionRpc from "@gjermundgaraba/effect-actions/ActionRpc";
+import * as Webhook from "@gjermundgaraba/effect-actions/Webhook";
+import { Layer } from "effect";
+import { RpcSerialization, RpcServer } from "effect/rpc";
+
+import { Http } from "./Api.js";
+import { buildEvents } from "./builds/events.js";
+import { builds } from "./builds/handlers.js";
+import { logs } from "./builds/log.js";
+import { statusEvents } from "./builds/status.js";
+import { deployEvents } from "./deploys/events.js";
+import { deploys } from "./deploys/handlers.js";
+import { Login } from "./identity/Identity.js";
+import { authenticate } from "./identity/verifier.js";
+import { Rpc } from "./Rpc.js";
+
+// Every domain's implementation, once: the events beside the actions, in one list.
+const implementations = [
+  builds,
+  logs,
+  buildEvents,
+  statusEvents,
+  deploys,
+  deployEvents,
+];
+
+// The actions as MCP tools and the events as MCP events, at `/mcp`. A client polls with
+// `events/poll`, or holds `events/stream` open and is pushed each occurrence. Both events are
+// protected, so each request needs a member's token, and each subscriber sees what its token
+// lets it. This long-lived process holds the deploy event's `subscription` hook between polls and
+// its log in memory, and pushes each occurrence: a `requestScoped` endpoint would serve the events
+// by poll and webhook alone, and a serverless host, where no process lasts, check sources alone,
+// without `Webhook.layer`.
+//
+// A tool answers one result, so `tailLog` would collect a whole log before answering, all of it
+// in a model's context: its implementation, `logs`, is left out, and the endpoint serves every
+// other action and every event.
+const mcp = ActionMcp.layerHttp(
+  [builds, buildEvents, statusEvents, deploys, deployEvents],
+  {
+    name: "build-events",
+    version: "1.0.0",
+    authentication: Login,
+  }
+);
+
+// The same implementations as routes under `/api`, for a client that speaks HTTP rather than
+// MCP: one implementation of each event serves every surface.
+const api = ActionHttp.layer(Http, implementations);
+
+// And as Effect RPC at `/rpc`, over HTTP. A watch is a stream rpc that never ends, so the
+// serialization frames each element as it is sent: `layerNdjson` does, where `layerJson` would
+// answer once every stream of the request ended, which a watch never does.
+const rpc = ActionRpc.layer(Rpc, implementations).pipe(
+  Layer.provide(RpcServer.layerProtocolHttp({ path: "/rpc" })),
+  Layer.provide(RpcSerialization.layerNdjson)
+);
+
+// Webhook delivery for MCP and HTTP alike: a member names a callback URL and a secret, with
+// MCP's `events/subscribe` or `POST /api/events/<name>/subscribe`, and each occurrence it may see
+// is POSTed there, signed. One layer holds the subscriptions of both, so either surface refreshes
+// one made over the other. `persist` keeps each in a `KeyValueStore`, so a restart goes on
+// delivering from where it reached, as the subscriber `Login`'s `schema` keeps. It needs an
+// `HttpClient` to POST, `Dns` to check where each callback resolves, and the store, which
+// `server.ts` provides.
+export const routes = Layer.mergeAll(mcp, api, rpc).pipe(
+  Layer.provide(authenticate),
+  Layer.provide(Webhook.layer({ persist: true }))
+);

package/examples/build-events/src/server.ts

@@ -0,0 +1,62 @@
+import { createServer } from "node:http";
+
+import {
+  NodeDns,
+  NodeFileSystem,
+  NodeHttpServer,
+  NodePath,
+  NodeRuntime,
+} from "@effect/platform-node";
+import * as Event from "@gjermundgaraba/effect-actions/Event";
+import { ByteSize, Config, Effect, Layer } from "effect";
+import { FetchHttpClient, HttpRouter, HttpServerRequest } from "effect/http";
+import { KeyValueStore } from "effect/persistence";
+
+import { BuildStore } from "./builds/store.js";
+import { Approvers } from "./deploys/approvers.js";
+import { routes } from "./routes.js";
+
+// Entrypoint: `node --import tsx examples/build-events/src/server.ts`.
+// It chooses the stores, reads the configuration and starts Node's HTTP server.
+const server = Layer.unwrap(
+  Effect.gen(function* () {
+    // The loopback default serves this machine alone; HOST=0.0.0.0 lets others reach it.
+    const host = yield* Config.String("HOST").pipe(
+      Config.withDefault("127.0.0.1")
+    );
+
+    const port = yield* Config.Port("PORT").pipe(Config.withDefault(3000));
+
+    const webhooks = yield* Config.String("WEBHOOKS_DIR").pipe(
+      Config.withDefault(".build-events/webhooks")
+    );
+
+    return HttpRouter.serve(routes).pipe(
+      Layer.provide(NodeHttpServer.layer(createServer, { host, port })),
+      // Request bodies have no size limit unless the host sets one. This covers every route
+      // that reads its body whole, the MCP endpoint and the webhook subscribe routes included.
+      Layer.provide(
+        Layer.succeed(HttpServerRequest.MaxBodySize, ByteSize.mebibytes(1))
+      ),
+      // DEMO ONLY: builds and approvers live in this process's memory; a deployment provides
+      // stores that last.
+      Layer.provide([BuildStore.layerMemory, Approvers.layerMemory]),
+      // The events this process announces: a notify after a build finishes, and each deploy
+      // request published. One for the whole server, which holds every subscriber's connection.
+      Layer.provide(Event.layerMemory),
+      // Webhook subscriptions are kept as files under WEBHOOKS_DIR, so a restart goes on
+      // delivering them; after one, the memory store above sends each a gap first. The files
+      // hold each subscriber's secret: give the directory to this server alone, and each server
+      // process its own, since the layer is its store's one writer.
+      Layer.provide(
+        KeyValueStore.layerFileSystem(webhooks).pipe(
+          Layer.provide([NodeFileSystem.layer, NodePath.layer])
+        )
+      ),
+      // Webhook delivery POSTs with fetch, and resolves each callback with the system's resolver.
+      Layer.provide([FetchHttpClient.layer, NodeDns.layer])
+    );
+  })
+);
+
+Layer.launch(server).pipe(NodeRuntime.runMain());

package/examples/build-events/test/builds/events.test.ts

@@ -0,0 +1,68 @@
+import { expect, it } from "@effect/vitest";
+import * as Action from "@gjermundgaraba/effect-actions/Action";
+import * as Event from "@gjermundgaraba/effect-actions/Event";
+import { Effect, Fiber, Stream } from "effect";
+import { TestClock } from "effect/testing";
+
+import { BuildFinished } from "../../src/builds/Builds.js";
+import { buildEvents } from "../../src/builds/events.js";
+import { builds } from "../../src/builds/handlers.js";
+import { BuildStore } from "../../src/builds/store.js";
+import { as } from "../support/as.js";
+
+it.effect(
+  "delivers each build a member may see as it finishes, as the subscription selects",
+  () =>
+    Effect.gen(function* () {
+      // One client holds both: the action that finishes builds and the event that reports them.
+      const client = yield* Action.client([builds, buildEvents]);
+
+      const failed = yield* client
+        .watch(BuildFinished, { status: "failed" })
+        .pipe(Stream.take(1), Stream.runCollect, as("grace"), Effect.forkChild);
+
+      // The watch starts from now: let it take its first position before builds finish.
+      yield* TestClock.adjust("0 millis");
+      yield* client
+        .finishBuild({ pipeline: "api", status: "failed" })
+        .pipe(as("ada"));
+      yield* client
+        .finishBuild({ pipeline: "web", status: "passed" })
+        .pipe(as("ada"));
+      // Each build finished notifies: the watch reads at once, with no wait for its next poll.
+      yield* client
+        .finishBuild({ pipeline: "web", status: "failed" })
+        .pipe(as("ada"));
+
+      // grace sees only the web pipeline, and asked only for failures.
+      expect(yield* Fiber.join(failed)).toMatchObject([
+        {
+          _tag: "Occurrence",
+          data: { id: "build-3", pipeline: "web", status: "failed" },
+        },
+      ]);
+    }).pipe(Effect.provide([BuildStore.layerMemory, Event.layerMemory]))
+);
+
+it.effect(
+  "sends a gap first to a subscriber resuming from a cursor the store never gave",
+  () =>
+    Effect.gen(function* () {
+      const client = yield* Action.client([builds, buildEvents]);
+
+      yield* client
+        .finishBuild({ pipeline: "web", status: "passed" })
+        .pipe(as("ada"));
+
+      // A cursor of the store before a restart, its offset one this store has too: what it named
+      // is gone, so the watch is told.
+      const resumed = yield* client
+        .watch(BuildFinished, {}, { cursor: "an-earlier-epoch:0" })
+        .pipe(Stream.take(2), Stream.runCollect, as("grace"));
+
+      expect(resumed).toMatchObject([
+        { _tag: "Gap" },
+        { _tag: "Occurrence", data: { id: "build-1", pipeline: "web" } },
+      ]);
+    }).pipe(Effect.provide([BuildStore.layerMemory, Event.layerMemory]))
+);

package/examples/build-events/test/builds/log.test.ts

@@ -0,0 +1,71 @@
+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 } from "effect/rpc";
+
+import { Http } from "../../src/Api.js";
+import { BuildNotFound } from "../../src/builds/Builds.js";
+import { routes } from "../../src/routes.js";
+import { Rpc } from "../../src/Rpc.js";
+import { inMemory } from "../support/memory.js";
+
+const served = Testing.layer(routes).pipe(Layer.provide(inMemory()));
+
+const overRpc = RpcClient.layerProtocolHttp({ url: "/rpc" }).pipe(
+  Layer.provide(RpcSerialization.layerNdjson),
+  Layer.provide(served)
+);
+
+const bearer = (token: string) =>
+  HttpClient.mapRequest(HttpClientRequest.bearerToken(token));
+
+const log = [
+  { line: "install: passed" },
+  { line: "build: passed" },
+  { line: "test: passed" },
+  { line: "passed" },
+];
+
+describe("a build's log", () => {
+  it.effect("streams each line of a build over HTTP and RPC", () =>
+    Effect.gen(function* () {
+      const http = yield* ActionHttp.client(Http, {
+        transformClient: bearer("ada"),
+      });
+
+      const rpc = yield* ActionRpc.client(Rpc);
+      const { id } = yield* http.startBuild({ pipeline: "api" });
+
+      // Each call returns a `Stream`: a line is read as the server sends it.
+      const lines = [
+        yield* Stream.runCollect(http.tailLog({ buildId: id })),
+        yield* Stream.runCollect(rpc.tailLog({ buildId: id })).pipe(
+          RpcClient.withHeaders({ authorization: "Bearer ada" })
+        ),
+      ];
+
+      expect(lines).toStrictEqual([log, log]);
+    }).pipe(Effect.scoped, Effect.provide(Layer.merge(served, overRpc)))
+  );
+
+  it.effect("is not found for a member who may not see its pipeline", () =>
+    Effect.gen(function* () {
+      const ada = yield* ActionHttp.client(Http, {
+        transformClient: bearer("ada"),
+      });
+
+      const grace = yield* ActionHttp.client(Http, {
+        transformClient: bearer("grace"),
+      });
+
+      const { id } = yield* ada.startBuild({ pipeline: "api" });
+
+      expect(
+        yield* Effect.exit(Stream.runDrain(grace.tailLog({ buildId: id })))
+      ).toStrictEqual(Exit.fail(new BuildNotFound({ buildId: id })));
+    }).pipe(Effect.provide(served))
+  );
+});

package/examples/build-events/test/builds/progress.test.ts

@@ -0,0 +1,57 @@
+import { describe, expect, it } from "@effect/vitest";
+import * as ActionHttp from "@gjermundgaraba/effect-actions/ActionHttp";
+import * as ActionMcp from "@gjermundgaraba/effect-actions/ActionMcp";
+import * as Testing from "@gjermundgaraba/effect-actions/Testing";
+import { Effect, Layer } from "effect";
+import { HttpClient, HttpClientRequest } from "effect/http";
+
+import { Http } from "../../src/Api.js";
+import { StartBuild } from "../../src/builds/Builds.js";
+import { Login } from "../../src/identity/Identity.js";
+import { routes } from "../../src/routes.js";
+import { inMemory } from "../support/memory.js";
+
+const served = Testing.layer(routes).pipe(Layer.provide(inMemory()));
+
+const bearer = (token: string) =>
+  HttpClient.mapRequest(HttpClientRequest.bearerToken(token));
+
+const steps = [
+  { step: "install", done: 0, total: 3 },
+  { step: "build", done: 1, total: 3 },
+  { step: "test", done: 2, total: 3 },
+];
+
+describe("a build started by a member", () => {
+  it.effect(
+    "reports each step to a caller that asks, over HTTP and MCP, then answers",
+    () =>
+      Effect.gen(function* () {
+        const http = yield* ActionHttp.client(Http, {
+          transformClient: bearer("ada"),
+        });
+
+        const mcp = yield* ActionMcp.client([StartBuild], {
+          authentication: Login,
+          transformClient: bearer("ada"),
+        });
+
+        const seen: unknown[] = [];
+
+        const onProgress = (step: (typeof steps)[number]) =>
+          Effect.sync(() => seen.push(step));
+
+        // A caller asks for the steps by giving `onProgress`; without it, the call answers alone.
+        const answers = [
+          yield* http.startBuild({ pipeline: "api" }, { onProgress }),
+          yield* mcp.startBuild({ pipeline: "api" }, { onProgress }),
+        ];
+
+        expect(seen).toStrictEqual([...steps, ...steps]);
+        expect(answers).toStrictEqual([
+          { id: "build-1", pipeline: "api", status: "passed" },
+          { id: "build-2", pipeline: "api", status: "passed" },
+        ]);
+      }).pipe(Effect.provide(served))
+  );
+});

package/examples/build-events/test/builds/status.test.ts

@@ -0,0 +1,42 @@
+import { expect, it } from "@effect/vitest";
+import * as Action from "@gjermundgaraba/effect-actions/Action";
+import * as Event from "@gjermundgaraba/effect-actions/Event";
+import { Effect, Fiber, Stream } from "effect";
+import { TestClock } from "effect/testing";
+
+import { PipelineStatus } from "../../src/builds/Builds.js";
+import { builds } from "../../src/builds/handlers.js";
+import { statusEvents } from "../../src/builds/status.js";
+import { BuildStore } from "../../src/builds/store.js";
+import { as } from "../support/as.js";
+
+it.effect(
+  "sends a pipeline's status as it is, then as each of its builds ends, and nothing for another's",
+  () =>
+    Effect.gen(function* () {
+      const client = yield* Action.client([builds, statusEvents]);
+
+      const watching = yield* client
+        .watch(PipelineStatus, { pipeline: "web" })
+        .pipe(Stream.take(3), Stream.runCollect, as("grace"), Effect.forkChild);
+
+      yield* TestClock.adjust("0 millis");
+      yield* client
+        .finishBuild({ pipeline: "api", status: "failed" })
+        .pipe(as("ada"));
+      yield* TestClock.adjust("0 millis");
+      yield* client
+        .finishBuild({ pipeline: "web", status: "failed" })
+        .pipe(as("ada"));
+      yield* TestClock.adjust("0 millis");
+      yield* client
+        .finishBuild({ pipeline: "web", status: "passed" })
+        .pipe(as("ada"));
+
+      expect(yield* Fiber.join(watching)).toMatchObject([
+        { _tag: "Occurrence", data: { status: null } },
+        { _tag: "Occurrence", data: { status: "failed" } },
+        { _tag: "Occurrence", data: { status: "passed" } },
+      ]);
+    }).pipe(Effect.provide([BuildStore.layerMemory, Event.layerMemory]))
+);

package/examples/build-events/test/commands.test.ts

@@ -0,0 +1,103 @@
+import { NodeServices } from "@effect/platform-node";
+import { describe, expect, it } from "@effect/vitest";
+import * as ActionHttp from "@gjermundgaraba/effect-actions/ActionHttp";
+import * as Testing from "@gjermundgaraba/effect-actions/Testing";
+import { ConfigProvider, Effect, Fiber, Layer, Schema } from "effect";
+import { Command } from "effect/cli";
+import { HttpClient, HttpClientRequest } from "effect/http";
+import { TestClock, TestConsole } from "effect/testing";
+
+import { Http } from "../src/Api.js";
+import { commands } from "../src/commands.js";
+import { routes } from "../src/routes.js";
+import { inMemory } from "./support/memory.js";
+
+const served = Testing.layer(routes).pipe(Layer.provide(inMemory()));
+
+// Effect's own runner, given arguments instead of the process's, as the member `token` names.
+const run = (token: string, args: readonly string[]) =>
+  Command.runWith(commands, { version: "0" })(args).pipe(
+    Effect.provide(
+      ConfigProvider.layer(
+        ConfigProvider.fromEnvRecord({ BUILDS_TOKEN: token })
+      ).pipe(Layer.provideMerge(NodeServices.layer))
+    )
+  );
+
+describe("the commands", () => {
+  it.effect(
+    "print each build a member may see as a line of JSON, until stopped",
+    () =>
+      Effect.gen(function* () {
+        // A watch runs until it is stopped, as Ctrl-C stops it: here, by interrupting it.
+        const watching = yield* Effect.forkChild(
+          run("grace", ["watch", "build.finished"])
+        );
+
+        yield* TestClock.adjust("0 millis");
+
+        const ada = yield* ActionHttp.client(Http, {
+          transformClient: HttpClient.mapRequest(
+            HttpClientRequest.bearerToken("ada")
+          ),
+        });
+
+        yield* ada.finishBuild({ pipeline: "api", status: "passed" });
+        yield* ada.finishBuild({ pipeline: "web", status: "passed" });
+        yield* TestClock.adjust("5 seconds");
+        yield* Fiber.interrupt(watching);
+
+        // Each line carries its cursor: `--cursor` given it resumes after that build.
+        const lines = yield* Schema.decodeUnknownEffect(
+          Schema.Array(Schema.fromJsonString(Schema.Unknown))
+        )(yield* TestConsole.logLines);
+
+        expect(lines).toMatchObject([
+          { _tag: "Occurrence", data: { id: "build-2", pipeline: "web" } },
+        ]);
+        expect(JSON.stringify(lines)).toMatch(/"cursor":"[^"]+:2"/u);
+      }).pipe(Effect.provide(served))
+  );
+
+  it.effect(
+    "print each step of a build on stderr as it starts, and the build on stdout",
+    () =>
+      Effect.gen(function* () {
+        yield* run("ada", ["start-build", "--pipeline", "api"]);
+
+        // stdout holds the answer alone, so `builds start-build ... | jq` reads the build.
+        expect(yield* TestConsole.logLines).toStrictEqual([
+          JSON.stringify(
+            { id: "build-1", pipeline: "api", status: "passed" },
+            null,
+            2
+          ),
+        ]);
+        expect(yield* TestConsole.errorLines).toStrictEqual([
+          '{"step":"install","done":0,"total":3}',
+          '{"step":"build","done":1,"total":3}',
+          '{"step":"test","done":2,"total":3}',
+        ]);
+      }).pipe(Effect.provide(served))
+  );
+
+  it.effect(
+    "print each line of a build's log as a line of JSON, as it arrives",
+    () =>
+      Effect.gen(function* () {
+        yield* run("ada", [
+          "finish-build",
+          "--pipeline",
+          "web",
+          "--status",
+          "failed",
+        ]);
+        yield* run("ada", ["tail-log", "--build-id", "build-1"]);
+
+        // A line per element, as JSON Lines: `builds tail-log ... | jq -r .line` prints the log.
+        expect((yield* TestConsole.logLines).slice(1)).toStrictEqual([
+          '{"line":"failed"}',
+        ]);
+      }).pipe(Effect.provide(served))
+  );
+});

package/examples/build-events/test/deploys/events.test.ts

@@ -0,0 +1,52 @@
+import { expect, it } from "@effect/vitest";
+import * as Action from "@gjermundgaraba/effect-actions/Action";
+import * as Event from "@gjermundgaraba/effect-actions/Event";
+import { Effect, Fiber, Stream } from "effect";
+import { TestClock } from "effect/testing";
+
+import { Approvers } from "../../src/deploys/approvers.js";
+import { DeployRequested } from "../../src/deploys/Deploys.js";
+import { deployEvents } from "../../src/deploys/events.js";
+import { deploys } from "../../src/deploys/handlers.js";
+import { as } from "../support/as.js";
+
+it.effect(
+  "delivers each deploy request to the subscribers of its environment, who stand by to approve it",
+  () =>
+    Effect.gen(function* () {
+      const client = yield* Action.client([deploys, deployEvents]);
+
+      const production = yield* client
+        .watch(DeployRequested, { environment: "production" })
+        .pipe(Stream.take(1), Stream.runCollect, as("grace"), Effect.forkChild);
+
+      yield* TestClock.adjust("0 millis");
+
+      const staging = yield* client
+        .requestDeploy({ environment: "staging", version: "1.1.0" })
+        .pipe(as("ada"));
+
+      yield* client
+        .requestDeploy({ environment: "production", version: "1.0.9" })
+        .pipe(as("ada"));
+
+      expect(staging.approvers).toStrictEqual([]);
+      expect(yield* Fiber.join(production)).toMatchObject([
+        {
+          data: {
+            environment: "production",
+            version: "1.0.9",
+            requestedBy: "ada",
+            approvers: ["grace"],
+          },
+        },
+      ]);
+
+      // The stream ended, and with it grace's standing by.
+      const later = yield* client
+        .requestDeploy({ environment: "production", version: "1.1.0" })
+        .pipe(as("ada"));
+
+      expect(later.approvers).toStrictEqual([]);
+    }).pipe(Effect.provide([Approvers.layerMemory, Event.layerMemory]))
+);

package/examples/build-events/test/http.test.ts

@@ -0,0 +1,95 @@
+import { describe, expect, it } from "@effect/vitest";
+import * as Action from "@gjermundgaraba/effect-actions/Action";
+import * as ActionHttp from "@gjermundgaraba/effect-actions/ActionHttp";
+import * as Testing from "@gjermundgaraba/effect-actions/Testing";
+import { Effect, Fiber, Layer, Stream } from "effect";
+import { HttpClient, HttpClientRequest } from "effect/http";
+import { TestClock } from "effect/testing";
+
+import { Http } from "../src/Api.js";
+import { BuildFinished } from "../src/builds/Builds.js";
+import { DeployRequested } from "../src/deploys/Deploys.js";
+import { routes } from "../src/routes.js";
+import { inMemory } from "./support/memory.js";
+
+const served = Testing.layer(routes).pipe(Layer.provide(inMemory()));
+
+// One client of the binding per member: the token is the member, as in production.
+const as = (token: string) =>
+  ActionHttp.client(Http, {
+    transformClient: HttpClient.mapRequest(
+      HttpClientRequest.bearerToken(token)
+    ),
+  });
+
+describe("the service, over HTTP", () => {
+  it.effect(
+    "streams each build a member may see, as SSE, as a call finishes it",
+    () =>
+      Effect.gen(function* () {
+        const ada = yield* as("ada");
+        const grace = yield* as("grace");
+
+        // `watch` asks for `text/event-stream`, and the route holds the stream open.
+        const watched = yield* grace
+          .watch(BuildFinished)
+          .pipe(Stream.take(1), Stream.runCollect, Effect.forkChild);
+
+        // The watch starts from now: let it take its first position before builds finish.
+        yield* TestClock.adjust("0 millis");
+        yield* ada.finishBuild({ pipeline: "api", status: "passed" });
+        yield* ada.finishBuild({ pipeline: "web", status: "passed" });
+
+        expect(yield* Fiber.join(watched)).toMatchObject([
+          { _tag: "Occurrence", data: { id: "build-2", pipeline: "web" } },
+        ]);
+      }).pipe(Effect.provide(served))
+  );
+
+  it.effect(
+    "delivers deploy requests to a member that polls the route for JSON pages",
+    () =>
+      Effect.gen(function* () {
+        const ada = yield* as("ada");
+        const grace = yield* as("grace");
+
+        // `mode: "poll"` asks for a page at a time, as a client that cannot hold a stream does.
+        const polled = yield* grace
+          .watch(
+            DeployRequested,
+            { environment: "production" },
+            { mode: "poll" }
+          )
+          .pipe(Stream.take(1), Stream.runCollect, Effect.forkChild);
+
+        yield* TestClock.adjust("0 millis");
+
+        const deploy = yield* ada.requestDeploy({
+          environment: "production",
+          version: "1.0.9",
+        });
+
+        yield* TestClock.adjust("5 seconds");
+
+        expect(deploy.approvers).toStrictEqual(["grace"]);
+        expect(yield* Fiber.join(polled)).toMatchObject([
+          {
+            _tag: "Occurrence",
+            data: { version: "1.0.9", approvers: ["grace"] },
+          },
+        ]);
+      }).pipe(Effect.provide(served))
+  );
+
+  it.effect(
+    "refuses a watch without a member's token, as the route's 401",
+    () =>
+      Effect.gen(function* () {
+        const stranger = yield* as("mallory");
+
+        expect(
+          yield* Effect.flip(Stream.runDrain(stranger.watch(BuildFinished)))
+        ).toBeInstanceOf(Action.Unauthenticated);
+      }).pipe(Effect.provide(served))
+  );
+});