@gjermundgaraba/effect-actions 0.19.0 → 0.21.0

package/examples/notes-service/README.md

@@ -1,14 +1,10 @@
 # notes-service
 
-A small service as most applications of this library are built: one set of contracts, one
-implementation, served as a JSON API and as MCP tools, with a CLI and a browser client on the
-same binding. Notes belong to the signed-in user; reading needs the `notes:read` scope and
-writing `notes:write`.
+A small service as most applications of this library are built: one set of contracts, one implementation, served as a JSON API and as MCP tools, with a CLI and a browser client on the same binding. Notes belong to the signed-in user; reading needs the `notes:read` scope and writing `notes:write`.
 
 ## 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/notes-service/src/server.ts          # 127.0.0.1:3000
@@ -34,30 +30,19 @@ claude mcp add --transport http notes http://127.0.0.1:3000/mcp --header "Author
 codex mcp add notes --url http://127.0.0.1:3000/mcp --bearer-token-env-var NOTES_TOKEN
 ```
 
-`src/stdio.ts` is another way in: a subprocess the host starts, with a store of its own.
-`src/worker.ts` serves the same routes as a `fetch` handler, for a serverless host such as
-Cloudflare Workers ([ActionMcp.md](../../docs/ActionMcp.md#serve-tools-over-http)).
+`src/stdio.ts` is another way in: a subprocess the host starts, with a store of its own. `src/worker.ts` serves the same routes as a `fetch` handler, for a serverless host such as Cloudflare Workers ([ActionMcp.md](../../docs/ActionMcp.md#serve-tools-over-http)).
 
-The server reads `HOST` (default `127.0.0.1`), `PORT` (default 3000) and `PUBLIC_URL`, the
-address it tells OAuth clients it is at; the CLI reads `NOTES_URL` and `NOTES_TOKEN`. Change the
-port and set `PORT`, `PUBLIC_URL` and `NOTES_URL` to match. Every command asks for
-`NOTES_TOKEN`, the public `get-status` included: without it a command prints one message on
-stderr saying to set it, and exits 1. `--help` needs none.
+The server reads `HOST` (default `127.0.0.1`), `PORT` (default 3000) and `PUBLIC_URL`, the address it tells OAuth clients it is at; the CLI reads `NOTES_URL` and `NOTES_TOKEN`. Change the port and set `PORT`, `PUBLIC_URL` and `NOTES_URL` to match. Every command asks for `NOTES_TOKEN`, the public `get-status` included: without it a command prints one message on stderr saying to set it, and exits 1. `--help` needs none.
 
 ## Retry a creation
 
-`createNote({ title, body })` creates a new note on every call. To retry safely, add an optional
-`requestId`. Generate it once for a new creation, for example with `crypto.randomUUID()`, and
-keep it with the pending operation outside any retry loop. After a lost response, send the
-same key and content again. For the CLI, pass `--request-id` and keep it when repeating the
-command:
+`createNote({ title, body })` creates a new note on every call. To retry safely, add an optional `requestId`. Generate it once for a new creation, for example with `crypto.randomUUID()`, and keep it with the pending operation outside any retry loop. After a lost response, send the same key and content again. For the CLI, pass `--request-id` and keep it when repeating the command:
 
 ```sh
 echo "First draft" | node --import tsx examples/notes-service/src/cli.ts create-note --request-id plan-1 --title Plan
 ```
 
-What a key promises, per caller, for changed content and after the note changes, is what
-[test/notes/idempotency.test.ts](test/notes/idempotency.test.ts) asserts.
+What a key promises, per caller, for changed content and after the note changes, is what [test/notes/idempotency.test.ts](test/notes/idempotency.test.ts) asserts.
 
 ## Layout
 
@@ -93,27 +78,27 @@ test/
 
 ## Where to look
 
-| To see                                                        | Read                             |
-| ------------------------------------------------------------- | -------------------------------- |
-| A contract with declared errors and their statuses            | `src/notes/Notes.ts`             |
-| Input fields described, for `--help` and a tool's schema      | `src/notes/Notes.ts`             |
-| Handlers getting a service once and the caller per call       | `src/notes/handlers.ts`          |
-| A write safe to retry with the same caller and request key    | `src/notes/store.ts`             |
-| A public action beside protected ones                         | `src/status/`                    |
-| Authorization from `readOnly`, refusing with a scope          | `src/identity/authorize.ts`      |
-| A token verifier and OAuth discovery read from config         | `src/identity/verifier.ts`       |
-| One implementation served over HTTP and MCP                   | `src/routes.ts`                  |
-| Config, a body limit and the host's own routes                | `src/server.ts`, `src/routes.ts` |
-| The same actions over stdio, the host naming the caller       | `src/stdio.ts`                   |
-| A serverless entrypoint, the MCP endpoint `requestScoped`     | `src/worker.ts`, `src/routes.ts` |
-| A CLI derived from the binding: an argument, a field on stdin | `src/commands.ts`                |
-| A command written by hand beside the derived ones             | `src/commands.ts`                |
-| A bulk import as one action, its command reading a file       | `src/notes/`, `src/commands.ts`  |
-| The CLI's connection, read from config when a command runs    | `src/commands.ts`                |
-| A missing token as one message, not a `ConfigError` report    | `src/commands.ts`                |
-| A promise client handling a declared error by its tag         | `src/browser.ts`                 |
-| Testing handlers and authorization with no transport          | `test/notes/in-process.test.ts`  |
-| Testing a revision race, two fibers taking turns              | `test/notes/notes.test.ts`       |
-| Testing routes, tools and refusals in memory                  | `test/routes.test.ts`            |
-| Testing commands against the routes in memory                 | `test/commands.test.ts`          |
-| Testing `--help` and the connection with config as a Layer    | `test/commands.test.ts`          |
+| To see | Read |
+| --- | --- |
+| A contract with declared errors and their statuses | `src/notes/Notes.ts` |
+| Input fields described, for `--help` and a tool's schema | `src/notes/Notes.ts` |
+| Handlers getting a service once and the caller per call | `src/notes/handlers.ts` |
+| A write safe to retry with the same caller and request key | `src/notes/store.ts` |
+| A public action beside protected ones | `src/status/` |
+| Authorization from `readOnly`, refusing with a scope | `src/identity/authorize.ts` |
+| A token verifier and OAuth discovery read from config | `src/identity/verifier.ts` |
+| One implementation served over HTTP and MCP | `src/routes.ts` |
+| Config, a body limit and the host's own routes | `src/server.ts`, `src/routes.ts` |
+| The same actions over stdio, the host naming the caller | `src/stdio.ts` |
+| A serverless entrypoint, the MCP endpoint `requestScoped` | `src/worker.ts`, `src/routes.ts` |
+| A CLI derived from the binding: an argument, a field on stdin | `src/commands.ts` |
+| A command written by hand beside the derived ones | `src/commands.ts` |
+| A bulk import as one action, its command reading a file | `src/notes/`, `src/commands.ts` |
+| The CLI's connection, read from config when a command runs | `src/commands.ts` |
+| A missing token as one message, not a `ConfigError` report | `src/commands.ts` |
+| A promise client handling a declared error by its tag | `src/browser.ts` |
+| Testing handlers and authorization with no transport | `test/notes/in-process.test.ts` |
+| Testing a revision race, two fibers taking turns | `test/notes/notes.test.ts` |
+| Testing routes, tools and refusals in memory | `test/routes.test.ts` |
+| Testing commands against the routes in memory | `test/commands.test.ts` |
+| Testing `--help` and the connection with config as a Layer | `test/commands.test.ts` |

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

@@ -1,4 +1,5 @@
 import * as ActionHttp from "@gjermundgaraba/effect-actions/ActionHttp";
+
 import { Login, WhoAmI } from "./identity/Identity.js";
 import { Notes } from "./notes/Notes.js";
 import { GetStatus } from "./status/Status.js";

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

@@ -1,6 +1,7 @@
+import * as ActionHttp from "@gjermundgaraba/effect-actions/ActionHttp";
 import { Effect } from "effect";
 import { HttpClient, HttpClientRequest } from "effect/http";
-import * as ActionHttp from "@gjermundgaraba/effect-actions/ActionHttp";
+
 import { Http } from "./Api.js";
 import type { Note } from "./notes/Notes.js";
 
@@ -12,30 +13,30 @@ import type { Note } from "./notes/Notes.js";
 export const connect = (token: string, baseUrl?: string) => {
   // Built once, outside any Effect. Every method is typed from its action.
   const api = ActionHttp.fetchClient(Http, {
-    transformClient: HttpClient.mapRequest(HttpClientRequest.bearerToken(token)),
+    transformClient: HttpClient.mapRequest(
+      HttpClientRequest.bearerToken(token)
+    ),
     ...(baseUrl === undefined ? {} : { baseUrl }),
   });
 
   // Each method returns a promise. A failure rejects it with the decoded error, so in a `catch`
   // `error instanceof Action.Unauthenticated` tells an expired sign-in from anything else.
   return {
-    notes: () => Effect.runPromise(api.listNotes()),
+    notes: async () => await Effect.runPromise(api.listNotes()),
 
     // A declared error can also be handled by its tag before the promise: a missing note is
     // `undefined` here, and every other failure still rejects.
-    note: (id: string): Promise<Note | undefined> =>
-      api.getNote({ id }).pipe(
-        Effect.catchTag("NoteNotFound", () => Effect.succeed(undefined)),
-        Effect.runPromise,
+    note: async (id: string): Promise<Note | undefined> =>
+      await api.getNote({ id }).pipe(
+        Effect.catchTag("NoteNotFound", () => Effect.undefined),
+        Effect.runPromise
       ),
 
-    // A stale revision is refused, never overwritten: the error carries the current one.
-    save: (note: Note, body: string) =>
-      api.updateNote({ id: note.id, body, revision: note.revision }).pipe(
-        Effect.catchTag("NoteChanged", ({ revision }) =>
-          Effect.fail(new Error(`Someone else saved revision ${revision}. Reload the note.`)),
-        ),
-        Effect.runPromise,
+    // A stale revision is refused, never overwritten: the error, `NoteChanged`, carries the
+    // current one.
+    save: async (note: Note, body: string) =>
+      await Effect.runPromise(
+        api.updateNote({ id: note.id, body, revision: note.revision })
       ),
   };
 };

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

@@ -1,7 +1,12 @@
-import { NodeHttpClient, NodeRuntime, NodeServices } from "@effect/platform-node";
+import {
+  NodeHttpClient,
+  NodeRuntime,
+  NodeServices,
+} from "@effect/platform-node";
+import * as ActionCli from "@gjermundgaraba/effect-actions/ActionCli";
 import { Effect } from "effect";
 import { Command } from "effect/cli";
-import * as ActionCli from "@gjermundgaraba/effect-actions/ActionCli";
+
 import { commands } from "./commands.js";
 
 // Entrypoint: `node --import tsx examples/notes-service/src/cli.ts list-notes`.
@@ -9,5 +14,5 @@ import { commands } from "./commands.js";
 Command.run(commands, { version: "1.0.0" }).pipe(
   Effect.provide([NodeHttpClient.layerUndici, NodeServices.layer]),
   ActionCli.logToStderr,
-  NodeRuntime.runMain,
+  NodeRuntime.runMain()
 );

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

@@ -1,13 +1,17 @@
+import * as ActionCli from "@gjermundgaraba/effect-actions/ActionCli";
+import * as ActionHttp from "@gjermundgaraba/effect-actions/ActionHttp";
 import { Config, Console, Effect, FileSystem, Schema } from "effect";
 import { Argument, CliError, Command } from "effect/cli";
 import { HttpClient, HttpClientRequest } from "effect/http";
-import * as ActionCli from "@gjermundgaraba/effect-actions/ActionCli";
-import * as ActionHttp from "@gjermundgaraba/effect-actions/ActionHttp";
+
 import { Http } from "./Api.js";
 
 // What a command fails with when no token is configured: a tagged error of the CLI's own, printed
 // on stderr as `MissingToken: <message>` under an `ERROR` heading, and exit 1.
-class MissingToken extends Schema.TaggedError<MissingToken>()("MissingToken", {
+class MissingToken extends Schema.TaggedError<
+  MissingToken,
+  { readonly brand: unique symbol }
+>()("MissingToken", {
   message: Schema.String,
 }) {}
 
@@ -15,7 +19,7 @@ class MissingToken extends Schema.TaggedError<MissingToken>()("MissingToken", {
 // from config. Every command here, the derived ones and your own, calls through this one.
 const api = Effect.gen(function* () {
   const baseUrl = yield* Config.String("NOTES_URL").pipe(
-    Config.withDefault("http://127.0.0.1:3000"),
+    Config.withDefault("http://127.0.0.1:3000")
   );
 
   // Required, since every command but `get-status` is refused without one, and mapped so that a
@@ -24,14 +28,17 @@ const api = Effect.gen(function* () {
     Effect.mapError(
       () =>
         new MissingToken({
-          message: "NOTES_TOKEN is not set. Set it to your token: export NOTES_TOKEN=<your token>",
-        }),
-    ),
+          message:
+            "NOTES_TOKEN is not set. Set it to your token: export NOTES_TOKEN=<your token>",
+        })
+    )
   );
 
   return yield* ActionHttp.client(Http, {
     baseUrl,
-    transformClient: HttpClient.mapRequest(HttpClientRequest.bearerToken(token)),
+    transformClient: HttpClient.mapRequest(
+      HttpClientRequest.bearerToken(token)
+    ),
   });
 });
 
@@ -49,17 +56,26 @@ const unescape = (body: string) => body.replaceAll(/^\\(?=\\*# )/gmu, "");
 // `FileSystem` every Effect CLI command has.
 const exportNotes = Command.make(
   "export",
-  { file: Argument.String("file").pipe(Argument.withDescription("The Markdown file to write.")) },
+  {
+    file: Argument.String("file").pipe(
+      Argument.withDescription("The Markdown file to write.")
+    ),
+  },
   ({ file }) =>
     Effect.gen(function* () {
       const client = yield* api;
       const files = yield* FileSystem.FileSystem;
       const { notes } = yield* client.listNotes();
-      const whole = yield* Effect.forEach(notes, ({ id }) => client.getNote({ id }));
+
+      const whole = yield* Effect.forEach(notes, ({ id }) =>
+        client.getNote({ id })
+      );
 
       yield* files.writeFileString(
         file,
-        whole.map((note) => `# ${note.title}\n\n${escape(note.body)}`).join("\n\n"),
+        whole
+          .map((note) => `# ${note.title}\n\n${escape(note.body)}`)
+          .join("\n\n")
       );
 
       yield* Console.log(`Wrote ${whole.length} notes to ${file}`);
