@gjermundgaraba/effect-actions 0.19.0 → 0.21.0

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

@@ -1,64 +1,72 @@
 import { describe, expect, it } from "@effect/vitest";
+import * as Action from "@gjermundgaraba/effect-actions/Action";
 import { Array, Effect, Layer, References } from "effect";
 import { RateLimiter } from "effect/persistence";
-import * as Action from "@gjermundgaraba/effect-actions/Action";
-import { CurrentMember } from "../../src/identity/Identity.js";
+
 import { members } from "../../src/identity/members.js";
 import { issues } from "../../src/issues/handlers.js";
 import { IssueNotFound, Issues, RateLimited } from "../../src/issues/Issues.js";
 import { IssueStore } from "../../src/issues/store.js";
 import { status } from "../../src/workspaces/handlers.js";
-
-// What the implementation does, with no transport: `Action.client` runs the same decoding,
-// `authorize` and handler a server runs. Each call names its caller, as a request would.
-const as = (member: keyof typeof members) => Effect.provideService(CurrentMember, members[member]);
+import { as } from "../support/as.js";
 
 // The two startup services the issues' builder yields, and nothing else of the application.
 const services = Layer.mergeAll(
   IssueStore.layerMemory,
-  RateLimiter.layer.pipe(Layer.provide(RateLimiter.layerStoreMemory)),
+  RateLimiter.layer.pipe(Layer.provide(RateLimiter.layerStoreMemory))
 );
 
 describe("issues, in process", () => {
   it.effect("keeps each workspace's issues its own", () =>
     Effect.gen(function* () {
       const client = yield* Action.client(issues);
-      const issue = yield* client.createIssue({ title: "Crash", body: "On save." }).pipe(as("ada"));
+
+      const issue = yield* client
+        .createIssue({ title: "Crash", body: "On save." })
+        .pipe(as("ada"));
 
       expect(issue).toMatchObject({ id: "ACME-1", status: "open" });
-      expect(yield* client.listIssues().pipe(as("linus"))).toEqual({
+      expect(yield* client.listIssues().pipe(as("linus"))).toStrictEqual({
         issues: [{ id: "ACME-1", title: "Crash", status: "open" }],
       });
-      expect(yield* client.listIssues().pipe(as("grace"))).toEqual({ issues: [] });
-      expect(yield* Effect.flip(client.getIssue({ id: issue.id }).pipe(as("grace")))).toEqual(
-        new IssueNotFound({ id: "ACME-1" }),
-      );
-    }).pipe(Effect.provide(services)),
+      expect(yield* client.listIssues().pipe(as("grace"))).toStrictEqual({
+        issues: [],
+      });
+      expect(
+        yield* Effect.flip(client.getIssue({ id: issue.id }).pipe(as("grace")))
+      ).toStrictEqual(new IssueNotFound({ id: "ACME-1" }));
+    }).pipe(Effect.provide(services))
   );
 
-  it.effect("lists twenty by default, newest first, or the status and limit asked for", () =>
-    Effect.gen(function* () {
-      const client = yield* Action.client(issues);
-      const store = yield* IssueStore;
-
-      // Written to the store, not through `createIssue`: twenty-one are over its write limit.
-      yield* Effect.forEach(Array.range(1, 21), (n) =>
-        store.create(members.ada.workspace, { title: `Issue ${n}`, body: "" }),
-      );
-      yield* client.closeIssue({ id: "ACME-2" }).pipe(as("ada"));
-
-      const all = yield* client.listIssues().pipe(as("ada"));
-      const closed = yield* client.listIssues({ status: "closed", limit: 20 }).pipe(as("ada"));
-      const newest = yield* client.listIssues({ limit: 1 }).pipe(as("ada"));
-
-      expect(all.issues.map(({ id }) => id)).toEqual(
-        Array.range(2, 21)
-          .map((n) => `ACME-${n}`)
-          .toReversed(),
-      );
-      expect(closed.issues.map(({ id }) => id)).toEqual(["ACME-2"]);
-      expect(newest.issues.map(({ id }) => id)).toEqual(["ACME-21"]);
-    }).pipe(Effect.provide(services)),
+  it.effect(
+    "lists twenty by default, newest first, or the status and limit asked for",
+    () =>
+      Effect.gen(function* () {
+        const client = yield* Action.client(issues);
+        const store = yield* IssueStore;
+
+        // Written to the store, not through `createIssue`: twenty-one are over its write limit.
+        yield* Effect.forEach(Array.range(1, 21), (n) =>
+          store.create(members.ada.workspace, { title: `Issue ${n}`, body: "" })
+        );
+        yield* client.closeIssue({ id: "ACME-2" }).pipe(as("ada"));
+
+        const all = yield* client.listIssues().pipe(as("ada"));
+
+        const closed = yield* client
+          .listIssues({ status: "closed", limit: 20 })
+          .pipe(as("ada"));
+
+        const newest = yield* client.listIssues({ limit: 1 }).pipe(as("ada"));
+
+        expect(all.issues.map(({ id }) => id)).toStrictEqual(
+          Array.range(2, 21)
+            .map((n) => `ACME-${n}`)
+            .toReversed()
+        );
+        expect(closed.issues.map(({ id }) => id)).toStrictEqual(["ACME-2"]);
+        expect(newest.issues.map(({ id }) => id)).toStrictEqual(["ACME-21"]);
+      }).pipe(Effect.provide(services))
   );
 
   it.effect("refuses a write from a member holding the read scope alone", () =>
@@ -68,9 +76,11 @@ describe("issues, in process", () => {
 
       const refused = yield* Effect.flip(create.pipe(as("linus")));
 
-      expect(refused).toEqual(new Action.Forbidden({ scopes: ["issues:write"] }));
+      expect(refused).toStrictEqual(
+        new Action.Forbidden({ scopes: ["issues:write"] })
+      );
       expect(refused.message).toBe("Requires issues:write.");
-    }).pipe(Effect.provide(services)),
+    }).pipe(Effect.provide(services))
   );
 
   it.effect("keeps both of two comments made at once", () =>
@@ -84,50 +94,70 @@ describe("issues, in process", () => {
       // three, the two do not finish.
       const kept = yield* Effect.forEach(Array.range(3, 60), (steps) =>
         Effect.gen(function* () {
-          const { id } = yield* store.create(workspace, { title: "Crash", body: "" });
-
-          yield* Effect.all(
-            ["One", "Two"].map((text) => store.comment(workspace, id, { author: "ada", text })),
-            { concurrency: "unbounded" },
+          const { id } = yield* store.create(workspace, {
+            title: "Crash",
+            body: "",
+          });
+
+          yield* Effect.forEach(
+            ["One", "Two"],
+            (text) => store.comment(workspace, id, { author: "ada", text }),
+            { concurrency: "unbounded" }
           ).pipe(Effect.provideService(References.MaxOpsBeforeYield, steps));
 
           return (yield* store.get(workspace, id)).comments.length;
-        }),
+        })
       );
 
-      expect(kept).toEqual(Array.range(3, 60).map(() => 2));
-    }).pipe(Effect.provide(services)),
+      expect(kept).toStrictEqual(Array.range(3, 60).map(() => 2));
+    }).pipe(Effect.provide(services))
   );
 
