@gjermundgaraba/effect-actions 0.20.0 → 0.21.0

package/examples/notes-service/src/notes/store.ts

@@ -1,5 +1,7 @@
 import { Context, Effect, Layer } from "effect";
-import { type Note, NoteChanged, NoteNotFound, RequestConflict } from "./Notes.js";
+
+import { NoteChanged, NoteNotFound, RequestConflict } from "./Notes.js";
+import type { Note } from "./Notes.js";
 
 /**
  * Where notes live, each owned by one user. Ownership is checked here, in the data access, so no
@@ -8,26 +10,32 @@ import { type Note, NoteChanged, NoteNotFound, RequestConflict } from "./Notes.j
 export class NoteStore extends Context.Service<
   NoteStore,
   {
-    readonly list: (owner: string) => Effect.Effect<ReadonlyArray<Note>>;
-    readonly get: (owner: string, id: string) => Effect.Effect<Note, NoteNotFound>;
+    readonly list: (owner: string) => Effect.Effect<readonly Note[]>;
+    readonly get: (
+      owner: string,
+      id: string
+    ) => Effect.Effect<Note, NoteNotFound>;
     readonly create: (
       owner: string,
       title: string,
       body: string,
-      requestId?: string,
+      requestId?: string
     ) => Effect.Effect<Note, RequestConflict>;
     /** Every note or none: a database does this in one transaction. */
     readonly createAll: (
       owner: string,
-      notes: ReadonlyArray<{ readonly title: string; readonly body: string }>,
-    ) => Effect.Effect<ReadonlyArray<Note>>;
+      notes: ReadonlyArray<{ readonly title: string; readonly body: string }>
+    ) => Effect.Effect<readonly Note[]>;
     readonly update: (
       owner: string,
       id: string,
       body: string,
-      revision: number,
+      revision: number
     ) => Effect.Effect<Note, NoteNotFound | NoteChanged>;