@@ -67,10 +83,12 @@ const exportNotes = Command.make(
       // Context of your own for a failure, on stderr before it. The line prints for every
       // failure of the command, a file that cannot be written included, so it says only what is
       // true of them all.
-      Effect.tapError(() => Console.error(`The export to ${file} did not finish.`)),
+      Effect.tapError(() =>
+        Console.error(`The export to ${file} did not finish.`)
+      ),
       // So the export fails as a derived command does.
-      ActionCli.toUserError(Http),
-    ),
+      ActionCli.toUserError(Http)
+    )
 ).pipe(Command.withDescription("Write every note to a file, as Markdown."));
 
 // The other half of `export`: it reads such a file and creates its notes with one call of the
@@ -84,19 +102,22 @@ const importNotes = Command.make(
   "import",
   {
     text: Argument.FileText("file").pipe(
-      Argument.withDescription("A Markdown file as `notes export` writes it."),
+      Argument.withDescription("A Markdown file as `notes export` writes it.")
     ),
   },
   ({ text }) =>
     Effect.gen(function* () {
       const client = yield* api;
 
-      if (text === "") return yield* Console.log("Created 0 notes");
+      if (text === "") {
+        return yield* Console.log("Created 0 notes");
+      }
 
       if (!text.startsWith("# ")) {
         return yield* new CliError.UserError({
           cause: text.split("\n", 1)[0],
-          userMessage: "The file does not start with a `# ` title, as `notes export` writes one.",
+          userMessage:
+            "The file does not start with a `# ` title, as `notes export` writes one.",
         });
       }
 
@@ -109,9 +130,11 @@ const importNotes = Command.make(
       const { notes: created } = yield* client.importNotes({ notes });
 
       yield* Console.log(`Created ${created.length} notes`);
-    }).pipe(ActionCli.toUserError(Http)),
+    }).pipe(ActionCli.toUserError(Http))
 ).pipe(
-  Command.withDescription("Create the notes of a file `export` wrote, all or none, at most 100."),
+  Command.withDescription(
+    "Create the notes of a file `export` wrote, all or none, at most 100."
+  )
 );
 
 // A command per action of the binding, a flag per input field, each calling the server over