-  it.effect("counts every write of a member against one limit, and no one else's", () =>
-    Effect.gen(function* () {
-      const client = yield* Action.client(issues);
-
-      yield* client.createIssue({ title: "Crash", body: "" }).pipe(as("ada"));
-      yield* Effect.forEach(Array.range(1, 9), (n) =>
-        client.commentOnIssue({ id: "ACME-1", text: `Comment ${n}` }).pipe(as("ada")),
-      );
-
-      // Ten writes are spent, by two actions: the eleventh, of a third, is refused.
-      expect(
-        yield* Effect.flip(client.closeIssue({ id: "ACME-1" }).pipe(as("ada"))),
-      ).toBeInstanceOf(RateLimited);
-      expect(yield* client.getIssue({ id: "ACME-1" }).pipe(as("ada"))).toMatchObject({
-        status: "open",
-      });
-      expect(
-        yield* client.createIssue({ title: "Mine", body: "" }).pipe(as("grace")),
-      ).toMatchObject({ id: "GLOBEX-1" });
-    }).pipe(Effect.provide(services)),
+  it.effect(
+    "counts every write of a member against one limit, and no one else's",
+    () =>
+      Effect.gen(function* () {
+        const client = yield* Action.client(issues);
+
+        yield* client.createIssue({ title: "Crash", body: "" }).pipe(as("ada"));
+        yield* Effect.forEach(Array.range(1, 9), (n) =>
+          client
+            .commentOnIssue({ id: "ACME-1", text: `Comment ${n}` })
+            .pipe(as("ada"))
+        );
+
+        // Ten writes are spent, by two actions: the eleventh, of a third, is refused.
+        expect(
+          yield* Effect.flip(
+            client.closeIssue({ id: "ACME-1" }).pipe(as("ada"))
+          )
+        ).toBeInstanceOf(RateLimited);
+        expect(
+          yield* client.getIssue({ id: "ACME-1" }).pipe(as("ada"))
+        ).toMatchObject({
+          status: "open",
+        });
+        expect(
+          yield* client
+            .createIssue({ title: "Mine", body: "" })
+            .pipe(as("grace"))
+        ).toMatchObject({ id: "GLOBEX-1" });
+      }).pipe(Effect.provide(services))
   );
 
-  it.effect("builds only the implementations whose actions a client lists", () =>
-    Effect.gen(function* () {
-      // Two implementations are passed, and `actions` selects the issues': `status` is left
-      // out, unbuilt, so `services` need not hold the registry its builder yields.
-      const client = yield* Action.client([status, issues], { actions: Issues });
-
-      expect(yield* client.listIssues().pipe(as("ada"))).toEqual({ issues: [] });
-    }).pipe(Effect.provide(services)),
+  it.effect(
+    "builds only the implementations whose actions a client lists",
+    () =>
+      Effect.gen(function* () {
+        // Two implementations are passed, and `actions` selects the issues': `status` is left
+        // out, unbuilt, so `services` need not hold the registry its builder yields.
+        const client = yield* Action.client([status, issues], {
+          actions: Issues,
+        });
+
+        expect(yield* client.listIssues().pipe(as("ada"))).toStrictEqual({
+          issues: [],
+        });
+      }).pipe(Effect.provide(services))
   );
 });

