@effect-app/vue 2.65.0 → 2.67.0

package/src/experimental/commander.ts

@@ -5,6 +5,7 @@ import { type Result } from "@effect-atom/atom/Result"
 import { Cause, Effect, type Exit, flow, Match, Option, Runtime, S } from "effect-app"
 import { SupportedErrors } from "effect-app/client"
 import { OperationFailure, OperationSuccess } from "effect-app/Operations"
+import { wrapEffect } from "effect-app/utils"
 import { type RuntimeFiber } from "effect/Fiber"
 import { type NoInfer } from "effect/Types"
 import { isGeneratorFunction, type YieldWrap } from "effect/Utils"
@@ -69,7 +70,7 @@ export declare namespace Commander {
     waiting: boolean
   }
 
-  export interface CommandOut<Args extends Array<any>, A, E, R, Id extends string> extends CommandProps<A, E, Id> {
+  export interface CommandOut<Args extends Array<unknown>, A, E, R, Id extends string> extends CommandProps<A, E, Id> {
     new(): {}
 
     /** click handlers */
@@ -91,7 +92,7 @@ export declare namespace Commander {
     exec: (...args: Args) => Effect.Effect<Exit.Exit<A, E>, never, Exclude<R, CommandContext>>
   }
 
-  type CommandOutHelper<Args extends Array<any>, Eff extends Effect.Effect<any, any, any>, Id extends string> =
+  type CommandOutHelper<Args extends Array<unknown>, Eff extends Effect.Effect<any, any, any>, Id extends string> =
     CommandOut<
       Args,
       Effect.Effect.Success<Eff>,
@@ -101,7 +102,7 @@ export declare namespace Commander {
     >
 
   export type Gen<RT, Id extends string> = {
-    <Eff extends YieldWrap<Effect.Effect<any, any, RT | CommandContext>>, AEff, Args extends Array<any>>(
+    <Eff extends YieldWrap<Effect.Effect<any, any, RT | CommandContext>>, AEff, Args extends Array<unknown>>(
       body: (...args: Args) => Generator<Eff, AEff, never>
     ): CommandOut<
       Args,
@@ -117,7 +118,7 @@ export declare namespace Commander {
     <
       Eff extends YieldWrap<Effect.Effect<any, any, any>>,
       AEff,
-      Args extends Array<any>,
+      Args extends Array<unknown>,
       A extends Effect.Effect<any, any, RT | CommandContext>
     >(
       body: (...args: Args) => Generator<Eff, AEff, never>,
@@ -137,7 +138,7 @@ export declare namespace Commander {
     <
       Eff extends YieldWrap<Effect.Effect<any, any, any>>,
       AEff,
-      Args extends Array<any>,
+      Args extends Array<unknown>,
       A,
       B extends Effect.Effect<any, any, RT | CommandContext>
     >(
@@ -159,7 +160,7 @@ export declare namespace Commander {
     <
       Eff extends YieldWrap<Effect.Effect<any, any, any>>,
       AEff,
-      Args extends Array<any>,
+      Args extends Array<unknown>,
       A,
       B,
       C extends Effect.Effect<any, any, RT | CommandContext>
@@ -183,7 +184,7 @@ export declare namespace Commander {
     <
       Eff extends YieldWrap<Effect.Effect<any, any, any>>,
       AEff,
-      Args extends Array<any>,
+      Args extends Array<unknown>,
       A,
       B,
       C,
@@ -209,7 +210,7 @@ export declare namespace Commander {
     <
       Eff extends YieldWrap<Effect.Effect<any, any, any>>,
       AEff,
-      Args extends Array<any>,
+      Args extends Array<unknown>,
       A,
       B,
       C,
@@ -237,7 +238,7 @@ export declare namespace Commander {
     <
       Eff extends YieldWrap<Effect.Effect<any, any, any>>,
       AEff,
-      Args extends Array<any>,
+      Args extends Array<unknown>,
       A,
       B,
       C,
@@ -267,7 +268,7 @@ export declare namespace Commander {
     <
       Eff extends YieldWrap<Effect.Effect<any, any, any>>,
       AEff,
-      Args extends Array<any>,
+      Args extends Array<unknown>,
       A,
       B,
       C,
@@ -299,7 +300,7 @@ export declare namespace Commander {
     <
       Eff extends YieldWrap<Effect.Effect<any, any, any>>,
       AEff,
-      Args extends Array<any>,
+      Args extends Array<unknown>,
       A,
       B,
       C,
@@ -333,7 +334,7 @@ export declare namespace Commander {
     <
       Eff extends YieldWrap<Effect.Effect<any, any, any>>,
       AEff,
-      Args extends Array<any>,
+      Args extends Array<unknown>,
       A,
       B,
       C,
@@ -369,32 +370,32 @@ export declare namespace Commander {
   }
 
   export type NonGen<RT, Id extends string> = {
-    <Eff extends Effect.Effect<any, any, RT | CommandContext>, Args extends Array<any>>(
+    <Eff extends Effect.Effect<any, any, RT | CommandContext>, Args extends Array<unknown>>(
       body: (...args: Args) => Eff
     ): CommandOutHelper<Args, Eff, Id>
-    <Eff extends Effect.Effect<any, any, RT | CommandContext>, A, Args extends Array<any>>(
+    <Eff extends Effect.Effect<any, any, RT | CommandContext>, A, Args extends Array<unknown>>(
       body: (...args: Args) => A,
       a: (_: A, ...args: NoInfer<Args>) => Eff
     ): CommandOutHelper<Args, Eff, Id>
-    <Eff extends Effect.Effect<any, any, RT | CommandContext>, A, B, Args extends Array<any>>(
+    <Eff extends Effect.Effect<any, any, RT | CommandContext>, A, B, Args extends Array<unknown>>(
       body: (...args: Args) => A,
       a: (_: A, ...args: NoInfer<Args>) => B,
       b: (_: B, ...args: NoInfer<Args>) => Eff
     ): CommandOutHelper<Args, Eff, Id>
-    <Eff extends Effect.Effect<any, any, RT | CommandContext>, A, B, C, Args extends Array<any>>(
+    <Eff extends Effect.Effect<any, any, RT | CommandContext>, A, B, C, Args extends Array<unknown>>(
       body: (...args: Args) => A,
       a: (_: A, ...args: NoInfer<Args>) => B,
       b: (_: B, ...args: NoInfer<Args>) => C,
       c: (_: C, ...args: NoInfer<Args>) => Eff
     ): CommandOutHelper<Args, Eff, Id>
-    <Eff extends Effect.Effect<any, any, RT | CommandContext>, A, B, C, D, Args extends Array<any>>(
+    <Eff extends Effect.Effect<any, any, RT | CommandContext>, A, B, C, D, Args extends Array<unknown>>(
       body: (...args: Args) => A,
       a: (_: A, ...args: NoInfer<Args>) => B,
       b: (_: B, ...args: NoInfer<Args>) => C,
       c: (_: C, ...args: NoInfer<Args>) => D,
       d: (_: D, ...args: NoInfer<Args>) => Eff
     ): CommandOutHelper<Args, Eff, Id>
-    <Eff extends Effect.Effect<any, any, RT | CommandContext>, A, B, C, D, E, Args extends Array<any>>(
+    <Eff extends Effect.Effect<any, any, RT | CommandContext>, A, B, C, D, E, Args extends Array<unknown>>(
       body: (...args: Args) => A,
       a: (_: A, ...args: NoInfer<Args>) => B,
       b: (_: B, ...args: NoInfer<Args>) => C,
@@ -402,7 +403,7 @@ export declare namespace Commander {
       d: (_: D, ...args: NoInfer<Args>) => E,
       e: (_: E, ...args: NoInfer<Args>) => Eff
     ): CommandOutHelper<Args, Eff, Id>
-    <Eff extends Effect.Effect<any, any, RT | CommandContext>, A, B, C, D, E, F, Args extends Array<any>>(
+    <Eff extends Effect.Effect<any, any, RT | CommandContext>, A, B, C, D, E, F, Args extends Array<unknown>>(
       body: (...args: Args) => A,
       a: (_: A, ...args: NoInfer<Args>) => B,
       b: (_: B, ...args: NoInfer<Args>) => C,
@@ -411,7 +412,7 @@ export declare namespace Commander {
       e: (_: E, ...args: NoInfer<Args>) => F,
       f: (_: F, ...args: NoInfer<Args>) => Eff
     ): CommandOutHelper<Args, Eff, Id>
-    <Eff extends Effect.Effect<any, any, RT | CommandContext>, A, B, C, D, E, F, G, Args extends Array<any>>(
+    <Eff extends Effect.Effect<any, any, RT | CommandContext>, A, B, C, D, E, F, G, Args extends Array<unknown>>(
       body: (...args: Args) => A,
       a: (_: A, ...args: NoInfer<Args>) => B,
       b: (_: B, ...args: NoInfer<Args>) => C,
@@ -421,7 +422,7 @@ export declare namespace Commander {
       f: (_: F, ...args: NoInfer<Args>) => G,
       g: (_: G, ...args: NoInfer<Args>) => Eff
     ): CommandOutHelper<Args, Eff, Id>
-    <Eff extends Effect.Effect<any, any, RT | CommandContext>, A, B, C, D, E, F, G, H, Args extends Array<any>>(
+    <Eff extends Effect.Effect<any, any, RT | CommandContext>, A, B, C, D, E, F, G, H, Args extends Array<unknown>>(
       body: (...args: Args) => A,
       a: (_: A, ...args: NoInfer<Args>) => B,
       b: (_: B, ...args: NoInfer<Args>) => C,
@@ -432,7 +433,7 @@ export declare namespace Commander {
       g: (_: G, ...args: NoInfer<Args>) => H,
       h: (_: H, ...args: NoInfer<Args>) => Eff
     ): CommandOutHelper<Args, Eff, Id>
-    <Eff extends Effect.Effect<any, any, RT | CommandContext>, A, B, C, D, E, F, G, H, I, Args extends Array<any>>(
+    <Eff extends Effect.Effect<any, any, RT | CommandContext>, A, B, C, D, E, F, G, H, I, Args extends Array<unknown>>(
       body: (...args: Args) => A,
       a: (_: A, ...args: NoInfer<Args>) => B,
       b: (_: B, ...args: NoInfer<Args>) => C,
@@ -446,7 +447,7 @@ export declare namespace Commander {
     ): CommandOutHelper<Args, Eff, Id>
   }
 
-  export type GenWrap<RT, Id extends string, Args extends Array<any>, AEff, EEff, REff> = {
+  export type GenWrap<RT, Id extends string, Args extends Array<unknown>, AEff, EEff, REff> = {
     (): CommandOut<
       Args,
       AEff,
@@ -617,9 +618,9 @@ export declare namespace Commander {
     ): CommandOutHelper<Args, I, Id>
   }
 
-  export type NonGenWrap<RT, Id extends string, Args extends Array<any>, AEff, EEff, REff> = {
+  export type NonGenWrap<RT, Id extends string, Args extends Array<unknown>, AEff, EEff, REff> = {
     (): CommandOutHelper<Args, Effect.Effect<AEff, EEff, REff>, Id>
-    <Eff extends Effect.Effect<any, any, RT | CommandContext>, Args extends Array<any>>(
+    <Eff extends Effect.Effect<any, any, RT | CommandContext>, Args extends Array<unknown>>(
       a: (
         _: Effect.Effect<
           AEff,
@@ -629,7 +630,7 @@ export declare namespace Commander {
         ...args: NoInfer<Args>
       ) => Eff
     ): CommandOutHelper<Args, Eff, Id>
-    <Eff extends Effect.Effect<any, any, RT | CommandContext>, B, Args extends Array<any>>(
+    <Eff extends Effect.Effect<any, any, RT | CommandContext>, B, Args extends Array<unknown>>(
       a: (
         _: Effect.Effect<
           AEff,
@@ -640,7 +641,7 @@ export declare namespace Commander {
       ) => B,
       b: (_: B, ...args: NoInfer<Args>) => Eff
     ): CommandOutHelper<Args, Eff, Id>
-    <Eff extends Effect.Effect<any, any, RT | CommandContext>, B, C, Args extends Array<any>>(
+    <Eff extends Effect.Effect<any, any, RT | CommandContext>, B, C, Args extends Array<unknown>>(
       a: (
         _: Effect.Effect<
           AEff,
@@ -652,7 +653,7 @@ export declare namespace Commander {
       b: (_: B, ...args: NoInfer<Args>) => C,
       c: (_: C, ...args: NoInfer<Args>) => Eff
     ): CommandOutHelper<Args, Eff, Id>
-    <Eff extends Effect.Effect<any, any, RT | CommandContext>, B, C, D, Args extends Array<any>>(
+    <Eff extends Effect.Effect<any, any, RT | CommandContext>, B, C, D, Args extends Array<unknown>>(
       a: (
         _: Effect.Effect<
           AEff,
@@ -665,7 +666,7 @@ export declare namespace Commander {
       c: (_: C, ...args: NoInfer<Args>) => D,
       d: (_: D, ...args: NoInfer<Args>) => Eff
     ): CommandOutHelper<Args, Eff, Id>
-    <Eff extends Effect.Effect<any, any, RT | CommandContext>, B, C, D, E, Args extends Array<any>>(
+    <Eff extends Effect.Effect<any, any, RT | CommandContext>, B, C, D, E, Args extends Array<unknown>>(
       a: (
         _: Effect.Effect<
           AEff,
@@ -679,7 +680,7 @@ export declare namespace Commander {
       d: (_: D, ...args: NoInfer<Args>) => E,
       e: (_: E, ...args: NoInfer<Args>) => Eff
     ): CommandOutHelper<Args, Eff, Id>
-    <Eff extends Effect.Effect<any, any, RT | CommandContext>, B, C, D, E, F, Args extends Array<any>>(
+    <Eff extends Effect.Effect<any, any, RT | CommandContext>, B, C, D, E, F, Args extends Array<unknown>>(
       a: (
         _: Effect.Effect<
           AEff,
@@ -694,7 +695,7 @@ export declare namespace Commander {
       e: (_: E, ...args: NoInfer<Args>) => F,
       f: (_: F, ...args: NoInfer<Args>) => Eff
     ): CommandOutHelper<Args, Eff, Id>
-    <Eff extends Effect.Effect<any, any, RT | CommandContext>, B, C, D, E, F, G, Args extends Array<any>>(
+    <Eff extends Effect.Effect<any, any, RT | CommandContext>, B, C, D, E, F, G, Args extends Array<unknown>>(
       a: (
         _: Effect.Effect<
           AEff,
@@ -710,7 +711,7 @@ export declare namespace Commander {
       f: (_: F, ...args: NoInfer<Args>) => G,
       g: (_: G, ...args: NoInfer<Args>) => Eff
     ): CommandOutHelper<Args, Eff, Id>
-    <Eff extends Effect.Effect<any, any, RT | CommandContext>, B, C, D, E, F, G, H, Args extends Array<any>>(
+    <Eff extends Effect.Effect<any, any, RT | CommandContext>, B, C, D, E, F, G, H, Args extends Array<unknown>>(
       a: (
         _: Effect.Effect<
           AEff,
@@ -727,7 +728,7 @@ export declare namespace Commander {
       g: (_: G, ...args: NoInfer<Args>) => H,
       h: (_: H, ...args: NoInfer<Args>) => Eff
     ): CommandOutHelper<Args, Eff, Id>
-    <Eff extends Effect.Effect<any, any, RT | CommandContext>, B, C, D, E, F, G, H, I, Args extends Array<any>>(
+    <Eff extends Effect.Effect<any, any, RT | CommandContext>, B, C, D, E, F, G, H, I, Args extends Array<unknown>>(
       a: (
         _: Effect.Effect<
           AEff,
@@ -759,6 +760,7 @@ export class Commander extends Effect.Service<Commander>()("Commander", {
     const { confirm, confirmOrInterrupt } = yield* Confirm
 
     const makeContext = <Id extends string>(id: Id) => {
+      if (!id) throw new Error("must specify an id")
       const namespace = `action.${id}` as const
 
       const action = intl.formatMessage({
@@ -778,7 +780,7 @@ export class Commander extends Effect.Service<Commander>()("Commander", {
     const makeCommand = <RT>(runtime: Runtime.Runtime<RT>) => {
       const runFork = Runtime.runFork(runtime)
       return <const Id extends string>(id: Id, errorDef?: Error) =>
-      <Args extends ReadonlyArray<any>, A, E, R extends RT | CommandContext>(
+      <Args extends ReadonlyArray<unknown>, A, E, R extends RT | CommandContext>(
         handler: (...args: Args) => Effect.Effect<A, E, R>
       ) => {
         // we capture the definition stack here, so we can append it to later stack traces
@@ -1053,10 +1055,17 @@ export class Commander extends Effect.Service<Commander>()("Commander", {
         )
       }
 
-    const defaultFailureMessageHandler =
-      <E, Args extends readonly any[]>(action: string, errorRenderer?: ErrorRenderer<E, Args>) =>
-      (o: Option.Option<E>, ...args: Args) =>
-        Option.match(o, {
+    const defaultFailureMessageHandler = <E, Args extends Array<unknown>, AME, AMR>(
+      actionMaker:
+        | string
+        | ((o: Option.Option<E>, ...args: Args) => string)
+        | ((o: Option.Option<E>, ...args: Args) => Effect.Effect<string, AME, AMR>),
+      errorRenderer?: ErrorRenderer<E, Args>
+    ) =>
+      Effect.fnUntraced(function*(o: Option.Option<E>, ...args: Args) {
+        const action = yield* wrapEffect(actionMaker)(o, ...args)
+
+        return Option.match(o, {
           onNone: () =>
             intl.formatMessage(
               { id: "handle.unexpected_error2" },
@@ -1083,6 +1092,7 @@ export class Commander extends Effect.Service<Commander>()("Commander", {
                 )
               }:\n` + renderError(action, errorRenderer)(e, ...args)
         })
+      })
 
     return {
       /** @experimental */
@@ -1163,7 +1173,7 @@ export class Commander extends Effect.Service<Commander>()("Commander", {
         )
       }),
       updateAction:
-        <Args extends Array<any>>(update: (currentActionId: string, ...args: Args) => string) =>
+        <Args extends Array<unknown>>(update: (currentActionId: string, ...args: Args) => string) =>
         <A, E, R>(_: Effect.Effect<A, E, R>, ...input: Args) =>
           Effect.updateService(
             _,
@@ -1173,7 +1183,7 @@ export class Commander extends Effect.Service<Commander>()("Commander", {
       defaultFailureMessageHandler,
       renderError,
       /** Version of withDefaultToast that automatically includes the action name in the default messages and uses intl */
-      withDefaultToast: <A, E, R, Args extends ReadonlyArray<unknown>>(
+      withDefaultToast: <A, E, R, Args extends Array<unknown>>(
         options?: {
           errorRenderer?: ErrorRenderer<E, Args>
           onWaiting?: null | undefined | string | ((action: string, ...args: Args) => string | null | undefined)
@@ -1252,7 +1262,7 @@ export class Commander extends Effect.Service<Commander>()("Commander", {
         const cmd = makeCommand(rt)
         return (_id: any) => {
           const isObject = typeof _id === "object" || typeof _id === "function"
-          const id = isObject ? _id.name : _id
+          const id = isObject ? _id.id : _id
           const context = makeContext(id)
           const idCmd = cmd(id)
           // TODO: implement proper tracing stack
@@ -1269,16 +1279,19 @@ export class Commander extends Effect.Service<Commander>()("Commander", {
                   ),
                 context,
                 isObject
-                  ? { mutate: _id.mutate }
+                  ? { mutate: "mutate" in _id ? _id.mutate : typeof _id === "function" ? _id : undefined }
                   : {}
               )
             ))
         }
       }) as unknown as <RT>(
         runtime: Runtime.Runtime<RT>
-      ) => <const Id extends string, MutArgs extends Array<any>, MutA, MutE, MutR>(
-        id: Id | { name: Id; mutate: (...args: MutArgs) => Effect.Effect<MutA, MutE, MutR> }
-      ) => <Args extends Array<any>, A, E, R extends RT | CommandContext>(
+      ) => <const Id extends string, MutArgs extends Array<unknown>, MutA, MutE, MutR>(
+        id:
+          | Id
+          | { id: Id; mutate: (...args: MutArgs) => Effect.Effect<MutA, MutE, MutR> }
+          | ((...args: MutArgs) => Effect.Effect<MutA, MutE, MutR>) & { id: Id }
+      ) => <Args extends Array<unknown>, A, E, R extends RT | CommandContext>(
         handler: (
           ctx: Effect.fn.Gen & Effect.fn.NonGen & Commander.CommandContextLocal<Id> & {
             // todo: only if we passed in one
@@ -1290,15 +1303,17 @@ export class Commander extends Effect.Service<Commander>()("Commander", {
       /** @experimental */
       alt: makeCommand as unknown as <RT>(runtime: Runtime.Runtime<RT>) => <const Id extends string>(
         id: Id
-      ) => <Args extends Array<any>, A, E, R extends RT | CommandContext>(
+      ) => <Args extends Array<unknown>, A, E, R extends RT | CommandContext>(
         handler: (...args: Args) => Effect.Effect<A, E, R>
       ) => Commander.CommandOut<Args, A, E, R, Id>,
 
       /** @experimental */
       wrap: <RT>(runtime: Runtime.Runtime<RT>) => {
         const make = makeCommand(runtime)
-        return <const Id extends string, Args extends Array<any>, A, E, R>(
-          mutation: { mutate: (...args: Args) => Effect.Effect<A, E, R>; name: Id }
+        return <const Id extends string, Args extends Array<unknown>, A, E, R>(
+          mutation:
+            | { mutate: (...args: Args) => Effect.Effect<A, E, R>; id: Id }
+            | ((...args: Args) => Effect.Effect<A, E, R>) & { id: Id }
         ): Commander.GenWrap<RT, Id, Args, A, E, R> & Commander.NonGenWrap<RT, Id, Args, A, E, R> =>
         (
           ...combinators: any[]
@@ -1309,11 +1324,13 @@ export class Commander extends Effect.Service<Commander>()("Commander", {
           const errorDef = new Error()
           Error.stackTraceLimit = limit
 
-          return make(mutation.name, errorDef)(
+          const mutate = "mutate" in mutation ? mutation.mutate : mutation
+
+          return make(mutation.id, errorDef)(
             Effect.fnUntraced(
               // fnUntraced only supports generators as first arg, so we convert to generator if needed
-              isGeneratorFunction(mutation.mutate) ? mutation.mutate : function*(...args: Args) {
-                return yield* mutation.mutate(...args)
+              isGeneratorFunction(mutate) ? mutate : function*(...args: Args) {
+                return yield* mutate(...args)
               },
               ...combinators as [any]
             ) as any

package/src/experimental/withToast.ts

@@ -1,4 +1,5 @@
 import { Cause, Effect, type Option } from "effect-app"
+import { wrapEffect } from "effect-app/utils"
 import { CurrentToastId, Toast } from "./toast.js"
 
 export interface ToastOptions<A, E, Args extends ReadonlyArray<unknown>, WaiR, SucR, ErrR> {
@@ -30,25 +31,11 @@ export interface ToastOptions<A, E, Args extends ReadonlyArray<unknown>, WaiR, S
     ) => Effect.Effect<string | { level: "warn" | "error"; message: string }, never, ErrR>)
 }
 
-// unifies any input to be an effect.
-const wrapEffect = <I, A, E, R, Args extends Array<any>>(
-  m: I | ((...args: Args) => A) | ((...args: Args) => Effect.Effect<A, E, R>)
-) => {
-  if (typeof m === "function") {
-    return (...args: Args): Effect.Effect<A | I, E, R> => {
-      const r = (m as any)(...args)
-      if (Effect.isEffect(r)) return r as Effect.Effect<A, E, R>
-      return Effect.succeed(r)
-    }
-  }
-  return (): Effect.Effect<A | I, E, R> => Effect.succeed(m)
-}
-
 // @effect-diagnostics-next-line missingEffectServiceDependency:off
 export class WithToast extends Effect.Service<WithToast>()("WithToast", {
   effect: Effect.gen(function*() {
     const toast = yield* Toast
-    return <A, E, Args extends ReadonlyArray<unknown>, R, WaiR = never, SucR = never, ErrR = never>(
+    return <A, E, Args extends Array<unknown>, R, WaiR = never, SucR = never, ErrR = never>(
       options: ToastOptions<A, E, Args, WaiR, SucR, ErrR>
     ) =>
       Effect.fnUntraced(function*(self: Effect.Effect<A, E, R>, ...args: Args) {
@@ -96,7 +83,7 @@ export class WithToast extends Effect.Service<WithToast>()("WithToast", {
       })
   })
 }) {
-  static readonly handle = <A, E, Args extends ReadonlyArray<unknown>, R, WaiR = never, SucR = never, ErrR = never>(
+  static readonly handle = <A, E, Args extends Array<unknown>, R, WaiR = never, SucR = never, ErrR = never>(
     options: ToastOptions<A, E, Args, WaiR, SucR, ErrR>
   ): (self: Effect.Effect<A, E, R>, ...args: Args) => Effect.Effect<A, E, R | WaiR | SucR | ErrR | WithToast> =>
   (self, ...args) => this.use((_) => _<A, E, Args, R, WaiR, SucR, ErrR>(options)(self, ...args))

package/src/lib.ts

@@ -30,9 +30,9 @@ export const reportRuntimeError = (cause: Cause.Cause<unknown>, extras?: Record<
 
 // $Project/$Configuration.Index
 // -> "$Project", "$Configuration", "Index"
-export const makeQueryKey = ({ name, options }: { name: string; options?: ClientForOptions }) =>
+export const makeQueryKey = ({ id, options }: { id: string; options?: ClientForOptions }) =>
   pipe(
-    name.split("/"),
+    id.split("/"),
     (split) => split.filter((_) => !options || !options?.skipQueryKey?.includes(_)).map((_) => "$" + _)
   )
     .join(".")

package/src/makeClient.ts

@@ -126,7 +126,7 @@ function handleRequest<
   RDefect = never
 >(
   f: Effect.Effect<Exit.Exit<A, E>, never, R> | ((i: I) => Effect.Effect<Exit.Exit<A, E>, never, R>),
-  name: string,
+  id: string,
   action: string,
   options: {
     onSuccess: (a: A, i: I) => Effect.Effect<void, ESuccess, RSuccess>
@@ -168,7 +168,7 @@ function handleRequest<
             })
         })
       ),
-      Effect.withSpan(`mutation ${name}`, { captureStackTrace: false })
+      Effect.withSpan(`mutation ${id}`, { captureStackTrace: false })
     )
   return Object.assign(
     Effect.isEffect(f)
@@ -190,7 +190,7 @@ const _useMutation = makeMutation()
 /**
  * Pass an Effect or a function that returns an Effect, e.g from a client action
  * Executes query cache invalidation based on default rules or provided option.
- * adds a span with the mutation name
+ * adds a span with the mutation id
  */
 export const useMutation: typeof _useMutation = <
   I,
@@ -205,7 +205,7 @@ export const useMutation: typeof _useMutation = <
 ) =>
   mapHandler(
     _useMutation(self as any, options),
-    Effect.withSpan(`mutation ${self.name}`, { captureStackTrace: false })
+    Effect.withSpan(`mutation ${self.id}`, { captureStackTrace: false })
   ) as any
 
 // @effect-diagnostics-next-line missingEffectServiceDependency:off
@@ -248,7 +248,7 @@ export class LegacyMutation extends Effect.Service<LegacyMutation>()("LegacyMuta
           a,
           mapHandler(
             b,
-            Effect.withSpan(`mutation ${self.name}`, { captureStackTrace: false })
+            Effect.withSpan(`mutation ${self.id}`, { captureStackTrace: false })
           )
         ] as const as any
       }
@@ -276,7 +276,7 @@ export class LegacyMutation extends Effect.Service<LegacyMutation>()("LegacyMuta
           RDefect = never
         >(
           f: Effect.Effect<Exit.Exit<A2, E2>, never, R2> | ((i: I) => Effect.Effect<Exit.Exit<A2, E2>, never, R2>),
-          name: string,
+          id: string,
           action: string,
           options: Opts<A, E, R, I, A2, E2, R2, ESuccess, RSuccess, EError, RError, EDefect, RDefect> = {}
         ) {
@@ -294,7 +294,7 @@ export class LegacyMutation extends Effect.Service<LegacyMutation>()("LegacyMuta
             { action: actionMessage }
           )
 
-          return handleRequest<E2, A2, R2, any, ESuccess, RSuccess, EError, RError, EDefect, RDefect>(f, name, action, {
+          return handleRequest<E2, A2, R2, any, ESuccess, RSuccess, EError, RError, EDefect, RDefect>(f, id, action, {
             onSuccess: Effect.fnUntraced(function*(a, i) {
               const message = options.successMessage ? yield* options.successMessage(a, i) : defaultSuccessMessage
                 + (S.is(OperationSuccess)(a) && a.message
@@ -460,7 +460,7 @@ export class LegacyMutation extends Effect.Service<LegacyMutation>()("LegacyMuta
 
         return tuple(
           a,
-          handleRequestWithToast(b as any, self.name, action, options)
+          handleRequestWithToast(b as any, self.id, action, options)
         )
       }
       //
@@ -697,7 +697,7 @@ export class LegacyMutation extends Effect.Service<LegacyMutation>()("LegacyMuta
 
         return tuple(
           computed(() => mutationResultToVue(a.value)),
-          handleRequest(b as any, self.name, action, {
+          handleRequest(b as any, self.id, action, {
             onSuccess: suppressToast,
             onDefect: suppressToast,
             onFail: suppressToast,

package/src/mutate.ts

@@ -7,13 +7,13 @@ import { tuple } from "effect-app/Function"
 import { computed, type ComputedRef, shallowRef } from "vue"
 import { makeQueryKey } from "./lib.js"
 
-export const getQueryKey = (h: { name: string }) => {
+export const getQueryKey = (h: { id: string }) => {
   const key = makeQueryKey(h)
   const ns = key.filter((_) => _.startsWith("$"))
   // we invalidate the parent namespace e.g $project/$configuration.get, we invalidate $project
   // for $project/$configuration/$something.get, we invalidate $project/$configuration
   const k = ns.length ? ns.length > 1 ? ns.slice(0, ns.length - 1) : ns : undefined
-  if (!k) throw new Error("empty query key for: " + h.name)
+  if (!k) throw new Error("empty query key for: " + h.id)
   return k
 }
 
@@ -180,7 +180,7 @@ export const makeMutation = () => {
       const queryKey = getQueryKey(self)
 
       if (options?.queryInvalidation) {
-        const opts = options.queryInvalidation(queryKey, self.name)
+        const opts = options.queryInvalidation(queryKey, self.id)
         if (!opts.length) {
           return Effect.void
         }

package/src/query.ts

@@ -75,7 +75,7 @@ export const makeQuery = <R>(getRuntime: () => Runtime.Runtime<R>) => {
               handler
                 .pipe(
                   Effect.tapDefect(reportRuntimeError),
-                  Effect.withSpan(`query ${q.name}`, { captureStackTrace: false }),
+                  Effect.withSpan(`query ${q.id}`, { captureStackTrace: false }),
                   meta?.["span"] ? Effect.withParentSpan(meta["span"] as Span) : (_) => _
                 ),
               { signal }
@@ -100,7 +100,7 @@ export const makeQuery = <R>(getRuntime: () => Runtime.Runtime<R>) => {
               handler(req.value)
                 .pipe(
                   Effect.tapDefect(reportRuntimeError),
-                  Effect.withSpan(`query ${q.name}`, { captureStackTrace: false }),
+                  Effect.withSpan(`query ${q.id}`, { captureStackTrace: false }),
                   meta?.["span"] ? Effect.withParentSpan(meta["span"] as Span) : (_) => _
                 ),
               { signal }

package/test/Mutation.test.ts

@@ -23,9 +23,31 @@ describe("alt2", () => {
         let executed = false
 
         const someMutation = {
-          name: "Test Action",
-          mutate: (() => {}) as unknown as (a: number, b: string) => Effect.Effect<string, number, boolean>
-        }
+          id: "Test Action",
+          mutate: (() => {}) as unknown as (a: number, b: string) => Effect.Effect<string, number, CommandContext>
+        } as const
+        const someMutation2 = Object.assign(
+          (() => {}) as unknown as (a: number, b: string) => Effect.Effect<string, number, CommandContext>,
+          {
+            id: "Test Action"
+          } as const
+        )
+        const command1 = Command.alt2(someMutation2)((fn) =>
+          fn(
+            function*() {
+              expect(typeof fn.mutate).toBe("function")
+              expect(fn.id).toBe("Test Action")
+              expect(fn.namespace).toBe("action.Test Action")
+              expect(fn.namespaced("a")).toBe("action.Test Action.a")
+            }
+          )
+        )
+        yield* unwrap(command1.handle())
+        expect(command1.action).toBe("Test Action")
+        expect(command1.id).toBe("Test Action")
+        expect(command1.namespace).toBe("action.Test Action")
+        expect(command1.namespaced("a")).toBe("action.Test Action.a")
+
         const command = Command.alt2(someMutation)((fn) =>
           fn(
             function*() {
@@ -55,7 +77,7 @@ describe("alt2", () => {
             Effect.tap(() => executed = true)
           )
         )
-        console.log(command)
+
         expect(command.action).toBe("Test Action")
         expect(command.id).toBe("Test Action")
         expect(command.namespace).toBe("action.Test Action")