-    readonly remove: (owner: string, id: string) => Effect.Effect<void, NoteNotFound>;
+    readonly remove: (
+      owner: string,
+      id: string
+    ) => Effect.Effect<void, NoteNotFound>;
     readonly count: Effect.Effect<number>;
   }
 >()("notes-service/NoteStore") {
@@ -43,7 +51,8 @@ export class NoteStore extends Context.Service<
     // Keep the original result even after the note is updated or deleted.
     const creations = new Map<string, Map<string, Note>>();
 
-    const ownedBy = (owner: string) => notes.get(owner) ?? new Map<string, Note>();
+    const ownedBy = (owner: string) =>
+      notes.get(owner) ?? new Map<string, Note>();
 
     const save = (owner: string, note: Note) => {
       notes.set(owner, ownedBy(owner).set(note.id, note));
@@ -51,67 +60,85 @@ export class NoteStore extends Context.Service<
       return note;
     };
 
-    const get = Effect.fn("NoteStore.get")(function* (owner: string, id: string) {
+    const get = Effect.fn("NoteStore.get")(function* (
+      owner: string,
+      id: string
+    ) {
       const note = ownedBy(owner).get(id);
 
-      if (note === undefined) return yield* new NoteNotFound({ id });
+      if (note === undefined) {
+        return yield* new NoteNotFound({ id });
+      }
 
       return note;
     });
 
     return NoteStore.of({
-      list: (owner) => Effect.sync(() => Array.from(ownedBy(owner).values())),
+      list: (owner) => Effect.sync(() => [...ownedBy(owner).values()]),
       get,
-      create: Effect.fn("NoteStore.create")(function* (owner, title, body, requestId) {
-        if (requestId !== undefined) {
-          const recorded = creations.get(owner)?.get(requestId);
+      create: Effect.fn("NoteStore.create")(
+        function* (owner, title, body, requestId) {
+          if (requestId !== undefined) {
+            const recorded = creations.get(owner)?.get(requestId);
 
-          if (recorded !== undefined) {
-            if (recorded.title !== title || recorded.body !== body) {
-              return yield* new RequestConflict({ requestId });
-            }
+            if (recorded !== undefined) {
+              if (recorded.title !== title || recorded.body !== body) {
+                return yield* new RequestConflict({ requestId });
+              }
 
-            return recorded;
+              return recorded;
+            }
           }
-        }
 
-        // No yield between lookup, mutation and recording: concurrent calls cannot interleave
-        // or interruption leave a note without its result.
-        const note = save(owner, { id: crypto.randomUUID(), title, body, revision: 1 });
+          // No yield between lookup, mutation and recording: concurrent calls cannot interleave
+          // or interruption leave a note without its result.
+          const note = save(owner, {
+            id: crypto.randomUUID(),
+            title,
+            body,
+            revision: 1,
+          });
+
+          if (requestId !== undefined) {
+            const requests = creations.get(owner) ?? new Map<string, Note>();
+            requests.set(requestId, note);
+            creations.set(owner, requests);
+          }
 
-        if (requestId !== undefined) {
-          const requests = creations.get(owner) ?? new Map<string, Note>();
-          requests.set(requestId, note);
-          creations.set(owner, requests);
+          return note;
         }
-
-        return note;
-      }),
+      ),
       createAll: (owner, all) =>
         Effect.sync(() =>
           all.map(({ title, body }) =>
-            save(owner, { id: crypto.randomUUID(), title, body, revision: 1 }),
-          ),
+            save(owner, { id: crypto.randomUUID(), title, body, revision: 1 })
+          )
         ),
       // No `yield*` between the read and the write: a fiber may be set aside at one, and two
       // updates that each read revision 1 before either wrote would both succeed. A database
       // does this with a conditional update or a transaction.
-      update: Effect.fn("NoteStore.update")(function* (owner, id, body, revision) {
-        const current = ownedBy(owner).get(id);
+      update: Effect.fn("NoteStore.update")(
+        function* (owner, id, body, revision) {
+          const current = ownedBy(owner).get(id);
 
-        if (current === undefined) return yield* new NoteNotFound({ id });
+          if (current === undefined) {
+            return yield* new NoteNotFound({ id });
+          }
 
-        if (current.revision !== revision) {
-          return yield* new NoteChanged({ id, revision: current.revision });
-        }
+          if (current.revision !== revision) {
+            return yield* new NoteChanged({ id, revision: current.revision });
+          }
 
-        return save(owner, { ...current, body, revision: revision + 1 });
-      }),
+          return save(owner, { ...current, body, revision: revision + 1 });
+        }
+      ),
       remove: Effect.fn("NoteStore.remove")(function* (owner, id) {
-        if (!ownedBy(owner).delete(id)) return yield* new NoteNotFound({ id });
+        if (!ownedBy(owner).delete(id)) {
+          return yield* new NoteNotFound({ id });
+        }
       }),
       count: Effect.sync(() =>
-        Array.from(notes.values()).reduce((total, owned) => total + owned.size, 0),
+        [...notes.values()].reduce((total, owned) => total + owned.size, 0)
       ),
     });
   });

package/examples/notes-service/src/routes.ts

@@ -1,8 +1,9 @@
+import * as ActionHttp from "@gjermundgaraba/effect-actions/ActionHttp";
+import * as ActionMcp from "@gjermundgaraba/effect-actions/ActionMcp";
 import { Layer } from "effect";
 import { HttpRouter, HttpServerResponse } from "effect/http";
 import { OpenApi } from "effect/http-api";
-import * as ActionHttp from "@gjermundgaraba/effect-actions/ActionHttp";
-import * as ActionMcp from "@gjermundgaraba/effect-actions/ActionMcp";
+
 import { Http } from "./Api.js";
 import { identity } from "./identity/handlers.js";
 import { Login } from "./identity/Identity.js";
@@ -25,7 +26,7 @@ const health = HttpRouter.add("GET", "/healthz", HttpServerResponse.text("ok"));
 const openApi = HttpRouter.add(
   "GET",
   "/api/openapi.json",
-  HttpServerResponse.jsonUnsafe(OpenApi.fromApi(Http.api)),
+  HttpServerResponse.jsonUnsafe(OpenApi.fromApi(Http.api))
 );
 
 // What the host serves: the JSON routes, the same actions as MCP tools at `/mcp`, and the host's
@@ -40,12 +41,13 @@ const serving = (requestScoped: boolean) =>
     ActionMcp.layerHttp(implementations, {
       name: "notes-service",
       version: "1.0.0",
-      instructions: "Notes belong to the signed-in user. Read a note before updating it.",
+      instructions:
+        "Notes belong to the signed-in user. Read a note before updating it.",
       authentication: Login,
       requestScoped,
     }),
     health,
-    openApi,
+    openApi
   ).pipe(Layer.provide(authenticate));
 
 export const routes = serving(false);

package/examples/notes-service/src/server.ts

@@ -1,7 +1,9 @@
 import { createServer } from "node:http";
+
 import { NodeHttpServer, NodeRuntime } from "@effect/platform-node";
 import { ByteSize, Config, Effect, Layer } from "effect";
 import { HttpRouter, HttpServerRequest } from "effect/http";
+
 import { NoteStore } from "./notes/store.js";
 import { routes } from "./routes.js";
 
@@ -10,18 +12,23 @@ import { routes } from "./routes.js";
 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 host = yield* Config.String("HOST").pipe(
+      Config.withDefault("127.0.0.1")
+    );
+
     const port = yield* Config.Port("PORT").pipe(Config.withDefault(3000));
 
     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.
-      Layer.provide(Layer.succeed(HttpServerRequest.MaxBodySize, ByteSize.mebibytes(1))),
+      Layer.provide(
+        Layer.succeed(HttpServerRequest.MaxBodySize, ByteSize.mebibytes(1))
+      ),
       // DEMO ONLY: notes live in this process's memory; a deployment provides a store that lasts.
-      Layer.provide(NoteStore.layerMemory),
+      Layer.provide(NoteStore.layerMemory)
     );
