@gjermundgaraba/effect-actions 0.19.0 → 0.21.0

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

@@ -1,63 +1,83 @@
 import { describe, expect, it } from "@effect/vitest";
-import { Effect, Layer } from "effect";
-import { RpcClient, RpcSerialization, RpcServer } from "effect/rpc";
 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, Stream } from "effect";
+import { RpcClient, RpcSerialization, RpcServer } from "effect/rpc";
+import { TestClock } from "effect/testing";
+
 import { openChat } from "../src/browser.js";
-import { chatOver } from "../src/page.js";
 import { MessageStore } from "../src/chat/store.js";
+import { chatOver } from "../src/page.js";
 import { rpc } from "../src/routes.js";
 
-// The page's client against the real rpcs, in memory, served as in routes.test.ts. `openChat`
-// needs a client protocol and does not care which: a page gives it `connection(url)`, a
-// WebSocket, and this test Effect's HTTP protocol.
+// The page's client against the real rpcs, in memory, served as in routes.test.ts, NDJSON
+// included. `openChat` needs a client protocol and does not care which: a page gives it
+// `connection(url)`, a WebSocket, and this test Effect's HTTP protocol.
 const served = RpcClient.layerProtocolHttp({ url: "/rpc" }).pipe(
-  Layer.provide(RpcSerialization.layerJson),
+  Layer.provide(RpcSerialization.layerNdjson),
   Layer.provide(
     Testing.layer(
       rpc.pipe(
         Layer.provide(RpcServer.layerProtocolHttp({ path: "/rpc" })),
-        Layer.provide(RpcSerialization.layerJson),
-      ),
-    ),
+        Layer.provide(RpcSerialization.layerNdjson)
+      )
+    )
   ),
