@gjermundgaraba/effect-actions 0.19.0 → 0.21.0

package/examples/kitchen-sink/test/routes.test.ts

@@ -1,19 +1,20 @@
 import { describe, expect, it } from "@effect/vitest";
-import { Effect, flow, Layer } from "effect";
-import { HttpClient, HttpClientRequest } from "effect/http";
 import * as Action from "@gjermundgaraba/effect-actions/Action";
 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, flow, Layer } from "effect";
+import { HttpClient, HttpClientRequest } from "effect/http";
+
 import { Tools } from "../src/Actions.js";
 import { AdminHttp, Http } from "../src/Api.js";
-import { memory } from "../src/memory.js";
 import { adminRoutes, builders, publicRoutes } from "../src/routes.js";
+import { services } from "./support/services.js";
 
 // The host's surfaces, as routes.ts builds them, answering in memory: no port is opened. Each
 // port is a `Testing.layer` of its own, and what they share is provided above both, as
 // server.ts does.
-const shared = builders.pipe(Layer.provideMerge(memory));
+const shared = builders.pipe(Layer.provideMerge(services()));
 
 const onPublicPort = Effect.provide(Testing.layer(publicRoutes));
 
@@ -21,59 +22,92 @@ const onAdminPort = Effect.provide(Testing.layer(adminRoutes));
 
 const ada = {
   transformClient: HttpClient.mapRequest(
-    flow(HttpClientRequest.bearerToken("ada"), HttpClientRequest.setHeader("x-workspace", "acme")),
+    flow(
+      HttpClientRequest.bearerToken("ada"),
+      HttpClientRequest.setHeader("x-workspace", "acme")
+    )
   ),
 };
 
 const ops = {
-  transformClient: HttpClient.mapRequest(HttpClientRequest.setHeader("x-operator-key", "ops-key")),
+  transformClient: HttpClient.mapRequest(
+    HttpClientRequest.setHeader("x-operator-key", "ops-key")
+  ),
 };
 
 const post = (path: string) =>
-  HttpClient.execute(HttpClientRequest.post(path).pipe(HttpClientRequest.bodyJsonUnsafe({})));
+  HttpClient.execute(
+    HttpClientRequest.post(path).pipe(HttpClientRequest.bodyJsonUnsafe({}))
+  );
 
