@effect-app/vue 4.0.0-beta.186 → 4.0.0-beta.188

package/src/commander.ts

@@ -3,7 +3,6 @@ import { asResult, asStreamResult, deepToRaw, type MissingDependencies, reportRu
 import { reportMessage } from "@effect-app/vue/errorReporter"
 import { Cause, Context, Effect, type Exit, type Fiber, flow, Layer, Match, MutableHashMap, Option, Predicate, S } from "effect-app"
 import { SupportedErrors } from "effect-app/client"
-import { OperationFailure, OperationSuccess } from "effect-app/Operations"
 import { isGeneratorFunction, wrapEffect } from "effect-app/utils"
 import { type Refinement } from "effect/Predicate"
 import * as Stream from "effect/Stream"
@@ -23,41 +22,6 @@ type IntlRecord = Record<string, PrimitiveType | FormatXMLElementFn<string, stri
  */
 export type Progress = string | { readonly text: string; readonly percentage: number }
 
-/**
- * Options accepted when calling a stream mutation factory.
- * Supplying `progress` causes the resulting command to expose `running`
- * (the live AsyncResult ref) and `progress` (formatted loading info).
- * When omitted, neither is exposed on the command.
- */
-export type StreamMutationCallOptions<A, E> = {
-  progress?: (result: AsyncResult.AsyncResult<A, E>) => Progress | undefined
-}
-
-/**
- * The result of invoking a `mutateToResult` factory: the `execute` function (or
- * `Effect`, when the request takes no input) carries `id`, plus `running` and
- * `progress` when the factory was called with a `progress` formatter. Pass
- * directly to `Command.fn` / `Command.wrap` / `Command.wrapStream`, or invoke
- * to run the stream.
- */
-type StreamMutationCallable<Id extends string, Arg, A, E, R> =
-  & (((arg: Arg) => Effect.Effect<any, E, R>) | Effect.Effect<any, E, R>)
-  & {
-    readonly id: Id
-    readonly _streamCallable: true
-    readonly running?: ComputedRef<AsyncResult.AsyncResult<A, E>>
-    readonly progress?: ComputedRef<Progress | undefined>
-  }
-
-type StreamMutationFactory<Id extends string, Arg, A, E, R> =
-  & ((options?: StreamMutationCallOptions<A, E>) => StreamMutationCallable<Id, Arg, A, E, R>)
-  & { readonly id: Id; readonly _streamFactory: true }
-
-const isStreamFactory = (x: unknown): x is StreamMutationFactory<string, any, any, any, any> =>
-  typeof x === "function" && (x as any)._streamFactory === true
-
-const isStreamCallable = (x: unknown): x is StreamMutationCallable<string, any, any, any, any> =>
-  x !== null && x !== undefined && (x as any)._streamCallable === true
 type FnOptions<
   Id extends string,
   I18nCustomKey extends string,
@@ -218,15 +182,8 @@ export declare namespace Commander {
     /** reactive */
     result: AsyncResult.AsyncResult<A, E>
     /**
-     * reactive – set when the command wraps a stream (`wrapStream` / `wrap` with `mutateToResult`)
-     * or when the `progress` option is provided to `fn`.
-     * Reflects the live AsyncResult of the underlying stream.
-     */
-    running: AsyncResult.AsyncResult<any, any> | undefined
-    /**
-     * reactive – formatted progress info computed from `running` via the
-     * `progress` option. Useful as the loading state on a `CommandButton`.
-     * Undefined when no `progress` formatter was supplied.
+     * reactive – formatted progress info driven by `Command.mapProgress` or `Command.updateProgress`
+     * inside a `streamFn` handler. Undefined for non-stream commands.
      */
     progress: Progress | undefined
     /** reactive */
@@ -1873,6 +1830,97 @@ export declare namespace Commander {
         ? CommandOut<Arg, SA2, SE2 | EE2, SR2 | ER2, Id, I18nKey, State>
       : never
   }
+
+  /**
+   * Type returned by `mutate.wrap` on a stream handler — analogous to `CommanderWrap` but for streams.
+   * The handler is pre-baked (from the stream mutation), so this is called with only optional combinators.
+   */
+  export type StreamerWrap<
+    RT,
+    Id extends string,
+    I18nKey extends string,
+    State extends IntlRecord | undefined,
+    Arg,
+    SA,
+    SE,
+    SR
+  > =
+    & CommandContextLocal<Id, I18nKey>
+    & { readonly state: Context.Service<`Commander.Command.${Id}.state`, State> }
+    & {
+      (): Exclude<SR, RT> extends never ? CommandOut<Arg, SA, SE, SR, Id, I18nKey, State>
+        : MissingDependencies<RT, SR> & {}
+      <A extends Stream.Stream<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>>(
+        a: (
+          _: Stream.Stream<SA, SE, SR>,
+          arg: ArgForCombinator<Arg>,
+          ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
+        ) => A
+      ): CommandOut<Arg, Stream.Success<A>, Stream.Error<A>, Stream.Services<A>, Id, I18nKey, State>
+      <
+        B,
+        A extends Stream.Stream<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>
+      >(
+        a: (
+          _: Stream.Stream<SA, SE, SR>,
+          arg: ArgForCombinator<Arg>,
+          ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
+        ) => B,
+        b: (
+          _: B,
+          arg: ArgForCombinator<Arg>,
+          ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
+        ) => A
+      ): CommandOut<Arg, Stream.Success<A>, Stream.Error<A>, Stream.Services<A>, Id, I18nKey, State>
+      <
+        B,
+        C,
+        A extends Stream.Stream<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>
+      >(
+        a: (
+          _: Stream.Stream<SA, SE, SR>,
+          arg: ArgForCombinator<Arg>,
+          ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
+        ) => B,
+        b: (
+          _: B,
+          arg: ArgForCombinator<Arg>,
+          ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
+        ) => C,
+        c: (
+          _: C,
+          arg: ArgForCombinator<Arg>,
+          ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
+        ) => A
+      ): CommandOut<Arg, Stream.Success<A>, Stream.Error<A>, Stream.Services<A>, Id, I18nKey, State>
+      <
+        B,
+        C,
+        D,
+        A extends Stream.Stream<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>
+      >(
+        a: (
+          _: Stream.Stream<SA, SE, SR>,
+          arg: ArgForCombinator<Arg>,
+          ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
+        ) => B,
+        b: (
+          _: B,
+          arg: ArgForCombinator<Arg>,
+          ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
+        ) => C,
+        c: (
+          _: C,
+          arg: ArgForCombinator<Arg>,
+          ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
+        ) => D,
+        d: (
+          _: D,
+          arg: ArgForCombinator<Arg>,
+          ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
+        ) => A
+      ): CommandOut<Arg, Stream.Success<A>, Stream.Error<A>, Stream.Services<A>, Id, I18nKey, State>
+    }
 }
 
 type ErrorRenderer<E, Args extends readonly any[]> = (e: E, action: string, ...args: Args) => string | undefined
@@ -1966,25 +2014,15 @@ const defaultFailureMessageHandler = <E, Args extends Array<unknown>, AME, AMR>(
         ),
       onSome: (e) => {
         const rendered = renderError(action, errorRenderer)(e, ...args)
-        return S.is(OperationFailure)(e)
-          ? {
-            level: "warn" as const,
-            message: `${
-              intl.formatMessage(
-                { id: "handle.with_warnings" },
-                { action }
-              )
-            }${rendered ? "\n" + rendered : ""}`
-          }
-          : {
-            level: "warn" as const,
-            message: `${
-              intl.formatMessage(
-                { id: "handle.with_errors" },
-                { action }
-              )
-            }:\n` + rendered
-          }
+        return {
+          level: "warn" as const,
+          message: `${
+            intl.formatMessage(
+              { id: "handle.with_errors" },
+              { action }
+            )
+          }:\n` + rendered
+        }
       }
     })
   })