package/examples/kitchen-sink/test/request-policy.test.ts

@@ -1,25 +1,37 @@
+import { NodeHttpServer } from "@effect/platform-node";
 import { afterAll, describe, expect, it } from "@effect/vitest";
-import { Effect, Layer } from "effect";
-import { HttpRouter, HttpServer } from "effect/http";
 import * as ActionHttp from "@gjermundgaraba/effect-actions/ActionHttp";
 import * as Testing from "@gjermundgaraba/effect-actions/Testing";
+import { ConfigProvider, Effect, Layer } from "effect";
+import {
+  HttpClient,
+  HttpClientRequest,
+  HttpRouter,
+  HttpServer,
+} from "effect/http";
+
 import { Http } from "../src/Api.js";
 import { memory } from "../src/memory.js";
 import { adminRoutes, publicRoutes } from "../src/routes.js";
+import { services } from "./support/services.js";
 
 // Each port as a web handler, `Request` in and `Response` out: what a platform without
 // Effect's server runs, and what a test sends raw requests to. A handler builds its routes
 // once; the test owns it, and disposes it when done.
 const web = HttpRouter.toWebHandler(
-  publicRoutes.pipe(Layer.provide(HttpServer.layerServices), Layer.provide(memory)),
+  publicRoutes.pipe(
+    Layer.provide(HttpServer.layerServices),
+    Layer.provide(services())
+  )
 );
 
 const adminWeb = HttpRouter.toWebHandler(
-  adminRoutes.pipe(Layer.provide(HttpServer.layerServices), Layer.provide(memory)),
+  adminRoutes.pipe(
+    Layer.provide(HttpServer.layerServices),
+    Layer.provide(memory)
+  )
 );
 