@@ -123,7 +146,10 @@ export const commands = ActionCli.remote(Http, {
   commands: {
     // `notes create-note --title Draft < draft.md`: the body is piped in, not a flag.
     createNote: { stdin: "body" },
-    getNote: { positional: ["id"], render: (note) => `# ${note.title}\n\n${note.body}` },
+    getNote: {
+      positional: ["id"],
+      render: (note) => `# ${note.title}\n\n${note.body}`,
+    },
     // `notes update-note <id> --revision 1 < draft.md`: an argument, a flag and stdin together.
     updateNote: { positional: ["id"], stdin: "body" },
   },

package/examples/notes-service/src/identity/Identity.ts

@@ -1,6 +1,6 @@
-import { Context, Schema } from "effect";
 import * as Action from "@gjermundgaraba/effect-actions/Action";
 import * as Authentication from "@gjermundgaraba/effect-actions/Authentication";
+import { Context, Schema } from "effect";
 
 export const scopes = { read: "notes:read", write: "notes:write" } as const;
 
@@ -16,7 +16,7 @@ export interface User {
  * provides it per request, and a local host, such as the stdio server, provides it itself.
  */
 export class CurrentUser extends Context.Service<CurrentUser, User>()(
-  "notes-service/CurrentUser",
+  "notes-service/CurrentUser"
 ) {}
 
 // How a remote caller proves it is CurrentUser: a bearer token, the default scheme. Clients

package/examples/notes-service/src/identity/authorize.ts

@@ -1,5 +1,6 @@
-import { Effect } from "effect";
 import * as Action from "@gjermundgaraba/effect-actions/Action";
+import { Effect } from "effect";
+
 import { CurrentUser, scopes } from "./Identity.js";
 
 // The one rule, read from each contract: a read needs the read scope, anything else the write
@@ -11,6 +12,9 @@ export const authorize = Effect.fn("authorize")(function* (action: Action.Any) {
   const user = yield* CurrentUser;
 
   if (!user.scopes.includes(scope)) {
-    return yield* new Action.Forbidden({ message: `Requires ${scope}.`, scopes: [scope] });
+    return yield* new Action.Forbidden({
+      message: `Requires ${scope}.`,
+      scopes: [scope],
+    });
   }
 });

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

@@ -1,10 +1,11 @@
-import { Effect } from "effect";
 import * as Action from "@gjermundgaraba/effect-actions/Action";
+import { Effect } from "effect";
+
 import { authorize } from "./authorize.js";
 import { CurrentUser, WhoAmI } from "./Identity.js";
 
 export const identity = Action.implement(
   WhoAmI,
   () => Effect.map(CurrentUser, ({ id, scopes }) => ({ id, scopes })),
-  { authorize },
+  { authorize }
 );

package/examples/notes-service/src/identity/users.ts

@@ -1,4 +1,5 @@
-import { scopes, type User } from "./Identity.js";
+import { scopes } from "./Identity.js";
+import type { User } from "./Identity.js";
 
 // DEMO ONLY: the people who may sign in, each under a token that is their name. A real service
 // has no such table: its verifier reads the user from a signed token.

package/examples/notes-service/src/identity/verifier.ts

@@ -1,20 +1,24 @@
-import { Config, Effect, Redacted } from "effect";
 import * as Action from "@gjermundgaraba/effect-actions/Action";
 import * as Authentication from "@gjermundgaraba/effect-actions/Authentication";
+import { Config, Effect, Redacted } from "effect";
+
 import { Login, scopes } from "./Identity.js";
 import { users } from "./users.js";
 
-const isToken = (token: string): token is keyof typeof users => Object.hasOwn(users, token);
+const isToken = (token: string): token is keyof typeof users =>
+  Object.hasOwn(users, token);
 
 // DEMO ONLY: a token is a user's name. A real verifier checks a signed token with your
 // authorization server's library, its audience included. An unknown token is the built-in
 // `Unauthenticated`: a 401 every client decodes.
-const verify = (token: Redacted.Redacted<string>) => {
+const verify = (token: Redacted.Redacted) => {
   const name = Redacted.value(token);
 
   return isToken(name)
     ? Effect.succeed(users[name])
-    : Effect.fail(new Action.Unauthenticated({ message: "Unknown demo token." }));
+    : Effect.fail(
+        new Action.Unauthenticated({ message: "Unknown demo token." })
+      );
 };
 
 // Server only: `Login`'s provider. As an OAuth protected resource it also publishes discovery,
@@ -22,7 +26,9 @@ const verify = (token: Redacted.Redacted<string>) => {
 // is the server's public URL, known only at startup, so it is read from config.
 export const authenticate = Authentication.layer(Login, verify, {
   protectedResource: Effect.map(
-    Config.String("PUBLIC_URL").pipe(Config.withDefault("http://localhost:3000")),
+    Config.String("PUBLIC_URL").pipe(
+      Config.withDefault("http://localhost:3000")
+    ),
     (url) =>
       ({
         resource: `${url}/mcp`,
@@ -30,6 +36,6 @@ export const authenticate = Authentication.layer(Login, verify, {
         authorizationServers: ["https://auth.example.com"],
         scopesSupported: [scopes.read, scopes.write],
         scopesRequired: [scopes.read],
-      }) satisfies Authentication.ProtectedResource,
+      }) satisfies Authentication.ProtectedResource
   ),
 });

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

@@ -1,5 +1,6 @@
-import { Schema } from "effect";
 import * as Action from "@gjermundgaraba/effect-actions/Action";
+import { Schema } from "effect";
+
 import { CurrentUser } from "../identity/Identity.js";
 
 export const Note = Schema.Struct({
@@ -13,23 +14,24 @@ export type Note = typeof Note.Type;
 
 // A declared error is part of the contract: every client decodes it as this class, and its
 // status is what HTTP answers with.
-export class NoteNotFound extends Schema.TaggedError<NoteNotFound>()(
-  "NoteNotFound",
-  { id: Schema.String },
-  { httpApiStatus: 404 },
-) {}
-
-export class NoteChanged extends Schema.TaggedError<NoteChanged>()(
+export class NoteNotFound extends Schema.TaggedError<
+  NoteNotFound,
+  { readonly brand: unique symbol }
+>()("NoteNotFound", { id: Schema.String }, { httpApiStatus: 404 }) {}
+
+export class NoteChanged extends Schema.TaggedError<
+  NoteChanged,
+  { readonly brand: unique symbol }
+>()(
   "NoteChanged",
   { id: Schema.String, revision: Schema.Finite },
-  { httpApiStatus: 409 },
+  { httpApiStatus: 409 }
 ) {}
 
-export class RequestConflict extends Schema.TaggedError<RequestConflict>()(
-  "RequestConflict",
-  { requestId: Schema.String },
-  { httpApiStatus: 409 },
-) {}
+export class RequestConflict extends Schema.TaggedError<
+  RequestConflict,
+  { readonly brand: unique symbol }
+>()("RequestConflict", { requestId: Schema.String }, { httpApiStatus: 409 }) {}
 
 // A description on an input field is that field's help on every surface: beside its flag or
 // argument in a command's `--help`, and in the input schema a model reads from the MCP tool
@@ -42,7 +44,9 @@ const Id = Schema.String.annotate({
 // generic "Expected a value with a length of at least 1". A model and a CLI user read it too.
 const Title = Schema.String.check(
   Schema.isMinLength(1, { message: "A note needs a title." }),
-  Schema.isPattern(/^[^\r\n\u2028\u2029]*$/u, { message: "A title is one line." }),
+  Schema.isPattern(/^[^\r\n\u2028\u2029]*$/u, {
+    message: "A title is one line.",
+  })
 ).annotate({
   description: "A short name for the note: one line, at least one character.",
 });
@@ -53,7 +57,11 @@ const Content = Schema.Struct({ title: Title, body: Body });
 
 export const ListNotes = Action.make("listNotes", {
   description: "List your notes, without their bodies.",
-  success: { notes: Schema.Array(Schema.Struct({ id: Schema.String, title: Schema.String })) },
+  success: {
+    notes: Schema.Array(
+      Schema.Struct({ id: Schema.String, title: Schema.String })
+    ),
+  },
   readOnly: true,
   caller: CurrentUser,
 });
@@ -90,9 +98,12 @@ export const UpdateNote = Action.make("updateNote", {
     "Replace a note's body. Pass the revision you read: the update is refused if the note changed since.",
   input: {
     id: Id,
-    body: Body.annotate({ description: "The text that replaces the note's body." }),
+    body: Body.annotate({
+      description: "The text that replaces the note's body.",
+    }),
     revision: Schema.Finite.annotate({
-      description: "The revision you read: 1 for a new note, one more after each update.",
+      description:
+        "The revision you read: 1 for a new note, one more after each update.",
     }),
   },
   success: Note,
@@ -120,10 +131,16 @@ export const ImportNotes = Action.make("importNotes", {
   input: {
     notes: Schema.Array(Content)
       .check(
-        Schema.isMinLength(1, { message: "An import holds at least one note." }),
-        Schema.isMaxLength(100, { message: "An import holds at most 100 notes." }),
+        Schema.isMinLength(1, {
+          message: "An import holds at least one note.",
+        }),
+        Schema.isMaxLength(100, {
+          message: "An import holds at most 100 notes.",
+        })
       )
-      .annotate({ description: "The notes to create, in order: from 1 to 100." }),
+      .annotate({
+        description: "The notes to create, in order: from 1 to 100.",
+      }),
   },
   success: { notes: Schema.Array(Note) },
   readOnly: false,
@@ -131,4 +148,11 @@ export const ImportNotes = Action.make("importNotes", {
   mcp: { destructiveHint: false },
 });
 
-export const Notes = [ListNotes, GetNote, CreateNote, UpdateNote, DeleteNote, ImportNotes] as const;
+export const Notes = [
+  ListNotes,
+  GetNote,
+  CreateNote,
+  UpdateNote,
+  DeleteNote,
+  ImportNotes,
+] as const;

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

@@ -1,5 +1,6 @@
-import { Effect } from "effect";
 import * as Action from "@gjermundgaraba/effect-actions/Action";
+import { Effect } from "effect";
+
 import { authorize } from "../identity/authorize.js";
 import { CurrentUser } from "../identity/Identity.js";
 import { Notes } from "./Notes.js";
@@ -22,18 +23,26 @@ export const notes = Action.implement(
 
           return { notes: owned.map(({ id, title }) => ({ id, title })) };
         }),
-      getNote: ({ id }) => Effect.flatMap(CurrentUser, (user) => store.get(user.id, id)),
+      getNote: ({ id }) =>
+        Effect.flatMap(CurrentUser, (user) => store.get(user.id, id)),
       createNote: ({ requestId, title, body }) =>
-        Effect.flatMap(CurrentUser, (user) => store.create(user.id, title, body, requestId)),
+        Effect.flatMap(CurrentUser, (user) =>
+          store.create(user.id, title, body, requestId)
+        ),
       updateNote: ({ id, body, revision }) =>
-        Effect.flatMap(CurrentUser, (user) => store.update(user.id, id, body, revision)),
-      deleteNote: ({ id }) => Effect.flatMap(CurrentUser, (user) => store.remove(user.id, id)),
-      importNotes: ({ notes }) =>
+        Effect.flatMap(CurrentUser, (user) =>
+          store.update(user.id, id, body, revision)
+        ),
+      deleteNote: ({ id }) =>
+        Effect.flatMap(CurrentUser, (user) => store.remove(user.id, id)),
+      importNotes: ({ notes: imported }) =>
         Effect.map(
-          Effect.flatMap(CurrentUser, (user) => store.createAll(user.id, notes)),
-          (created) => ({ notes: created }),
+          Effect.flatMap(CurrentUser, (user) =>
+            store.createAll(user.id, imported)
+          ),
+          (created) => ({ notes: created })
         ),
     };
   }),
-  { authorize },
+  { authorize }
 );