-describe("the public port", () => {
-  it.effect("answers the public action without a token and refuses the rest", () =>
-    Effect.gen(function* () {
-      const anyone = yield* ActionHttp.client(Http);
+const from = (url: string, origin: string) =>
+  HttpClient.execute(
+    ActionMcp.request("tools/list", {}, { url, headers: { origin } })
+  );
 
-      expect(yield* anyone.getStatus()).toMatchObject({ service: "tracker", workspaces: 2 });
-      expect(yield* Effect.flip(anyone.whoAmI())).toBeInstanceOf(Action.Unauthenticated);
-    }).pipe(onPublicPort, Effect.provide(shared)),
+describe("the public port", () => {
+  it.effect(
+    "answers the public action without a token and refuses the rest",
+    () =>
+      Effect.gen(function* () {
+        const anyone = yield* ActionHttp.client(Http);
+
+        expect(yield* anyone.getStatus()).toMatchObject({
+          service: "tracker",
+          workspaces: 2,
+        });
+        expect(yield* Effect.flip(anyone.whoAmI())).toBeInstanceOf(
+          Action.Unauthenticated
+        );
+      }).pipe(onPublicPort, Effect.provide(shared))
   );
 
-  it.effect("lists the tools to a signed-out MCP client, the unlisted action left out", () =>
-    Effect.gen(function* () {
-      const listing = yield* HttpClient.execute(ActionMcp.request("tools/list"));
-      const text = yield* listing.text;
+  it.effect(
+    "lists the tools to a signed-out MCP client, the unlisted action left out",
+    () =>
+      Effect.gen(function* () {
+        const listing = yield* HttpClient.execute(
+          ActionMcp.request("tools/list")
+        );
 
-      expect(listing.status).toBe(200);
-      expect(text).toContain('"name":"createIssue"');
-      expect(text).not.toContain('"name":"attachImage"');
-    }).pipe(onPublicPort, Effect.provide(shared)),
+        const text = yield* listing.text;
+
+        expect(listing.status).toBe(200);
+        expect(text).toContain('"name":"createIssue"');
+        expect(text).not.toContain('"name":"attachImage"');
+      }).pipe(onPublicPort, Effect.provide(shared))
   );
 
-  it.effect("serves one store to both surfaces: an issue filed over HTTP is read as a tool", () =>
-    Effect.gen(function* () {
-      const http = yield* ActionHttp.client(Http, ada);
-      const mcp = yield* ActionMcp.client(Tools, ada);
-      const issue = yield* http.createIssue({ title: "Crash", body: "On save." });
+  it.effect(
+    "serves one store to both surfaces: an issue filed over HTTP is read as a tool",
+    () =>
+      Effect.gen(function* () {
+        const http = yield* ActionHttp.client(Http, ada);
+        const mcp = yield* ActionMcp.client(Tools, ada);
 
-      expect(yield* mcp.getIssue({ id: issue.id })).toEqual(issue);
-    }).pipe(onPublicPort, Effect.provide(shared)),
+        const issue = yield* http.createIssue({
+          title: "Crash",
+          body: "On save.",
+        });
+
+        expect(yield* mcp.getIssue({ id: issue.id })).toStrictEqual(issue);
+      }).pipe(onPublicPort, Effect.provide(shared))
   );
 
-  it.effect("refuses, at the MCP endpoint, a page of this host that is not on its list", () =>
-    Effect.gen(function* () {
-      // The request policy lets both through: one is the request's own origin, one is listed.
-      const from = (url: string, origin: string) =>
-        HttpClient.execute(ActionMcp.request("tools/list", {}, { url, headers: { origin } }));
+  it.effect(
+    "refuses, at the MCP endpoint, a page of this host that is not on its list",
+    () =>
+      Effect.gen(function* () {
+        // The request policy lets both through: one is the request's own origin, one is listed.
+        const listed = yield* from("/mcp", "http://localhost:6274");
 
-      const listed = yield* from("/mcp", "http://localhost:6274");
-      const sameHost = yield* from("http://127.0.0.1/mcp", "http://127.0.0.1");
+        const sameHost = yield* from(
+          "http://127.0.0.1/mcp",
+          "http://127.0.0.1"
+        );
 
-      expect([listed.status, sameHost.status]).toEqual([200, 403]);
-    }).pipe(onPublicPort, Effect.provide(shared)),
+        expect([listed.status, sameHost.status]).toStrictEqual([200, 403]);
+      }).pipe(onPublicPort, Effect.provide(shared))
   );
 });
 
@@ -83,42 +117,53 @@ describe("the two ports", () => {
       const admin = yield* post("/admin/listWorkspaces").pipe(onPublicPort);
       const member = yield* post("/api/v1/whoAmI").pipe(onAdminPort);
 
-      expect([admin.status, member.status]).toEqual([404, 404]);
-    }).pipe(Effect.provide(shared)),
+      expect([admin.status, member.status]).toStrictEqual([404, 404]);
+    }).pipe(Effect.provide(shared))
   );
 
   it.effect("run a builder once for an implementation both serve", () =>
     Effect.gen(function* () {
-      const onPublic = yield* Effect.flatMap(ActionHttp.client(Http), (client) =>
-        client.getStatus(),
+      const onPublic = yield* Effect.flatMap(
+        ActionHttp.client(Http),
+        (client) => client.getStatus()
       ).pipe(onPublicPort);
 
-      const onAdmin = yield* Effect.flatMap(ActionHttp.client(AdminHttp), (client) =>
-        client.getStatus(),
+      const onAdmin = yield* Effect.flatMap(
+        ActionHttp.client(AdminHttp),
+        (client) => client.getStatus()
       ).pipe(onAdminPort);
 
       // `status`'s builder names the start it ran in. With `builders` above both ports it ran
       // once. Provide `memory` alone instead, and each port runs it: two instances.
       expect(onAdmin.instance).toBe(onPublic.instance);
-    }).pipe(Effect.provide(shared)),
+    }).pipe(Effect.provide(shared))
   );
 
-  it.effect("share their services: a workspace suspended on one is refused on the other", () =>
-    Effect.gen(function* () {
-      const whoAmI = Effect.flatMap(ActionHttp.client(Http, ada), (client) => client.whoAmI());
+  it.effect(
+    "share their services: a workspace suspended on one is refused on the other",
+    () =>
+      Effect.gen(function* () {
+        const whoAmI = Effect.flatMap(ActionHttp.client(Http, ada), (client) =>
+          client.whoAmI()
+        );
 
-      expect(yield* whoAmI.pipe(onPublicPort)).toMatchObject({ id: "ada" });
+        expect(yield* whoAmI.pipe(onPublicPort)).toMatchObject({ id: "ada" });
 
-      const suspended = yield* Effect.flatMap(ActionHttp.client(AdminHttp, ops), (client) =>
-        client.suspendWorkspace({ workspace: "acme" }),
-      ).pipe(onAdminPort);
+        const suspended = yield* Effect.flatMap(
+          ActionHttp.client(AdminHttp, ops),
+          (client) => client.suspendWorkspace({ workspace: "acme" })
+        ).pipe(onAdminPort);
 
-      expect(suspended).toEqual({ slug: "acme", name: "Acme", suspended: true });
+        expect(suspended).toStrictEqual({
+          slug: "acme",
+          name: "Acme",
+          suspended: true,
+        });
 
-      const refused = yield* Effect.flip(whoAmI).pipe(onPublicPort);
+        const refused = yield* Effect.flip(whoAmI).pipe(onPublicPort);
 
-      expect(refused).toBeInstanceOf(Action.Forbidden);
-      expect(refused.message).toBe("This workspace is suspended.");
-    }).pipe(Effect.provide(shared)),
+        expect(refused).toBeInstanceOf(Action.Forbidden);
+        expect(refused.message).toBe("This workspace is suspended.");
+      }).pipe(Effect.provide(shared))
   );
 });

package/examples/kitchen-sink/test/support/as.ts

@@ -0,0 +1,9 @@
+import { Effect } from "effect";
+
+import { CurrentMember } from "../../src/identity/Identity.js";
+import { members } from "../../src/identity/members.js";
+
+// What the implementation does, with no transport: `Action.client` runs the same decoding,
+// `authorize` and handler a server runs. Each call or watch names its caller, as a request would.
+export const as = (member: keyof typeof members) =>
+  Effect.provideService(CurrentMember, members[member]);

package/examples/kitchen-sink/test/support/scripted.ts

@@ -1,7 +1,8 @@
 import { Effect, Layer, Ref, Stream } from "effect";
-import { AiError, LanguageModel, type Response } from "effect/ai";
+import { AiError, LanguageModel } from "effect/ai";
+import type { Response } from "effect/ai";
 
-type Reply = ReadonlyArray<Response.PartEncoded>;
+type Reply = readonly Response.PartEncoded[];
 
 // A model for a test: it answers its first request with the first reply it was given, its
 // second with the second, whatever the prompt says. A reply is the parts a provider sends, or
@@ -24,11 +25,11 @@ export const scripted = (
               return Effect.isEffect(reply)
                 ? Effect.map(reply, (parts) => [...parts])
                 : Effect.succeed([...reply]);
-            },
+            }
           ),
         streamText: () => Stream.empty,
       });