-afterAll(() => Promise.all([web.dispose(), adminWeb.dispose()]));
-
 const post = (url: string, headers: Record<string, string> = {}) =>
   new Request(url, {
     method: "POST",
@@ -27,32 +39,49 @@ const post = (url: string, headers: Record<string, string> = {}) =>
     body: "{}",
   });
 
+const read = async (url: string, headers: Record<string, string> = {}) =>
+  await web.handler(new Request(url, { headers }));
+
 const discovery = "/.well-known/oauth-protected-resource/mcp";
 
 describe("the request policy", () => {
+  afterAll(async () => {
+    await Promise.all([web.dispose(), adminWeb.dispose()]);
+  });
+
   it("refuses a foreign Host or Origin", async () => {
-    const foreignHost = await web.handler(post("http://tracker.evil.example/api/v1/getStatus"));
+    const foreignHost = await web.handler(
+      post("http://tracker.evil.example/api/v1/getStatus")
+    );
 
     const foreignOrigin = await web.handler(
-      post("http://localhost/api/v1/getStatus", { origin: "http://evil.example" }),
+      post("http://localhost/api/v1/getStatus", {
+        origin: "http://evil.example",
+      })
     );
 
-    expect([foreignHost.status, await foreignHost.text()]).toEqual([403, "Host not allowed"]);
-    expect([foreignOrigin.status, await foreignOrigin.text()]).toEqual([403, "Origin not allowed"]);
+    expect([foreignHost.status, await foreignHost.text()]).toStrictEqual([
+      403,
+      "Host not allowed",
+    ]);
+    expect([foreignOrigin.status, await foreignOrigin.text()]).toStrictEqual([
+      403,
+      "Origin not allowed",
+    ]);
   });
 
   it("runs before authentication: a foreign Host is refused, not asked to sign in", async () => {
     const signedOut = await web.handler(post("http://localhost/api/v1/whoAmI"));
-    const foreignHost = await web.handler(post("http://tracker.evil.example/api/v1/whoAmI"));
 
-    expect([signedOut.status, foreignHost.status]).toEqual([401, 403]);
+    const foreignHost = await web.handler(
+      post("http://tracker.evil.example/api/v1/whoAmI")
+    );
+
+    expect([signedOut.status, foreignHost.status]).toStrictEqual([401, 403]);
     expect(foreignHost.headers.get("www-authenticate")).toBeNull();
   });
 
   it("runs before the discovery the Bearer provider publishes", async () => {
-    const read = (url: string, headers: Record<string, string> = {}) =>
-      web.handler(new Request(url, { headers }));
-
     const here = await read(`http://localhost${discovery}`);
     const foreignHost = await read(`http://tracker.evil.example${discovery}`);
 
@@ -60,12 +89,18 @@ describe("the request policy", () => {
       origin: "http://evil.test",
     });
 
-    expect([here.status, foreignHost.status, foreignOrigin.status]).toEqual([200, 403, 403]);
+    expect([
+      here.status,
+      foreignHost.status,
+      foreignOrigin.status,
+    ]).toStrictEqual([200, 403, 403]);
   });
 
   it("answers the browser MCP client's origin, and its CORS preflight", async () => {
     const allowed = await web.handler(
-      post("http://localhost/api/v1/getStatus", { origin: "http://localhost:6274" }),
+      post("http://localhost/api/v1/getStatus", {
+        origin: "http://localhost:6274",
+      })
     );
 
     const preflight = await web.handler(
@@ -74,16 +109,23 @@ describe("the request policy", () => {
         headers: {
           origin: "http://localhost:6274",
           "access-control-request-method": "POST",
-          "access-control-request-headers": "authorization, mcp-protocol-version",
+          "access-control-request-headers":
+            "authorization, mcp-protocol-version",
         },
-      }),
+      })
     );
 
     expect(allowed.status).toBe(200);
-    expect(allowed.headers.get("access-control-allow-origin")).toBe("http://localhost:6274");
+    expect(allowed.headers.get("access-control-allow-origin")).toBe(
+      "http://localhost:6274"
+    );
     expect(preflight.status).toBe(204);
-    expect(preflight.headers.get("access-control-allow-headers")).toContain("MCP-Protocol-Version");
-    expect(allowed.headers.get("access-control-expose-headers")).toContain("Mcp-Session-Id");
+    expect(preflight.headers.get("access-control-allow-headers")).toContain(
+      "MCP-Protocol-Version"
+    );
+    expect(allowed.headers.get("access-control-expose-headers")).toContain(
+      "Mcp-Session-Id"
+    );
   });
 
   it("lets a browser client of an MCP revision with sessions end its session", async () => {
@@ -95,31 +137,86 @@ describe("the request policy", () => {
           "access-control-request-method": "DELETE",
           "access-control-request-headers": "authorization, mcp-session-id",
         },
-      }),
+      })
     );
 
     expect(preflight.status).toBe(204);
