@gjermundgaraba/effect-actions 0.20.0 → 0.21.0

package/examples/assistant/src/platform/tasks-file.ts

@@ -1,6 +1,8 @@
 import { tmpdir } from "node:os";
-import { join } from "node:path";
+import path from "node:path";
+
 import { Config, Effect, FileSystem, Layer, Schema } from "effect";
+
 import { TaskStore } from "../tasks/store.js";
 import { Task } from "../tasks/Tasks.js";
 
@@ -15,24 +17,26 @@ export const tasksFile = Layer.effect(
   Effect.gen(function* () {
     const files = yield* FileSystem.FileSystem;
 
-    const path = yield* Config.String("ASSISTANT_TASKS").pipe(
-      Config.withDefault(join(tmpdir(), "assistant-tasks.json")),
+    const file = yield* Config.String("ASSISTANT_TASKS").pipe(
+      Config.withDefault(path.join(tmpdir(), "assistant-tasks.json"))
     );
 
-    const load = files.readFileString(path).pipe(
-      Effect.catchReason("PlatformError", "NotFound", () => Effect.succeed("[]")),
+    const load = files.readFileString(file).pipe(
+      Effect.catchReason("PlatformError", "NotFound", () =>
+        Effect.succeed("[]")
+      ),
       Effect.flatMap(Schema.decodeEffect(TasksFile)),
-      Effect.orDie,
+      Effect.orDie
     );
 
-    const save = (tasks: ReadonlyArray<Task>) =>
+    const save = (tasks: readonly Task[]) =>
       Schema.encodeEffect(TasksFile)(tasks).pipe(
-        Effect.flatMap((json) => files.writeFileString(path, json)),
+        Effect.flatMap((json) => files.writeFileString(file, json)),
         // A log, not a result: a command sends its handler's logs to stderr.
-        Effect.tap(() => Effect.log(`Saved ${tasks.length} tasks to ${path}.`)),
-        Effect.orDie,
+        Effect.tap(() => Effect.log(`Saved ${tasks.length} tasks to ${file}.`)),
+        Effect.orDie
       );
 
     return TaskStore.make(load, save);
-  }),
+  })
 );

package/examples/assistant/src/scripted.ts

@@ -1,11 +1,14 @@
 import { Effect, Layer, Ref, Stream } from "effect";
-import { LanguageModel, type Response } from "effect/ai";
+import { LanguageModel } from "effect/ai";
+import type { Response } from "effect/ai";
 
 // DEMO ONLY: a model that needs no API key. It answers its first request with the first reply
 // it was given, its second with the second, whatever the prompt says, and with nothing once
 // they run out. It stands exactly where a provider's model layer goes, such as
 // `OpenAiLanguageModel.model(...)` of `@effect/ai-openai`.
-export const scripted = (...replies: ReadonlyArray<ReadonlyArray<Response.PartEncoded>>) =>
+export const scripted = (
+  ...replies: ReadonlyArray<readonly Response.PartEncoded[]>
+) =>
   Layer.effect(
     LanguageModel.LanguageModel,
     Effect.gen(function* () {
@@ -15,9 +18,9 @@ export const scripted = (...replies: ReadonlyArray<ReadonlyArray<Response.PartEn
         generateText: () =>
           Effect.map(
             Ref.getAndUpdate(answered, (count) => count + 1),
-            (count) => [...(replies[count] ?? [])],
+            (count) => [...(replies[count] ?? [])]
           ),
         streamText: () => Stream.empty,
       });
-    }),
+    })
   );

package/examples/assistant/src/tasks/Tasks.ts

@@ -1,5 +1,6 @@
-import { Schema } from "effect";
 import * as Action from "@gjermundgaraba/effect-actions/Action";