-  Layer.provide(MessageStore.layerMemory),
+  Layer.provide([MessageStore.layerMemory, Event.layerMemory])
 );
 
 describe("the page's client", () => {
-  it.effect("posts and reads in the room it names, as the member its token names", () =>
-    Effect.gen(function* () {
-      const chat = yield* openChat;
-      const first = yield* chat.room("lobby", "ada").post("Deploying at noon.");
-      const second = yield* chat.room("lobby", "grace").post("Ready.");
+  it.effect(
+    "posts and reads in the room it names, as the member its token names",
+    () =>
+      Effect.gen(function* () {
+        const chat = yield* openChat;
 
-      yield* chat.room("ops", "ada").post("Disk is full.");
+        const first = yield* chat
+          .room("lobby", "ada")
+          .post("Deploying at noon.");
 
-      expect(first).toEqual({ id: 1, author: "ada", text: "Deploying at noon." });
-      expect(yield* chat.room("lobby", "grace").read(first.id)).toEqual({
-        access: "member",
-        messages: [second],
-      });
-      expect(yield* chat.rooms).toEqual([
-        { name: "lobby", messages: 2 },
-        { name: "ops", messages: 1 },
-      ]);
-    }).pipe(Effect.provide(served)),
+        const second = yield* chat.room("lobby", "grace").post("Ready.");
+
+        yield* chat.room("ops", "ada").post("Disk is full.");
+
+        expect(first).toStrictEqual({
+          id: 1,
+          author: "ada",
+          text: "Deploying at noon.",
+        });
+        expect(yield* chat.room("lobby", "grace").read(first.id)).toStrictEqual(
+          {
+            access: "member",
+            messages: [second],
+          }
+        );
+        expect(yield* chat.rooms).toStrictEqual([
+          { name: "lobby", messages: 2 },
+          { name: "ops", messages: 1 },
+        ]);
+      }).pipe(Effect.provide(served))
   );
 
-  it.effect("turns each declared error of a removal into what the page shows", () =>
-    Effect.gen(function* () {
-      const chat = yield* openChat;
-      const ada = chat.room("lobby", "ada");
-      const grace = chat.room("lobby", "grace");
-      const { id } = yield* ada.post("Oops.");
-
-      expect(yield* grace.remove(id)).toBe("not-yours");
-      expect(yield* grace.read(0)).toMatchObject({ messages: [{ id }] });
-      expect(yield* ada.remove(id)).toBe("removed");
-      expect(yield* grace.read(0)).toEqual({ access: "member", messages: [] });
-      expect(yield* ada.remove(id)).toBe("removed");
-    }).pipe(Effect.provide(served)),
+  it.effect(
+    "turns each declared error of a removal into what the page shows",
+    () =>
+      Effect.gen(function* () {
+        const chat = yield* openChat;
+        const ada = chat.room("lobby", "ada");
+        const grace = chat.room("lobby", "grace");
+        const { id } = yield* ada.post("Oops.");
+
+        expect(yield* grace.remove(id)).toBe("not-yours");
+        expect(yield* grace.read(0)).toMatchObject({ messages: [{ id }] });
+        expect(yield* ada.remove(id)).toBe("removed");
+        expect(yield* grace.read(0)).toStrictEqual({
+          access: "member",
+          messages: [],
+        });
+        expect(yield* ada.remove(id)).toBe("removed");
+      }).pipe(Effect.provide(served))
   );
 
   it.effect("turns each refusal of a read into the access the page shows", () =>
@@ -66,15 +86,62 @@ describe("the page's client", () => {
 
       yield* chat.room("ops", "ada").post("Disk is full.");
 
-      expect(yield* chat.room("ops", "grace").read(0)).toEqual({
+      expect(yield* chat.room("ops", "grace").read(0)).toStrictEqual({
         access: "not-a-member",
         messages: [],
       });
-      expect(yield* chat.room("ops", "expired").read(0)).toEqual({
+      expect(yield* chat.room("ops", "expired").read(0)).toStrictEqual({
         access: "signed-out",
         messages: [],
       });
-    }).pipe(Effect.provide(served)),
+    }).pipe(Effect.provide(served))
+  );
+
+  it.effect(
+    "streams the posts after what the page read, one posted in between included",
+    () =>
+      Effect.gen(function* () {
+        const chat = yield* openChat;
+        const lobby = chat.room("lobby", "grace");
+
+        yield* chat.room("lobby", "ada").post("Deploying at noon.");
+
+        const { messages } = yield* lobby.read(0);
+
+        // Posted after the page read and before it watches: the watch from the last id read
+        // still sends it.
+        yield* chat.room("lobby", "ada").post("Done.");
+
+        const watched = yield* lobby
+          .messages(messages.at(-1)?.id ?? 0)
+          .pipe(Stream.take(1), Stream.runCollect);
+
+        expect(watched).toMatchObject([
+          { _tag: "Occurrence", data: { id: 2, text: "Done." } },
+        ]);
+      }).pipe(Effect.provide(served))
+  );
+
+  it.effect(
+    "sends a gap first for an id the room never gave, then the posts after its last",
+    () =>
+      Effect.gen(function* () {
+        const chat = yield* openChat;
+
+        // As after a restart emptied the demo's memory store: the page holds id 7.
+        const watching = yield* chat
+          .room("lobby", "grace")
+          .messages(7)
+          .pipe(Stream.take(2), Stream.runCollect, Effect.forkChild);
+
+        yield* Effect.repeat(TestClock.adjust("0 millis"), { times: 10 });
+        yield* chat.room("lobby", "ada").post("Hello again.");
+
+        expect(yield* Fiber.join(watching)).toMatchObject([
+          { _tag: "Gap" },
+          { _tag: "Occurrence", data: { id: 1, text: "Hello again." } },
+        ]);
+      }).pipe(Effect.provide(served))
   );
 
   // `connect(url)` is this with a WebSocket. Each test's runtime builds its own layer, and so
@@ -84,23 +151,33 @@ describe("the page's client", () => {
 
     const posted = await chat.room("lobby", "ada").post("Deploying at noon.");
 
-    expect(posted).toEqual({ id: 1, author: "ada", text: "Deploying at noon." });
-    expect(await chat.room("lobby", "grace").read(0)).toEqual({
+    expect(posted).toStrictEqual({
+      id: 1,
+      author: "ada",
+      text: "Deploying at noon.",
+    });
+    await expect(chat.room("lobby", "grace").read(0)).resolves.toStrictEqual({
       access: "member",
       messages: [posted],
     });
-    expect(await chat.room("lobby", "grace").remove(posted.id)).toBe("not-yours");
-    expect(await chat.room("ops", "expired").read(0)).toEqual({
+    await expect(chat.room("lobby", "grace").remove(posted.id)).resolves.toBe(
+      "not-yours"
+    );
+    await expect(chat.room("ops", "expired").read(0)).resolves.toStrictEqual({
       access: "signed-out",
       messages: [],
     });
-    expect(await chat.rooms()).toEqual([{ name: "lobby", messages: 1 }]);
+    await expect(chat.rooms()).resolves.toStrictEqual([
+      { name: "lobby", messages: 1 },
+    ]);
 
     // A failure `openChat` does not handle rejects: here, a text the contract refuses.
-    await expect(chat.room("lobby", "ada").post("")).rejects.toBeInstanceOf(Action.InvalidInput);
+    await expect(chat.room("lobby", "ada").post("")).rejects.toBeInstanceOf(
+      Action.InvalidInput
+    );
 
     await chat.close();
 
-    await expect(chat.rooms()).rejects.toThrow();
+    await expect(chat.rooms()).rejects.toThrow("disposed");
   });
 });

package/examples/live-rpc/test/chat/chat.test.ts

@@ -1,7 +1,11 @@
 import { describe, expect, it } from "@effect/vitest";
-import { Effect, flow } from "effect";
 import * as Action from "@gjermundgaraba/effect-actions/Action";
-import { NotAuthor } from "../../src/chat/Chat.js";
+import * as Event from "@gjermundgaraba/effect-actions/Event";
+import { Effect, Fiber, flow, Stream } from "effect";
+import { TestClock } from "effect/testing";
+
+import { MessagePosted, NotAuthor } from "../../src/chat/Chat.js";
+import { messageEvents } from "../../src/chat/events.js";
 import { messages } from "../../src/chat/handlers.js";
 import { CurrentRoom } from "../../src/chat/room.js";
 import { MessageStore } from "../../src/chat/store.js";
@@ -15,7 +19,19 @@ import { members } from "../../src/identity/members.js";
 const as = (member: keyof typeof members, room: string) =>
   flow(
     Effect.provideService(CurrentMember, members[member]),
-    Effect.provideService(CurrentRoom, room),
+    Effect.provideService(CurrentRoom, room)
+  );
+
+const posted = (text: string) =>
+  Effect.flatMap(Action.client([messages, messageEvents]), (client) =>
+    client.postMessage({ text }).pipe(as("ada", "lobby"))
+  );
+
+const watchedFrom = (cursor: string) =>
+  Effect.flatMap(Action.client([messages, messageEvents]), (client) =>
+    client
+      .watch(MessagePosted, {}, { cursor })
+      .pipe(Stream.take(1), Stream.runCollect, as("grace", "lobby"))
   );
 
 describe("messages, in process", () => {
@@ -23,47 +39,223 @@ describe("messages, in process", () => {
     Effect.gen(function* () {
       const client = yield* Action.client(messages);
 
-      yield* client.postMessage({ text: "Deploying at noon." }).pipe(as("ada", "lobby"));
-      yield* client.postMessage({ text: "Disk is full." }).pipe(as("ada", "ops"));
+      yield* client
+        .postMessage({ text: "Deploying at noon." })
+        .pipe(as("ada", "lobby"));
+      yield* client
+        .postMessage({ text: "Disk is full." })
+        .pipe(as("ada", "ops"));
       yield* client.postMessage({ text: "Ready." }).pipe(as("grace", "lobby"));
 
-      expect(yield* client.readMessages({ after: 1 }).pipe(as("grace", "lobby"))).toEqual({
+      expect(
+        yield* client.readMessages({ after: 1 }).pipe(as("grace", "lobby"))
+      ).toStrictEqual({
         messages: [{ id: 2, author: "grace", text: "Ready." }],
       });
-      expect(yield* client.readMessages({ after: 0 }).pipe(as("ada", "ops"))).toEqual({
+      expect(
+        yield* client.readMessages({ after: 0 }).pipe(as("ada", "ops"))
+      ).toStrictEqual({
         messages: [{ id: 1, author: "ada", text: "Disk is full." }],
       });
-    }).pipe(Effect.provide(MessageStore.layerMemory)),
+    }).pipe(Effect.provide([MessageStore.layerMemory, Event.layerMemory]))
   );
 
   it.effect("lets only its author delete a message", () =>
     Effect.gen(function* () {
       const client = yield* Action.client(messages);
-      const { id } = yield* client.postMessage({ text: "Oops." }).pipe(as("ada", "lobby"));
 
-      expect(yield* Effect.flip(client.deleteMessage({ id }).pipe(as("grace", "lobby")))).toEqual(
-        new NotAuthor({ id }),
-      );
+      const { id } = yield* client
+        .postMessage({ text: "Oops." })
+        .pipe(as("ada", "lobby"));
+
+      expect(
+        yield* Effect.flip(
+          client.deleteMessage({ id }).pipe(as("grace", "lobby"))
+        )
+      ).toStrictEqual(new NotAuthor({ id }));
 
       yield* client.deleteMessage({ id }).pipe(as("ada", "lobby"));
 
-      expect(yield* client.readMessages({ after: 0 }).pipe(as("grace", "lobby"))).toEqual({
+      expect(
+        yield* client.readMessages({ after: 0 }).pipe(as("grace", "lobby"))
+      ).toStrictEqual({
         messages: [],
       });
-    }).pipe(Effect.provide(MessageStore.layerMemory)),
+    }).pipe(Effect.provide([MessageStore.layerMemory, Event.layerMemory]))
+  );
+
+  it.effect(
+    "refuses a member a room they have not joined, before the handler runs",
+    () =>
+      Effect.gen(function* () {
+        const client = yield* Action.client(messages);
+
+        const post = client
+          .postMessage({ text: "Hello?" })
+          .pipe(as("grace", "ops"));
+
+        const refused = yield* Effect.flip(post);
+
+        expect(refused).toBeInstanceOf(Action.Forbidden);
+        expect(refused.message).toBe("Not a member of ops.");
+        expect(
+          yield* client.readMessages({ after: 0 }).pipe(as("ada", "ops"))
+        ).toStrictEqual({
+          messages: [],
+        });
+      }).pipe(Effect.provide([MessageStore.layerMemory, Event.layerMemory]))
+  );
+
+  it.effect(
+    "delivers each message posted to a watched room as it is posted, and none of another",
+    () =>
+      Effect.gen(function* () {
+        const client = yield* Action.client([messages, messageEvents]);
+        const { epoch } = yield* MessageStore;
+
+        const watching = yield* client
+          .watch(MessagePosted, {})
+          .pipe(
+            Stream.take(1),
+            Stream.runCollect,
+            as("grace", "lobby"),
+            Effect.forkChild
+          );
+
+        // The watch starts from now: let it take its first position before anyone posts.
+        yield* TestClock.adjust("0 millis");
+        yield* client
+          .postMessage({ text: "Disk is full." })
+          .pipe(as("ada", "ops"));
+        yield* client.postMessage({ text: "Ready." }).pipe(as("ada", "lobby"));
+
+        // `postMessage` notifies: the watch reads at once, with no wait for its next read.
+        expect(yield* Fiber.join(watching)).toMatchObject([
+          {
+            _tag: "Occurrence",
+            eventId: `${epoch}:lobby:1`,
+            data: { id: 1, author: "ada", text: "Ready." },
+          },
+        ]);
+      }).pipe(Effect.provide([MessageStore.layerMemory, Event.layerMemory]))
+  );
+
+  it.effect(
+    "names the first message after a restart apart from the one before it",
+    () =>
+      Effect.gen(function* () {
+        const firstReceived = Effect.gen(function* () {
+          const client = yield* Action.client([messages, messageEvents]);
+
+          const watching = yield* client
+            .watch(MessagePosted, {})
+            .pipe(
+              Stream.take(1),
+              Stream.runCollect,
+              as("grace", "lobby"),
+              Effect.forkChild
+            );
+
+          yield* TestClock.adjust("0 millis");
+          yield* client
+            .postMessage({ text: "Ready." })
+            .pipe(as("ada", "lobby"));
+
+          return yield* Fiber.join(watching);
+        }).pipe(Effect.provide([MessageStore.layerMemory, Event.layerMemory]));
+
+        const received = [...(yield* firstReceived), ...(yield* firstReceived)];
+
+        // Both are the room's message 1, and a watch that saw the first still reads the second.
+        expect(received).toMatchObject([
+          { data: { id: 1 } },
+          { data: { id: 1 } },
+        ]);
+        expect(
+          new Set(
+            received.map((each) =>
+              each._tag === "Occurrence" ? each.eventId : ""
+            )
+          ).size
+        ).toBe(2);
+      })
   );
 
-  it.effect("refuses a member a room they have not joined, before the handler runs", () =>
+  it.effect("refuses a watch of a room the member has not joined", () =>
     Effect.gen(function* () {
-      const client = yield* Action.client(messages);
-      const post = client.postMessage({ text: "Hello?" }).pipe(as("grace", "ops"));
-      const refused = yield* Effect.flip(post);
+      const client = yield* Action.client([messages, messageEvents]);
+
+      const refused = yield* Effect.flip(
+        Stream.runDrain(client.watch(MessagePosted, {})).pipe(
+          as("grace", "ops")
+        )
+      );
 
       expect(refused).toBeInstanceOf(Action.Forbidden);
-      expect(refused.message).toBe("Not a member of ops.");
-      expect(yield* client.readMessages({ after: 0 }).pipe(as("ada", "ops"))).toEqual({
-        messages: [],
-      });
-    }).pipe(Effect.provide(MessageStore.layerMemory)),
+    }).pipe(Effect.provide([MessageStore.layerMemory, Event.layerMemory]))
+  );
+
+  it.effect(
+    "answers a cursor that names no id of the room with a gap, then reads on",
+    () =>
+      Effect.gen(function* () {
+        const client = yield* Action.client([messages, messageEvents]);
+        const { epoch } = yield* MessageStore;
+
+        yield* client.postMessage({ text: "Ready." }).pipe(as("ada", "lobby"));
+
+        // An event's id, such as `<epoch>:lobby:1`, is no cursor: the cursor is `<epoch>:<id>`.
+        const received = yield* client
+          .watch(MessagePosted, {}, { cursor: "lobby:1" })
+          .pipe(Stream.take(1), Stream.runCollect, as("grace", "lobby"));
+
+        expect(received).toMatchObject([{ _tag: "Gap", cursor: `${epoch}:1` }]);
+      }).pipe(Effect.provide([MessageStore.layerMemory, Event.layerMemory]))
+  );
+
+  it.effect(
+    "answers a cursor with more parts than `<epoch>:<id>` with a gap",
+    () =>
+      Effect.gen(function* () {
+        const client = yield* Action.client([messages, messageEvents]);
+        const { epoch } = yield* MessageStore;
+
+        yield* client
+          .postMessage({ text: "Disk is full." })
+          .pipe(as("ada", "lobby"));
+        yield* client.postMessage({ text: "Ready." }).pipe(as("ada", "lobby"));
+
+        const received = yield* client
+          .watch(MessagePosted, {}, { cursor: `${epoch}:1:lobby` })
+          .pipe(Stream.take(1), Stream.runCollect, as("grace", "lobby"));
+
+        expect(received).toMatchObject([{ _tag: "Gap", cursor: `${epoch}:2` }]);
+      }).pipe(Effect.provide([MessageStore.layerMemory, Event.layerMemory]))
+  );
+
+  it.effect(
+    "answers a cursor from before a restart with a gap, however far the store has counted",
+    () =>
+      Effect.gen(function* () {
+        const run = Effect.provide([
+          MessageStore.layerMemory,
+          Event.layerMemory,
+        ]);
+
+        const [before] = yield* Effect.andThen(
+          posted("Before the restart."),
+          watchedFrom("0")
+        ).pipe(run);
+
+        const after = yield* Effect.andThen(
+          posted("After the restart."),
+          watchedFrom(
+            before?._tag === "Occurrence" ? (before.cursor ?? "") : ""
+          )
+        ).pipe(run);
+
+        expect(before).toMatchObject({ _tag: "Occurrence", data: { id: 1 } });
+        expect(after).toMatchObject([{ _tag: "Gap" }]);
+      })
   );
 });