-    expect(preflight.headers.get("access-control-allow-methods")).toContain("DELETE");
-    expect(preflight.headers.get("access-control-allow-headers")).toContain("Mcp-Session-Id");
+    expect(preflight.headers.get("access-control-allow-methods")).toContain(
+      "DELETE"
+    );
+    expect(preflight.headers.get("access-control-allow-headers")).toContain(
+      "Mcp-Session-Id"
+    );
   });
 
   it("covers the admin port too, a valid key included", async () => {
     const key = { "x-operator-key": "ops-key" };
-    const here = await adminWeb.handler(post("http://localhost/admin/listWorkspaces", key));
+
+    const here = await adminWeb.handler(
+      post("http://localhost/admin/listWorkspaces", key)
+    );
 
     const foreignHost = await adminWeb.handler(
-      post("http://tracker.evil.example/admin/listWorkspaces", key),
+      post("http://tracker.evil.example/admin/listWorkspaces", key)
     );
 
-    expect([here.status, foreignHost.status]).toEqual([200, 403]);
+    expect([here.status, foreignHost.status]).toStrictEqual([200, 403]);
   });
 
-  // `Testing.layer(handler)` gives the typed clients the same handler the raw requests hit.
-  it.effect("leaves the typed client, served from the same web handler, alone", () =>
+  // Behind a proxy ending TLS, Node's server sees `http:`: the public URL's origin is allowed by
+  // name, not as the request's own, so a page of it is answered whatever the proxy forwards.
+  it.effect("answers the public URL's page behind a proxy ending TLS", () =>
     Effect.gen(function* () {
-      const client = yield* ActionHttp.client(Http);
+      const client = yield* HttpClient.HttpClient;
+
+      const status = (origin: string) =>
+        client
+          .execute(
+            HttpClientRequest.post("/api/v1/getStatus").pipe(
+              HttpClientRequest.setHeaders({
+                origin,
+                "x-forwarded-proto": "https",
+              }),
+              HttpClientRequest.bodyJsonUnsafe({})
+            )
+          )
+          .pipe(Effect.map((response) => response.status));
+
+      expect([
+        yield* status("https://tracker.example"),
+        yield* status("https://evil.example"),
+      ]).toStrictEqual([200, 403]);
+    }).pipe(
+      Effect.provide(
+        HttpRouter.serve(publicRoutes, {
+          disableLogger: true,
+          disableListenLog: true,
+        }).pipe(
+          Layer.provide(services()),
+          Layer.provideMerge(NodeHttpServer.layerTest),
+          Layer.provide(
+            ConfigProvider.layer(
+              ConfigProvider.fromEnvRecord({
+                PUBLIC_URL: "https://tracker.example",
+              })
+            )
+          )
+        )
+      )
+    )
+  );
 
-      expect(yield* client.getStatus()).toMatchObject({ service: "tracker", workspaces: 2 });
-    }).pipe(Effect.provide(Testing.layer(web.handler))),
+  // `Testing.layer(handler)` gives the typed clients the same handler the raw requests hit.
+  it.effect(
+    "leaves the typed client, served from the same web handler, alone",
+    () =>
+      Effect.gen(function* () {
+        const client = yield* ActionHttp.client(Http);
+
+        expect(yield* client.getStatus()).toMatchObject({
+          service: "tracker",
+          workspaces: 2,
+        });
+      }).pipe(Effect.provide(Testing.layer(web.handler)))
   );
 });