-  }),
+  })
 );
 
-Layer.launch(server).pipe(NodeRuntime.runMain);
+Layer.launch(server).pipe(NodeRuntime.runMain());

package/examples/notes-service/src/status/Status.ts

@@ -1,5 +1,5 @@
-import { Schema } from "effect";
 import * as Action from "@gjermundgaraba/effect-actions/Action";
+import { Schema } from "effect";
 
 // Public: `caller: Action.Anyone`. It answers before anyone has signed in, on every surface.
 export const GetStatus = Action.make("getStatus", {

package/examples/notes-service/src/status/handlers.ts

@@ -1,5 +1,6 @@
-import { Effect } from "effect";
 import * as Action from "@gjermundgaraba/effect-actions/Action";
+import { Effect } from "effect";
+
 import { NoteStore } from "../notes/store.js";
 import { GetStatus } from "./Status.js";
 
@@ -9,6 +10,7 @@ export const status = Action.implement(
   Effect.gen(function* () {
     const store = yield* NoteStore;
 
-    return () => Effect.map(store.count, (notes) => ({ service: "notes-service", notes }));
-  }),
+    return () =>
+      Effect.map(store.count, (notes) => ({ service: "notes-service", notes }));
+  })
 );

package/examples/notes-service/src/stdio.ts

@@ -1,7 +1,8 @@
 import { NodeRuntime, NodeStdio } from "@effect/platform-node";
-import { Effect } from "effect";
 import * as ActionCli from "@gjermundgaraba/effect-actions/ActionCli";
 import * as ActionMcp from "@gjermundgaraba/effect-actions/ActionMcp";
+import { Effect } from "effect";
+
 import { identity } from "./identity/handlers.js";
 import { CurrentUser } from "./identity/Identity.js";
 import { users } from "./identity/users.js";
@@ -17,11 +18,14 @@ import { status } from "./status/handlers.js";
 // over stdio, so this host names the caller itself. It is a process of its own with services
 // of its own. DEMO ONLY: this in-memory store holds its notes, not the running server's. To
 // share them, both provide a store they both reach, such as a database.
-ActionMcp.runStdio([status, notes, identity], { name: "notes-service", version: "1.0.0" }).pipe(
+ActionMcp.runStdio([status, notes, identity], {
+  name: "notes-service",
+  version: "1.0.0",
+}).pipe(
   // DEMO ONLY: a real host reads who started it, from its own login or configuration.
   Effect.provideService(CurrentUser, users.ada),
   Effect.provide([NodeStdio.layer, NoteStore.layerMemory]),
   // stdout carries the protocol alone, so logs and failures go to stderr.
   ActionCli.logToStderr,
-  NodeRuntime.runMain,
+  NodeRuntime.runMain()
 );

package/examples/notes-service/src/worker.ts

@@ -1,5 +1,6 @@
 import { Layer } from "effect";
 import { HttpRouter, HttpServer } from "effect/http";
+
 import { NoteStore } from "./notes/store.js";
 import { requestScopedRoutes } from "./routes.js";
 
@@ -13,8 +14,10 @@ const app = HttpRouter.toWebHandler(
     // DEMO ONLY: each instance of the worker holds notes of its own, lost when it stops. A
     // deployment provides a store every instance reaches.
     Layer.provide(NoteStore.layerMemory),
-    Layer.provide(HttpServer.layerServices),
-  ),
+    Layer.provide(HttpServer.layerServices)
+  )
 );
 
-export default { fetch: (request: Request) => app.handler(request) };
+export default {
+  fetch: async (request: Request) => await app.handler(request),
+};