@@ -2180,14 +2218,13 @@ export const CommanderStatic = {
               ),
             onSuccess: options?.onSuccess === null
               ? null
-              : (a, ..._args) =>
+              : (_a, ..._args) =>
                 hasCustomSuccess
                   ? intl.formatMessage(
                     { id: customSuccess },
                     cc.state
                   )
-                  : (intl.formatMessage({ id: "handle.success" }, { action: cc.action })
-                    + (S.is(OperationSuccess)(a) && a.message ? "\n" + a.message : "")),
+                  : intl.formatMessage({ id: "handle.success" }, { action: cc.action }),
             onFailure: defaultFailureMessageHandler(
               hasCustomFailure ? intl.formatMessage({ id: customFailure }, cc.state) : cc.action,
               options?.errorRenderer as ErrorRenderer<E, Args> | undefined
@@ -2362,7 +2399,6 @@ export const CommanderStatic = {
             : hasCustomSuccess
             ? intl.formatMessage({ id: customSuccess }, cc.state)
             : intl.formatMessage({ id: "handle.success" }, { action: cc.action })
-              + (S.is(OperationSuccess)(lastValue) && lastValue.message ? "\n" + lastValue.message : "")
 
           if (successMsg === null) return Effect.void
 
@@ -2495,17 +2531,11 @@ export class CommanderImpl<RT, RTHooks> {
   readonly makeCommand = <
     const Id extends string,
     const State extends IntlRecord | undefined,
-    const I18nKey extends string = Id,
-    RunningA = unknown,
-    RunningE = unknown
+    const I18nKey extends string = Id
   >(
     id_: Id | { id: Id },
     options?: FnOptions<Id, I18nKey, State>,
-    errorDef?: Error,
-    streamMeta?: {
-      running?: ComputedRef<AsyncResult.AsyncResult<RunningA, RunningE>> | undefined
-      progress?: ComputedRef<Progress | undefined> | undefined
-    }
+    errorDef?: Error
   ) => {
     const id = typeof id_ === "string" ? id_ : id_.id
     const state = getStateValues(options)
@@ -2690,12 +2720,8 @@ export class CommanderImpl<RT, RTHooks> {
 
           /** reactive */
           result,
-          /** reactive – live AsyncResult of the underlying stream, exposed only when
-           * the stream factory was called with a `progress` formatter */
-          running: streamMeta?.running,
-          /** reactive – formatted progress info for current `running` state, when `progress`
-           * formatter was supplied to the stream factory */
-          progress: streamMeta?.progress,
+          /** always undefined for non-stream commands */
+          progress: undefined,
           /** reactive */
           waiting,
           /** reactive */
@@ -2797,40 +2823,14 @@ export class CommanderImpl<RT, RTHooks> {
   fn = <
     const Id extends string,
     const State extends IntlRecord = IntlRecord,
-    const I18nKey extends string = Id,
-    RunningA = unknown,
-    RunningE = unknown
+    const I18nKey extends string = Id
   >(
-    id:
-      | Id
-      | { id: Id }
-      | StreamMutationCallable<Id, any, RunningA, RunningE, any>
-      | StreamMutationFactory<Id, any, RunningA, RunningE, any>,
+    id: Id | { id: Id },
     options?: FnOptions<Id, I18nKey, State>
   ): Commander.Gen<RT | RTHooks, Id, I18nKey, State> & Commander.NonGen<RT | RTHooks, Id, I18nKey, State> & {
     state: Context.Service<`Commander.Command.${Id}.state`, State>
   } => {
-    // Resolve id and (optionally) per-build stream metadata.
-    const resolvedId: Id = typeof id === "string" ? id : (id as { id: Id }).id
-    const factory = isStreamFactory(id)
-    const callable = !factory && isStreamCallable(id)
-    const resolveStreamMeta = ():
-      | {
-        running?: ComputedRef<AsyncResult.AsyncResult<RunningA, RunningE>> | undefined
-        progress?: ComputedRef<Progress | undefined> | undefined
-      }
-      | undefined =>
-    {
-      if (factory) {
-        const c = id()
-        return { running: c.running, progress: c.progress }
-      }
-      if (callable) {
-        const c = id as StreamMutationCallable<Id, any, RunningA, RunningE, any>
-        return { running: c.running, progress: c.progress }
-      }
-      return undefined
-    }
+    const resolvedId: Id = typeof id === "string" ? id : id.id
     return Object.assign(
       (
         fn: any,
@@ -2842,9 +2842,7 @@ export class CommanderImpl<RT, RTHooks> {
         const errorDef = new Error()
         Error.stackTraceLimit = limit
 
-        const streamMeta = resolveStreamMeta()
-
-        return this.makeCommand(resolvedId, options, errorDef, streamMeta)(
+        return this.makeCommand(resolvedId, options, errorDef)(
           Effect.fnUntraced(
             // fnUntraced only supports generators as first arg, so we convert to generator if needed
             isGeneratorFunction(fn) ? fn : function*(...args) {
@@ -3047,8 +3045,6 @@ export class CommanderImpl<RT, RTHooks> {
           namespace: initialContext.namespace,
           namespaced: initialContext.namespaced,
           result,
-          /** always undefined for streamFn commands — `result` already exposes the live stream state */
-          running: undefined,
           /** reactive – progress driven by `Command.mapProgress` or `Command.updateProgress` inside the stream */
           progress,
           waiting,
@@ -3270,147 +3266,77 @@ export class CommanderImpl<RT, RTHooks> {
    * **User Feedback**: Use the `withDefaultToast` helper for status notifications, or render
    * the `result` inline for custom UI feedback.
    */
-  wrap = <
+  streamWrap = <
     const Id extends string,
     Arg,
-    A,
-    E,
-    R,
+    SA,
+    SE,
+    SR,
     const State extends IntlRecord = IntlRecord,
     I18nKey extends string = Id
   >(
-    mutation:
-      | { mutate: (arg: Arg) => Effect.Effect<A, E, R>; id: Id }
-      | ((arg: Arg) => Effect.Effect<A, E, R>) & { id: Id }
-      | StreamMutationFactory<Id, Arg, A, E, R>
-      | {
-        id: Id
-        mutateToResult:
-          | StreamMutationFactory<Id, Arg, A, E, R>
-          | StreamMutationCallable<Id, Arg, A, E, R>
-      }
-      | StreamMutationCallable<Id, Arg, A, E, R>,
+    handler: (arg: Arg, ctx: Commander.CommandContextLocal2<Id, I18nKey, State>) => Stream.Stream<SA, SE, SR>,
+    id: Id,
     options?: FnOptions<Id, I18nKey, State>
-  ): Commander.CommanderWrap<RT | RTHooks, Id, I18nKey, State, Arg, A, E, R> => {
-    if (mutation !== null && typeof mutation === "object" && "mutateToResult" in mutation) {
-      return this.wrapStream(mutation as any, options) as any
-    }
-    if (isStreamCallable(mutation) || isStreamFactory(mutation)) {
-      return this.wrapStream(mutation as any, options) as any
-    }
-    // At this point mutation is either { mutate, id } or (fn & { id })
-    const callMutation = mutation as
-      | { mutate: (arg: Arg) => Effect.Effect<A, E, R>; id: Id }
-      | (((arg: Arg) => Effect.Effect<A, E, R>) & { id: Id })
+  ): Commander.StreamerWrap<RT | RTHooks, Id, I18nKey, State, Arg, SA, SE, SR> => {
     return Object.assign(
-      (
-        ...combinators: any[]
-      ): any => {
-        // we capture the definition stack here, so we can append it to later stack traces
+      (...combinators: any[]): any => {
         const limit = Error.stackTraceLimit
         Error.stackTraceLimit = 2
         const errorDef = new Error()
         Error.stackTraceLimit = limit
-        const mutate = "mutate" in callMutation
-          ? callMutation.mutate
-          : callMutation
-
-        return this.makeCommand(callMutation.id, options, errorDef)(
-          Effect.fnUntraced(
-            // fnUntraced only supports generators as first arg, so we convert to generator if needed
-            isGeneratorFunction(mutate) ? mutate : function*(arg: Arg) {
-              return yield* mutate(arg)
-            },
-            ...combinators as [any]
-          ) as any
+        return this.makeStreamCommand(id, options, errorDef)(
+          combinators.length === 0
+            ? handler
+            : (arg: Arg, ctx: Commander.CommandContextLocal2<Id, I18nKey, State>) => {
+              let current: any = handler(arg, ctx)
+              for (const combinator of combinators) {
+                current = combinator(current, arg, ctx)
+              }
+              return current
+            }
         )
       },
-      makeBaseInfo(callMutation.id, options),
+      makeBaseInfo(id, options),
       {
         state: Context.Service<`Commander.Command.${Id}.state`, State>(
-          `Commander.Command.${callMutation.id}.state`
+          `Commander.Command.${id}.state`
         )
       }
     )
   }
 
-  /**
-   * Define a Command from a stream-type mutation (`mutateToResult` factory).
-   * The stream's reactive `AsyncResult` ref is exposed as `running` for independent progress tracking.
-   * The command's own `result` reflects the execution outcome of the `execute` function.
-   * Supports the same combinator pipeline as `wrap` (e.g. `withDefaultToast`).
-   *
-   * Each invocation of the resulting wrap call produces a fresh `[ref, execute]` pair
-   * (the `mutateToResult` factory is called once per build), so independent commands
-   * don't share progress state.
-   *
-   * Accepts either:
-   * - An object with `id` and `mutateToResult` factory (e.g. a client entry)
-   * - The `mutateToResult` factory directly (callable, with `id`)
-   * - An already-called factory result (`[resultRef, execute] & { id }`) — shared ref across builds
-   *
-   * @example
-   * ```ts
-   * // Via client entry (recommended):
-   * const exportCmd = Command.wrapStream(client.myExport)()
-   *
-   * // Via factory directly:
-   * const exportCmd = Command.wrapStream(client.myExport.mutateToResult)()
-   *
-   * // Via already-called factory (shared ref):
-   * const stream = client.myExport.mutateToResult()
-   * const exportCmd = Command.wrapStream(stream)()
-   * ```
-   */
-  wrapStream = <
+  wrap = <
     const Id extends string,
     Arg,
     A,
     E,
     R,
     const State extends IntlRecord = IntlRecord,
-    const I18nKey extends string = Id
+    I18nKey extends string = Id
   >(
     mutation:
-      | {
-        id: Id
-        mutateToResult:
-          | StreamMutationFactory<Id, Arg, A, E, R>
-          | StreamMutationCallable<Id, Arg, A, E, R>
-      }
-      | StreamMutationFactory<Id, Arg, A, E, R>
-      | StreamMutationCallable<Id, Arg, A, E, R>,
+      | { mutate: (arg: Arg) => Effect.Effect<A, E, R>; id: Id }
+      | ((arg: Arg) => Effect.Effect<A, E, R>) & { id: Id },
     options?: FnOptions<Id, I18nKey, State>
   ): Commander.CommanderWrap<RT | RTHooks, Id, I18nKey, State, Arg, A, E, R> => {
-    const id = mutation.id
-    // Resolve `source` to the factory or already-invoked callable.
-    const source: StreamMutationFactory<Id, Arg, A, E, R> | StreamMutationCallable<Id, Arg, A, E, R> =
-      mutation !== null && typeof mutation === "object" && "mutateToResult" in mutation
-        ? (mutation.mutateToResult as any)
-        : (mutation as any)
-    const resolveCallable = (): StreamMutationCallable<Id, Arg, A, E, R> =>
-      (isStreamFactory(source)
-        ? (source as StreamMutationFactory<Id, Arg, A, E, R>)()
-        : source) as StreamMutationCallable<Id, Arg, A, E, R>
+    const callMutation = mutation
     return Object.assign(
-      (...combinators: any[]): any => {
+      (
+        ...combinators: any[]
+      ): any => {
         // we capture the definition stack here, so we can append it to later stack traces
         const limit = Error.stackTraceLimit
         Error.stackTraceLimit = 2
         const errorDef = new Error()
         Error.stackTraceLimit = limit
+        const mutate = "mutate" in callMutation
+          ? callMutation.mutate
+          : callMutation
 
-        // Fresh per build: invoke the factory once per command instance so each
-        // wrap call gets its own state + execute pair. `running`/`progress`
-        // are only surfaced when the factory was called with a `progress` formatter.
-        const callable = resolveCallable()
-        const mutate: (_arg: Arg) => Effect.Effect<any, E, R> = Effect.isEffect(callable)
-          ? (_arg: Arg) => callable
-          : callable as (arg: Arg) => Effect.Effect<any, E, R>
-        const streamMeta = { running: callable.running, progress: callable.progress }
-
-        return this.makeCommand(id, options, errorDef, streamMeta)(
+        return this.makeCommand(callMutation.id, options, errorDef)(
           Effect.fnUntraced(
+            // fnUntraced only supports generators as first arg, so we convert to generator if needed
             isGeneratorFunction(mutate) ? mutate : function*(arg: Arg) {
               return yield* mutate(arg)
             },
@@ -3418,10 +3344,10 @@ export class CommanderImpl<RT, RTHooks> {
           ) as any
         )
       },
-      makeBaseInfo(id, options),
+      makeBaseInfo(callMutation.id, options),
       {
         state: Context.Service<`Commander.Command.${Id}.state`, State>(
-          `Commander.Command.${id}.state`
+          `Commander.Command.${callMutation.id}.state`
         )
       }
     )