-    }),
+    })
   );
 
 export const down: Effect.Effect<never, AiError.AiError> = Effect.fail(
@@ -36,5 +37,5 @@ export const down: Effect.Effect<never, AiError.AiError> = Effect.fail(
     module: "scripted",
     method: "generateText",
     reason: new AiError.UnknownError({ description: "The provider is down." }),
-  }),
+  })
 );

package/examples/kitchen-sink/test/support/services.ts

@@ -0,0 +1,17 @@
+import * as Testing from "@gjermundgaraba/effect-actions/Testing";
+import { Layer } from "effect";
+import { Dns } from "effect/net";
+
+import { memory } from "../../src/memory.js";
+
+const unreached = async () => new Response(null, { status: 503 });
+
+// What the public routes need, in memory: the application's services, and for webhook delivery
+// a client and a resolver. `subscribers` answers each POST in place of a member's server, and
+// hooks.example.com resolves to a public address: delivery refuses a private or loopback one.
+export const services = (subscribers = Testing.layer(unreached)) =>
+  Layer.mergeAll(
+    memory,
+    subscribers,
+    Dns.layerStatic({ hosts: { "hooks.example.com": ["93.184.216.34"] } })
+  );

package/examples/live-rpc/README.md

@@ -1,15 +1,10 @@
 # live-rpc
 