+import { Schema } from "effect";
+
 import { CurrentCaller } from "../identity/Identity.js";
 
 export const Task = Schema.Struct({
@@ -14,14 +15,21 @@ export const Task = Schema.Struct({
 export type Task = typeof Task.Type;
 
 // A declared error is part of the contract.
-export class TaskNotFound extends Schema.TaggedError<TaskNotFound>()("TaskNotFound", {
+export class TaskNotFound extends Schema.TaggedError<
+  TaskNotFound,
+  { readonly brand: unique symbol }
+>()("TaskNotFound", {
   id: Schema.String,
 }) {}
 
 // A field's description is what a model reads beside the tool, and the flag's help text.
-const Id = Schema.String.annotate({ description: "The id listed beside the task." });
+const Id = Schema.String.annotate({
+  description: "The id listed beside the task.",
+});
 
-const Assignee = Schema.String.annotate({ description: "A teammate's name, such as ada." });
+const Assignee = Schema.String.annotate({
+  description: "A teammate's name, such as ada.",
+});
 
 const team = { caller: CurrentCaller } as const;
 
@@ -36,7 +44,10 @@ export const ListTasks = Action.make("listTasks", {
 export const AddTask = Action.make("addTask", {
   ...team,
   description: "Add a task and assign it to a teammate.",
-  input: { title: Schema.String.check(Schema.isMinLength(1)), assignee: Assignee },
+  input: {
+    title: Schema.String.check(Schema.isMinLength(1)),
+    assignee: Assignee,
+  },
   success: Task,
   readOnly: false,
 });
@@ -53,7 +64,10 @@ export const CompleteTask = Action.make("completeTask", {
 export const AnnotateTask = Action.make("annotateTask", {
   ...team,
   description: "Replace a task's notes.",
-  input: { id: Id, notes: Schema.String.annotate({ description: "The notes, as plain text." }) },
+  input: {
+    id: Id,
+    notes: Schema.String.annotate({ description: "The notes, as plain text." }),
+  },
   success: Task,
   error: TaskNotFound,
   readOnly: false,

package/examples/assistant/src/tasks/handlers.ts

@@ -1,9 +1,10 @@
-import { Effect } from "effect";
 import * as Action from "@gjermundgaraba/effect-actions/Action";
+import { Effect } from "effect";
+
 import { authorize } from "../identity/authorize.js";
 import { CurrentCaller } from "../identity/Identity.js";
-import { Tasks } from "./Tasks.js";
 import { TaskStore } from "./store.js";
+import { Tasks } from "./Tasks.js";
 
 // The builder gets the store. `CurrentCaller` is read per call. No handler knows whether a model
 // or a person at a terminal called it, and none checks a permission: `authorize` has run before
@@ -14,12 +15,15 @@ export const tasks = Action.implement(
     const store = yield* TaskStore;
 
     return {
-      listTasks: ({ assignee }) => Effect.map(store.list(assignee), (tasks) => ({ tasks })),
+      listTasks: ({ assignee }) =>
+        Effect.map(store.list(assignee), (listed) => ({ tasks: listed })),
       addTask: ({ title, assignee }) =>
-        Effect.flatMap(CurrentCaller, (caller) => store.add(caller.id, title, assignee)),
+        Effect.flatMap(CurrentCaller, (caller) =>
+          store.add(caller.id, title, assignee)
+        ),
       completeTask: ({ id }) => store.complete(id),
       annotateTask: ({ id, notes }) => store.annotate(id, notes),
     };
   }),
-  { authorize },
+  { authorize }
 );

package/examples/assistant/src/tasks/store.ts

@@ -1,20 +1,30 @@
 import { Context, Effect, Layer, Ref, Semaphore } from "effect";
-import { Task, TaskNotFound } from "./Tasks.js";
 
-type TaskList = ReadonlyArray<Task>;
+import type { Task } from "./Tasks.js";
+import { TaskNotFound } from "./Tasks.js";
+
+type TaskList = readonly Task[];
 
 // Every method reads the whole list, and a change writes it back: a layer says only where the
 // list is kept, in memory below or in a file (src/platform/tasks-file.ts).
-const make = (load: Effect.Effect<TaskList>, save: (tasks: TaskList) => Effect.Effect<void>) => {
+const make = (
+  load: Effect.Effect<TaskList>,
+  save: (tasks: TaskList) => Effect.Effect<void>
+) => {
   // A model's tool calls in one turn run concurrently. Two changes reading the list before
   // either writes it would lose one, so a change holds this lock from its read to its write.
   const lock = Semaphore.makeUnsafe(1);
 
-  const change = Effect.fn("TaskStore.change")(function* (id: string, to: (task: Task) => Task) {
+  const change = Effect.fn("TaskStore.change")(function* (
+    id: string,
+    to: (task: Task) => Task
+  ) {
     const tasks = yield* load;
     const task = tasks.find((each) => each.id === id);
 
-    if (task === undefined) return yield* new TaskNotFound({ id });
+    if (task === undefined) {
+      return yield* new TaskNotFound({ id });
+    }
 
     const changed = to(task);
 
@@ -26,11 +36,21 @@ const make = (load: Effect.Effect<TaskList>, save: (tasks: TaskList) => Effect.E
   return TaskStore.of({
     list: (assignee) =>
       Effect.map(load, (tasks) =>
-        assignee === undefined ? tasks : tasks.filter((task) => task.assignee === assignee),
+        assignee === undefined
+          ? tasks
+          : tasks.filter((task) => task.assignee === assignee)
       ),
     add: Effect.fn("TaskStore.add")(function* (addedBy, title, assignee) {
       const tasks = yield* load;
-      const task = { id: `${tasks.length + 1}`, title, assignee, addedBy, notes: "", done: false };
+
+      const task = {
+        id: `${tasks.length + 1}`,
+        title,
+        assignee,
+        addedBy,
+        notes: "",
+        done: false,
+      };
 
       yield* save([...tasks, task]);
 
@@ -46,9 +66,16 @@ export class TaskStore extends Context.Service<
   TaskStore,
   {
     readonly list: (assignee: string | undefined) => Effect.Effect<TaskList>;
-    readonly add: (addedBy: string, title: string, assignee: string) => Effect.Effect<Task>;
+    readonly add: (
+      addedBy: string,
+      title: string,
+      assignee: string
+    ) => Effect.Effect<Task>;
     readonly complete: (id: string) => Effect.Effect<Task, TaskNotFound>;
-    readonly annotate: (id: string, notes: string) => Effect.Effect<Task, TaskNotFound>;
+    readonly annotate: (
+      id: string,
+      notes: string
+    ) => Effect.Effect<Task, TaskNotFound>;
   }
 >()("assistant/TaskStore") {
   /** The store over a list kept by `load` and `save`, each change serialized. */
@@ -58,7 +85,7 @@ export class TaskStore extends Context.Service<
   static readonly layerMemory = Layer.effect(
     TaskStore,
     Effect.map(Ref.make<TaskList>([]), (tasks) =>
-      make(Ref.get(tasks), (next) => Ref.set(tasks, next)),
-    ),
+      make(Ref.get(tasks), (next) => Ref.set(tasks, next))
+    )
   );
 }

package/examples/assistant/src/toolkit.ts

@@ -1,8 +1,10 @@
+import * as ActionToolkit from "@gjermundgaraba/effect-actions/ActionToolkit";
 import { Effect, Option } from "effect";
 import { Tool, Toolkit } from "effect/ai";
-import * as ActionToolkit from "@gjermundgaraba/effect-actions/ActionToolkit";
+
 import { identity } from "./identity/handlers.js";
-import { CurrentCaller, type Member } from "./identity/Identity.js";
+import { CurrentCaller } from "./identity/Identity.js";
+import type { Member } from "./identity/Identity.js";
 import { tasks } from "./tasks/handlers.js";
 
 // `actions.layer` holds the handlers, and requires the startup services their builders read;
@@ -17,8 +19,9 @@ const actions = ActionToolkit.make([tasks, identity], {
       Effect.serviceOption(CurrentCaller),
       Option.match({
         onNone: () => true,
-        onSome: (caller) => call.name !== "addTask" || call.input.assignee !== caller.id,
-      }),
+        onSome: (caller) =>
+          call.name !== "addTask" || call.input.assignee !== caller.id,
+      })
     ),
 });
 
@@ -26,13 +29,14 @@ const actions = ActionToolkit.make([tasks, identity], {
 // The later definition wins; annotating the generated tool keeps its handler and approval rule.
 export const toolkit = Toolkit.merge(
   actions.toolkit,
-  Toolkit.make(actions.toolkit.tools.addTask.annotate(Tool.Title, "Add a task")),
+  Toolkit.make(actions.toolkit.tools.addTask.annotate(Tool.Title, "Add a task"))
 );
 
-export const layer = actions.layer;
+export const { layer } = actions;
 
 // One toolkit serves every member, so who a turn runs as is provided around that turn. This is
 // how this example names a model's caller, and it takes a `Member`. The tools themselves accept
 // any `CurrentCaller`, so keeping the operator away from a model is this function's doing, and
 // that of every host using it.
-export const actingFor = (member: Member) => Effect.provideService(CurrentCaller, member);
+export const actingFor = (member: Member) =>
+  Effect.provideService(CurrentCaller, member);

package/examples/assistant/test/commands.test.ts

@@ -3,8 +3,10 @@ import { describe, expect, it } from "@effect/vitest";
 import { Effect, Layer, Stdio, Stream } from "effect";
 import { Command } from "effect/cli";
 import { TestConsole } from "effect/testing";
+
 import { commands } from "../src/commands.js";
-import { CurrentCaller, type Operator } from "../src/identity/Identity.js";
+import { CurrentCaller } from "../src/identity/Identity.js";
+import type { Operator } from "../src/identity/Identity.js";
 import { Permissions } from "../src/identity/permissions.js";
 import { TaskStore } from "../src/tasks/store.js";
 
@@ -17,46 +19,70 @@ const operator: Operator = { kind: "operator", id: "root" };
 
 // Effect's own runner, given arguments instead of the process's, and stdin the text given here.
 // The console of `it.effect` keeps every line printed, so a run returns the lines it added.
-const run = (args: ReadonlyArray<string>, stdin = "") =>
+const run = (args: readonly string[], stdin = "") =>
   Effect.gen(function* () {
     const before = (yield* TestConsole.logLines).length;
 
-    yield* Command.runWith(commands.pipe(Command.provideSync(CurrentCaller, operator)), {
-      version: "0",
-    })(args).pipe(
-      Effect.provide(Stdio.layerTest({ stdin: Stream.make(new TextEncoder().encode(stdin)) })),
-      Effect.provide(NodeServices.layer),
+    yield* Command.runWith(
+      commands.pipe(Command.provideSync(CurrentCaller, operator)),
+      {
+        version: "0",
+      }
+    )(args).pipe(
+      Effect.provide(
+        Stdio.layerTest({
+          stdin: Stream.make(new TextEncoder().encode(stdin)),
+        }).pipe(Layer.provideMerge(NodeServices.layer))
+      )
     );
 
     return (yield* TestConsole.logLines).slice(before);
   });
 
 describe("the commands", () => {
-  it.effect("run as the operator the host names, taking an argument and stdin", () =>
-    Effect.gen(function* () {
-      yield* run(["add-task", "--title", "Rotate the keys", "--assignee", "ada"]);
-      yield* run(["annotate-task", "--id", "1"], "Before Friday.\n");
-      yield* run(["complete-task", "1"]);
-
-      const store = yield* TaskStore;
-
-      expect(yield* store.list("ada")).toMatchObject([
-        { addedBy: "root", notes: "Before Friday.", done: true },
-      ]);
-    }).pipe(Effect.provide(services)),
+  it.effect(
+    "run as the operator the host names, taking an argument and stdin",
+    () =>
+      Effect.gen(function* () {
+        yield* run([
+          "add-task",
+          "--title",
+          "Rotate the keys",
+          "--assignee",
+          "ada",
+        ]);
+        yield* run(["annotate-task", "--id", "1"], "Before Friday.\n");
+        yield* run(["complete-task", "1"]);
+
+        const store = yield* TaskStore;
+
+        expect(yield* store.list("ada")).toMatchObject([
+          { addedBy: "root", notes: "Before Friday.", done: true },
+        ]);
+      }).pipe(Effect.provide(services))
   );
 
-  it.effect("print what `render` returns, and JSON where a command states none", () =>
-    Effect.gen(function* () {
-      yield* run(["add-task", "--title", "Rotate the keys", "--assignee", "ada"]);
+  it.effect(
+    "print what `render` returns, and JSON where a command states none",
+    () =>
+      Effect.gen(function* () {
+        yield* run([
+          "add-task",
+          "--title",
+          "Rotate the keys",
+          "--assignee",
+          "ada",
+        ]);
 
-      const printed = yield* run(["list-tasks", "-a", "ada"]);
+        const printed = yield* run(["list-tasks", "-a", "ada"]);
 
-      expect(printed).toEqual(["[ ] 1 Rotate the keys (ada)"]);
+        expect(printed).toStrictEqual(["[ ] 1 Rotate the keys (ada)"]);
 
-      const json = yield* run(["who-am-i"]);
+        const json = yield* run(["who-am-i"]);
 
-      expect(json).toEqual([JSON.stringify({ id: "root", kind: "operator" }, undefined, 2)]);
-    }).pipe(Effect.provide(services)),
+        expect(json).toStrictEqual([
+          JSON.stringify({ id: "root", kind: "operator" }, undefined, 2),
+        ]);
+      }).pipe(Effect.provide(services))
   );
 });

package/examples/assistant/test/identity/identity.test.ts

@@ -1,12 +1,16 @@
 import { describe, expect, it } from "@effect/vitest";
-import { Effect, Ref } from "effect";
 import * as Action from "@gjermundgaraba/effect-actions/Action";
+import { Effect, Ref } from "effect";
+
 import { identity } from "../../src/identity/handlers.js";
-import { CurrentCaller, type Member, type Operator } from "../../src/identity/Identity.js";
+import { CurrentCaller } from "../../src/identity/Identity.js";
+import type { Member, Operator } from "../../src/identity/Identity.js";
 import { members } from "../../src/identity/members.js";
-import { type Permission, Permissions } from "../../src/identity/permissions.js";
+import { Permissions } from "../../src/identity/permissions.js";
+import type { Permission } from "../../src/identity/permissions.js";
 
-const as = (caller: Member | Operator) => Effect.provideService(CurrentCaller, caller);
+const as = (caller: Member | Operator) =>
+  Effect.provideService(CurrentCaller, caller);
 
 const operator: Operator = { kind: "operator", id: "root" };
 
@@ -15,19 +19,28 @@ describe("identity, in process", () => {
     Effect.gen(function* () {
       const client = yield* Action.client(identity);
 
-      expect(yield* client.whoAmI().pipe(as(members.ada))).toEqual({ id: "ada", kind: "member" });
-      expect(yield* client.whoAmI().pipe(as(operator))).toEqual({ id: "root", kind: "operator" });
-    }).pipe(Effect.provide(Permissions.layerMemory)),
+      expect(yield* client.whoAmI().pipe(as(members.ada))).toStrictEqual({
+        id: "ada",
+        kind: "member",
+      });
+      expect(yield* client.whoAmI().pipe(as(operator))).toStrictEqual({
+        id: "root",
+        kind: "operator",
+      });
+    }).pipe(Effect.provide(Permissions.layerMemory))
   );
 
   it.effect("gets the permission store once and asks it on every call", () =>
     Effect.gen(function* () {
-      const granted = yield* Ref.make<ReadonlyArray<Permission>>([]);
+      const granted = yield* Ref.make<readonly Permission[]>([]);
 
       // The store is a startup service, so it is provided where the client is acquired: the
       // authorizer is built there. No call is given it again.
       const client = yield* Action.client(identity).pipe(
-        Effect.provideService(Permissions, Permissions.of({ granted: () => Ref.get(granted) })),
+        Effect.provideService(
+          Permissions,
+          Permissions.of({ granted: () => Ref.get(granted) })
+        )
       );
 
       const refusal = yield* Effect.flip(client.whoAmI().pipe(as(members.ada)));
@@ -37,7 +50,10 @@ describe("identity, in process", () => {
 
       yield* Ref.set(granted, ["tasks:read"]);
 
-      expect(yield* client.whoAmI().pipe(as(members.ada))).toEqual({ id: "ada", kind: "member" });
-    }),
+      expect(yield* client.whoAmI().pipe(as(members.ada))).toStrictEqual({
+        id: "ada",
+        kind: "member",
+      });
+    })
   );
 });

package/examples/assistant/test/platform/tasks-file.test.ts

@@ -1,6 +1,7 @@
 import { NodeServices } from "@effect/platform-node";
 import { describe, expect, it } from "@effect/vitest";
 import { ConfigProvider, Effect, FileSystem, Layer, Path } from "effect";
+
 import { tasksFile } from "../../src/platform/tasks-file.js";
 import { TaskStore } from "../../src/tasks/store.js";
 
@@ -18,32 +19,47 @@ const fileStore = Effect.gen(function* () {
 });
 
 describe("the file store", () => {
-  it.effect("gives each of several concurrent adds, as one model turn makes them, its own id", () =>
-    Effect.gen(function* () {
-      const store = yield* TaskStore;
-
-      const added = yield* Effect.all(
-        ["Book the venue", "Send invitations", "Order lunch"].map((title) =>
-          store.add("ada", title, "ada"),
-        ),
-        { concurrency: "unbounded" },
-      );
-
-      expect(added.map(({ id }) => id)).toEqual(["1", "2", "3"]);
-      expect(yield* store.list("ada")).toEqual(added);
-    }).pipe(Effect.provide(Layer.unwrap(fileStore)), Effect.provide(NodeServices.layer)),
+  it.effect(
+    "gives each of several concurrent adds, as one model turn makes them, its own id",
+    () =>
+      Effect.gen(function* () {
+        const store = yield* TaskStore;
+
+        const added = yield* Effect.forEach(
+          ["Book the venue", "Send invitations", "Order lunch"],
+          (title) => store.add("ada", title, "ada"),
+          { concurrency: "unbounded" }
+        );
+
+        expect(added.map(({ id }) => id)).toStrictEqual(["1", "2", "3"]);
+        expect(yield* store.list("ada")).toStrictEqual(added);
+      }).pipe(
+        Effect.provide(
+          Layer.unwrap(fileStore).pipe(Layer.provideMerge(NodeServices.layer))
+        )
+      )
   );
 
-  it.effect("keeps tasks for the next process: a layer built again reads them", () =>
-    Effect.gen(function* () {
-      const store = yield* fileStore;
-      const add = Effect.flatMap(TaskStore, (tasks) => tasks.add("root", "Rotate keys", "ada"));
-      const list = Effect.flatMap(TaskStore, (tasks) => tasks.list(undefined));
+  it.effect(
+    "keeps tasks for the next process: a layer built again reads them",
+    () =>
+      Effect.gen(function* () {
+        const store = yield* fileStore;
+
+        const add = Effect.flatMap(TaskStore, (tasks) =>
+          tasks.add("root", "Rotate keys", "ada")
+        );
+
+        const list = Effect.flatMap(TaskStore, (tasks) =>
+          tasks.list(undefined)
+        );
 
-      // `local` builds the layer anew for each, as each run of the agent or of a command does.
-      const task = yield* add.pipe(Effect.provide(store, { local: true }));
+        // `local` builds the layer anew for each, as each run of the agent or of a command does.
+        const task = yield* add.pipe(Effect.provide(store, { local: true }));
 
-      expect(yield* list.pipe(Effect.provide(store, { local: true }))).toEqual([task]);
-    }).pipe(Effect.provide(NodeServices.layer)),
+        expect(
+          yield* list.pipe(Effect.provide(store, { local: true }))
+        ).toStrictEqual([task]);
+      }).pipe(Effect.provide(NodeServices.layer))
   );
 });