-A chat served as Effect RPC over a WebSocket: one connection per page, many calls on it.
-Members post, read and delete messages in the rooms they belong to; anyone may list the rooms.
-Each message on the socket carries its own token and names its room.
-To serve these same actions as JSON too, see
-[ActionRpc.md](../../docs/ActionRpc.md#serve-the-rpcs).
+A chat served as Effect RPC over a WebSocket: one connection per page, many calls on it. Members post, read and delete messages in the rooms they belong to, and watch a room, each post reaching their page as it is made; anyone may list the rooms. Each message on the socket carries its own token and names its room. To serve these same actions as JSON too, see [ActionRpc.md](../../docs/ActionRpc.md#serve-the-rpcs).
 
 ## Run it
 
-From the repository root, after `vp install` (from an installed package, see
-[Run one](../README.md#run-one)):
+From the repository root, after `vp install` (from an installed package, see [Run one](../README.md#run-one)):
 
 ```sh
 node --import tsx examples/live-rpc/src/server.ts     # 127.0.0.1:3000, HOST and PORT to change
@@ -18,54 +13,57 @@ node --import tsx examples/live-rpc/src/client.ts     # CHAT_URL to change, ws:/
 vp test examples/live-rpc
 ```
 
-`client.ts` runs the browser's client from Node: two members on one socket, then each declared
-error and refusal a page handles. `browser.ts` is imported by a page, not run: `openChat` for a
-page that is an Effect program; `page.ts` wraps it as `connect(url)` for one that calls with promises.
+`client.ts` runs the browser's client from Node: two members on one socket, a watch of the room, then each declared error and refusal a page handles. `browser.ts` is imported by a page, not run: `openChat` for a page that is an Effect program; `page.ts` wraps it as `connect(url)` for one that calls with promises.
 
 ## Layout
 
 ```text
 src/
 ├── chat/
-│   ├── Chat.ts        contract: schemas, errors, actions, the room header and its default
+│   ├── Chat.ts        contract: schemas, errors, actions, MessagePosted, the room header and its default
 │   ├── store.ts       MessageStore, the service the handlers call, and its Layer
 │   ├── room.ts        CurrentRoom, and the RPC middleware providing it per message
 │   ├── authorize.ts   the one authorization rule: a member of the room
-│   └── handlers.ts    Action.implement: contract to store
+│   ├── handlers.ts    Action.implement: contract to store, a post notifying its room
+│   └── events.ts      Event.implement: MessagePosted read from the store, keyed by room
 ├── identity/
 │   ├── Identity.ts    contract: CurrentMember and the Login descriptor
 │   ├── members.ts     the demo members
 │   └── verifier.ts    Authentication.layer: tokens to members, server only
-├── Rpc.ts             the RPC binding of every action
+├── Rpc.ts             the RPC binding of every action and MessagePosted
 ├── routes.ts          the rpcs, authenticated and with their middleware, not yet on a protocol
-├── server.ts          entrypoint: the rpcs over a WebSocket at /rpc, its messages bounded
+├── server.ts          entrypoint: the rpcs over a WebSocket at /rpc, its messages bounded, one Events
 ├── browser.ts         client module: the connection and the chat, as one Effect program
 ├── page.ts            the same chat as promises, for a page that is not one
 └── client.ts          entrypoint: that client, run from Node
 test/
-├── chat/              in process, with Action.client
-├── routes.test.ts     over RPC in memory, with Testing.layer
+├── chat/              in process, with Action.client, a watch included
+├── routes.test.ts     over RPC in memory, with Testing.layer, a watch over NDJSON
 ├── browser.test.ts    the page's client against the same rpcs
-└── server.test.ts     the socket itself: a listening port, connect(url), the bound on a message
+└── server.test.ts     the socket itself: a listening port, connect(url), a watch, the bound on a message
 ```
 
 ## Where to look
 
-| To see                                                                 | Read                                            |
-| ---------------------------------------------------------------------- | ----------------------------------------------- |
-| An RPC binding naming its authentication descriptor                    | `src/Rpc.ts`                                    |
-| The rpcs on Effect's `RpcServer`, before a protocol is chosen          | `src/routes.ts`                                 |
-| Serving them over a WebSocket, speaking JSON                           | `src/server.ts`                                 |
-| A verifier that runs for every message, not once per connection        | `src/identity/verifier.ts`                      |
-| Native `RpcMiddleware` providing a per-request service, with a default | `src/chat/room.ts`                              |
-| Handlers reading that service, and the rule that reads it              | `src/chat/handlers.ts`, `src/chat/authorize.ts` |
-| A public rpc beside protected ones                                     | `src/chat/Chat.ts`                              |
-| A socket client sending its token and room on each message             | `src/browser.ts`                                |
-| Who owns the socket, and how a promise page keeps it open              | `src/browser.ts`, `src/page.ts`                 |
-| A declared error and the built-in refusals handled by tag              | `src/browser.ts`                                |
-| Running that client from Node, two callers on one socket               | `src/client.ts`                                 |
-| Testing handlers and authorization with no transport                   | `test/chat/chat.test.ts`                        |
-| Testing rpcs, authentication and middleware in memory                  | `test/routes.test.ts`                           |
-| The binding's native `RpcGroup` called by Effect's own client          | `test/routes.test.ts`                           |
-| Testing the client's handling of each error and refusal                | `test/browser.test.ts`                          |
-| Testing over a real WebSocket, and a message over `maxPayload`         | `test/server.test.ts`                           |
+| To see | Read |
+| --- | --- |
+| An RPC binding naming its authentication descriptor | `src/Rpc.ts` |
+| The rpcs on Effect's `RpcServer`, before a protocol is chosen | `src/routes.ts` |
+| Serving them over a WebSocket, speaking JSON | `src/server.ts` |
+| A verifier that runs for every message, not once per connection | `src/identity/verifier.ts` |
+| Native `RpcMiddleware` providing a per-request service, with a default | `src/chat/room.ts` |
+| Handlers reading that service, and the rule that reads it | `src/chat/handlers.ts`, `src/chat/authorize.ts` |
+| A public rpc beside protected ones | `src/chat/Chat.ts` |
+| A socket client sending its token and room on each message | `src/browser.ts` |
+| Who owns the socket, and how a promise page keeps it open | `src/browser.ts`, `src/page.ts` |
+| A declared error and the built-in refusals handled by tag | `src/browser.ts` |
+| Running that client from Node, two callers on one socket | `src/client.ts` |
+| Testing handlers and authorization with no transport | `test/chat/chat.test.ts` |
+| Testing rpcs, authentication and middleware in memory | `test/routes.test.ts` |
+| The binding's native `RpcGroup` called by Effect's own client | `test/routes.test.ts` |
+| Testing the client's handling of each error and refusal | `test/browser.test.ts` |
+| Testing over a real WebSocket, and a message over `maxPayload` | `test/server.test.ts` |
+| An event read from the store, its `key` the room a header names | `src/chat/events.ts` |
+| A handler notifying the room it posted to | `src/chat/handlers.ts` |
+| A page watching a room, its headers on the stream, across drops | `src/browser.ts`, `src/page.ts` |
+| Testing a watch in process, over RPC, and over a real WebSocket | `test/chat/chat.test.ts`, `test/routes.test.ts`, `test/server.test.ts` |

package/examples/live-rpc/src/Rpc.ts

@@ -1,8 +1,12 @@
 import * as ActionRpc from "@gjermundgaraba/effect-actions/ActionRpc";
-import { ListRooms, Messages } from "./chat/Chat.js";
+
+import { ListRooms, MessagePosted, Messages } from "./chat/Chat.js";
 import { Login } from "./identity/Identity.js";
 
-// The RPC binding: one native rpc per action, named after it, the protected ones requiring
-// `Login`. It is plain data and imports no server code, so the server and a browser page both
-// import this one value. `Rpc.group` is the native `RpcGroup`, for Effect's own `RpcClient.make`.
-export const Rpc = ActionRpc.make([ListRooms, ...Messages], { authentication: Login });
+// The RPC binding: one native rpc per action, named after it, and a stream rpc for
+// `MessagePosted`, the protected ones requiring `Login`. It is plain data and imports no server
+// code, so the server and a browser page both import this one value. `Rpc.group` is the native
+// `RpcGroup`, for Effect's own `RpcClient.make`.
+export const Rpc = ActionRpc.make([ListRooms, ...Messages, MessagePosted], {
+  authentication: Login,
+});

package/examples/live-rpc/src/browser.ts

@@ -1,8 +1,10 @@
-import { Effect, Layer } from "effect";
+import * as ActionRpc from "@gjermundgaraba/effect-actions/ActionRpc";
+import { Effect, Layer, Stream } from "effect";
+import { Headers } from "effect/http";
 import { RpcClient, RpcSerialization } from "effect/rpc";
 import { Socket } from "effect/socket";
-import * as ActionRpc from "@gjermundgaraba/effect-actions/ActionRpc";
-import { roomHeader } from "./chat/Chat.js";
+
+import { MessagePosted, roomHeader } from "./chat/Chat.js";
 import { Rpc } from "./Rpc.js";
 
 // Client module: what a web page imports. It holds the binding and nothing of the server, so a
@@ -15,7 +17,7 @@ import { Rpc } from "./Rpc.js";
 export const connection = (url: string) =>
   RpcClient.layerProtocolSocket().pipe(
     Layer.provide(Socket.layerWebSocket(url)),
-    Layer.provide(RpcSerialization.layerJson),
+    Layer.provide(RpcSerialization.layerJson)
   );
 
 // The chat as a page uses it, on the connection provided around it.
@@ -30,24 +32,50 @@ export const openChat = Effect.gen(function* () {
     room: (name: string, token: string) => {
       // A browser WebSocket cannot set an `Authorization` header on its upgrade, so the token
       // travels on each message, and the room beside it. A refreshed token needs no new socket.
-      const here = RpcClient.withHeaders({ authorization: `Bearer ${token}`, [roomHeader]: name });
+      const headers = { authorization: `Bearer ${token}`, [roomHeader]: name };
+      const here = RpcClient.withHeaders(headers);
 
       return {
-        // Called again and again while the page is open, with the last id it holds. A token
-        // may expire while the page stays open, so each refusal becomes what the page shows.
+        // What the room holds after the last id the page has. A token may expire while the
+        // page stays open, so each refusal becomes what the page shows.
         read: (after: number) =>
           client.readMessages({ after }).pipe(
             here,
-            Effect.map(({ messages }) => ({ access: "member" as const, messages })),
+            Effect.map(({ messages }) => ({
+              access: "member" as const,
+              messages,
+            })),
             Effect.catchTags({
               Unauthenticated: () =>
                 Effect.succeed({ access: "signed-out" as const, messages: [] }),
-              Forbidden: () => Effect.succeed({ access: "not-a-member" as const, messages: [] }),
-            }),
+              Forbidden: () =>
+                Effect.succeed({
+                  access: "not-a-member" as const,
+                  messages: [],
+                }),
+            })
           ),
 
         post: (text: string) => client.postMessage({ text }).pipe(here),
 
+        // Each message posted to the room after the last id the page holds: a page opening a
+        // room reads it, then watches from the last id it read, so a post between the two is
+        // not lost; 0 sends the room's history first. `watch` connects again after a drop and
+        // resumes from the last message it delivered, so the page never subscribes by hand; a
+        // `Gap` says some were missed, or are another run's, so the page reads the room again
+        // with `read(0)`. The headers go with the
+        // stream, as `here` puts them on a call, and so with every request it sends again. A
+        // refusal ends it, as when it connects again with a token that has expired.
+        messages: (after: number) =>
+          client
+            .watch(MessagePosted, {}, { cursor: String(after) })
+            .pipe(
+              Stream.updateService(
+                RpcClient.CurrentHeaders,
+                Headers.merge(Headers.fromInput(headers))
+              )
+            ),
+
         // A declared error arrives as the contract's class. A message someone else already
         // removed is gone, which is what the page asked for.
         remove: (id: number) =>
@@ -57,7 +85,7 @@ export const openChat = Effect.gen(function* () {
             Effect.catchTags({
               MessageNotFound: () => Effect.succeed("removed" as const),
               NotAuthor: () => Effect.succeed("not-yours" as const),
-            }),
+            })
           ),
       };
     },

package/examples/live-rpc/src/chat/Chat.ts

@@ -1,5 +1,7 @@
-import { Schema } from "effect";
 import * as Action from "@gjermundgaraba/effect-actions/Action";
+import * as Event from "@gjermundgaraba/effect-actions/Event";
+import { Schema } from "effect";
+
 import { CurrentMember } from "../identity/Identity.js";
 
 // A message's `id` counts up within its room, so a client asks for what came after the last
@@ -15,19 +17,17 @@ export type Message = typeof Message.Type;
 // A declared error is part of the contract: every client decodes it as this class. Its status
 // is for a JSON binding, should these actions be served as one too: an rpc carries no status,
 // and an error without one answers 422 over HTTP.
-export class MessageNotFound extends Schema.TaggedError<MessageNotFound>()(
-  "MessageNotFound",
-  { id: Schema.Int },
-  { httpApiStatus: 404 },
-) {}
+export class MessageNotFound extends Schema.TaggedError<
+  MessageNotFound,
+  { readonly brand: unique symbol }
+>()("MessageNotFound", { id: Schema.Int }, { httpApiStatus: 404 }) {}
 
 // A refusal carries what the caller sent and no more: who wrote the message is for the actions
 // that read it, under their own rule.
-export class NotAuthor extends Schema.TaggedError<NotAuthor>()(
-  "NotAuthor",
-  { id: Schema.Int },
-  { httpApiStatus: 403 },
-) {}
+export class NotAuthor extends Schema.TaggedError<
+  NotAuthor,
+  { readonly brand: unique symbol }
+>()("NotAuthor", { id: Schema.Int }, { httpApiStatus: 403 }) {}
 
 // Which room a call is about is not an input of any action: it travels beside the call, in
 // this header, as the token does, because `authorize` sees the action and not its input, and
@@ -44,9 +44,12 @@ export const defaultRoom = "lobby";
 // tells a signed-out caller every room's name and how many messages it holds, a room appearing
 // once someone posts: decide whether yours may.
 export const ListRooms = Action.make("listRooms", {
-  description: "List the rooms someone has posted in, and how many messages each holds.",
+  description:
+    "List the rooms someone has posted in, and how many messages each holds.",
   success: {
-    rooms: Schema.Array(Schema.Struct({ name: Schema.String, messages: Schema.Int })),
+    rooms: Schema.Array(
+      Schema.Struct({ name: Schema.String, messages: Schema.Int })
+    ),
   },
   readOnly: true,
   caller: Action.Anyone,
@@ -54,8 +57,8 @@ export const ListRooms = Action.make("listRooms", {
 
 const signedIn = { caller: CurrentMember } as const;
 
-// Actions are unary: nothing streams. A page keeps up by calling this again on its open
-// socket, passing the last id it has seen.
+// Reads once: a page opening a room reads what is there, then watches `MessagePosted` below from
+// the last id it read.
 export const ReadMessages = Action.make("readMessages", {
   ...signedIn,
   description: "Read the room's messages after the given id; 0 reads them all.",
@@ -67,7 +70,9 @@ export const ReadMessages = Action.make("readMessages", {
 export const PostMessage = Action.make("postMessage", {
   ...signedIn,
   description: "Post a message to the room.",
-  input: { text: Schema.String.check(Schema.isMinLength(1), Schema.isMaxLength(500)) },
+  input: {
+    text: Schema.String.check(Schema.isMinLength(1), Schema.isMaxLength(500)),
+  },
   success: Message,
   readOnly: false,
 });
@@ -81,3 +86,12 @@ export const DeleteMessage = Action.make("deleteMessage", {
 });
 
 export const Messages = [ReadMessages, PostMessage, DeleteMessage] as const;
+
+// Each message posted to the room, as it is posted: a page watches it on its open socket,
+// about the room its header names, as the actions are. Signed-in, so each watch authenticates
+// and runs `authorize` as it starts, refused for a member outside the room.
+export const MessagePosted = Event.make("message.posted", {
+  description: "A message posted to the room.",
+  payload: Message,
+  caller: CurrentMember,
+});

package/examples/live-rpc/src/chat/authorize.ts

@@ -1,5 +1,6 @@
-import { Effect } from "effect";
 import * as Action from "@gjermundgaraba/effect-actions/Action";
+import { Effect } from "effect";
+
 import { CurrentMember } from "../identity/Identity.js";
 import { CurrentRoom } from "./room.js";