@effect-app/vue 4.0.0-beta.181 → 4.0.0-beta.182

package/examples/streamMutation.ts

@@ -74,11 +74,15 @@ export const useExportMutation = () => {
 // When a request schema has `type: "stream"`, `clientFor` exposes:
 //
 //   client.exportData.mutateStream
-//   // -> () => [ComputedRef<AsyncResult<ExportEvent, E>>, (input: I) => Effect<void, never, R>] & { id }
-//   // Always invoke `()` to get a fresh ref+execute pair (per-call state).
-//   const [ref, execute] = client.exportData.mutateStream()
+//   // -> (options?) => ((input: I) => Effect<Final, never, R>) & { id, running?, progress? }
+//   // Always invoke `()` (optionally with `{ progress }`) to get a fresh callable.
+//   const execute = client.exportData.mutateStream()
+//   const executeWithProgress = client.exportData.mutateStream({
+//     progress: (r) => r._tag === "Success" ? `${r.value.completed}/${r.value.total}` : undefined
+//   })
+//   // The callable can also be passed directly to Command.fn / Command.wrap / Command.wrapStream.
 //
-// which is equivalent to calling `asStreamResult(client.exportData.handler)`.
+// which wraps `asStreamResult(client.exportData.handler)` internally.
 //
 // The `.helpers` object also includes `exportDataStream` (the camelCase key
 // plus "Stream" suffix) with the same factory shape.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@effect-app/vue",
-  "version": "4.0.0-beta.181",
+  "version": "4.0.0-beta.182",
   "license": "MIT",
   "type": "module",
   "homepage": "https://github.com/effect-ts-app/libs/tree/main/packages/vue",
@@ -11,7 +11,7 @@
     "@vueuse/core": "^14.2.1",
     "change-case": "^5.4.4",
     "query-string": "^9.3.1",
-    "effect-app": "4.0.0-beta.181"
+    "effect-app": "4.0.0-beta.182"
   },
   "peerDependencies": {
     "@effect/atom-vue": "^4.0.0-beta.59",

package/src/commander.ts

@@ -31,20 +31,31 @@ export type StreamMutationCallOptions<A, E> = {
   progress?: (result: AsyncResult.AsyncResult<A, E>) => Progress | undefined
 }
 
-type StreamMutationTuple<Id extends string, Arg, A, E, R> =
-  & readonly [
-    ComputedRef<AsyncResult.AsyncResult<A, E>>,
-    ((arg: Arg) => Effect.Effect<any, never, R>) | Effect.Effect<any, never, R>
-  ]
+/**
+ * The result of invoking a `mutateStream` 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>) => StreamMutationTuple<Id, Arg, A, E, R>)
-  & { readonly id: Id }
+  & ((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,
@@ -2395,7 +2406,7 @@ export class CommanderImpl<RT, RTHooks> {
     id:
       | Id
       | { id: Id }
-      | StreamMutationTuple<Id, any, RunningA, RunningE, any>
+      | StreamMutationCallable<Id, any, RunningA, RunningE, any>
       | StreamMutationFactory<Id, any, RunningA, RunningE, any>,
     options?: FnOptions<Id, I18nKey, State>
   ): Commander.Gen<RT | RTHooks, Id, I18nKey, State> & Commander.NonGen<RT | RTHooks, Id, I18nKey, State> & {
@@ -2403,8 +2414,8 @@ export class CommanderImpl<RT, RTHooks> {
   } => {
     // Resolve id and (optionally) per-build stream metadata.
     const resolvedId: Id = typeof id === "string" ? id : (id as { id: Id }).id
-    const isStreamFactory = typeof id === "function" && "id" in id && (id as any).length <= 1
-    const isStreamTuple = Array.isArray(id) && "id" in id
+    const factory = isStreamFactory(id)
+    const callable = !factory && isStreamCallable(id)
     const resolveStreamMeta = ():
       | {
         running?: ComputedRef<AsyncResult.AsyncResult<RunningA, RunningE>> | undefined
@@ -2412,13 +2423,13 @@ export class CommanderImpl<RT, RTHooks> {
       }
       | undefined =>
     {
-      if (isStreamTuple) {
-        const t = id as StreamMutationTuple<Id, any, RunningA, RunningE, any>
-        return { running: t.running, progress: t.progress }
+      if (factory) {
+        const c = id()
+        return { running: c.running, progress: c.progress }
       }
-      if (isStreamFactory) {
-        const t = id()
-        return { running: t.running, progress: t.progress }
+      if (callable) {
+        const c = id as StreamMutationCallable<Id, any, RunningA, RunningE, any>
+        return { running: c.running, progress: c.progress }
       }
       return undefined
     }
@@ -2563,18 +2574,15 @@ export class CommanderImpl<RT, RTHooks> {
         id: Id
         mutateStream:
           | StreamMutationFactory<Id, Arg, A, E, R>
-          | StreamMutationTuple<Id, Arg, A, E, R>
+          | StreamMutationCallable<Id, Arg, A, E, R>
       }
-      | StreamMutationTuple<Id, Arg, A, E, R>,
+      | StreamMutationCallable<Id, Arg, A, E, R>,
     options?: FnOptions<Id, I18nKey, State>
   ): Commander.CommanderWrap<RT | RTHooks, Id, I18nKey, State, Arg, A, E, R> => {
     if (mutation !== null && typeof mutation === "object" && "mutateStream" in mutation) {
       return this.wrapStream(mutation as any, options) as any
     }
-    if (Array.isArray(mutation) && "id" in mutation) {
-      return this.wrapStream(mutation as any, options) as any
-    }
-    if (typeof mutation === "function" && "id" in mutation && (mutation as any).length <= 1) {
+    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 })
@@ -2655,19 +2663,22 @@ export class CommanderImpl<RT, RTHooks> {
         id: Id
         mutateStream:
           | StreamMutationFactory<Id, Arg, A, E, R>
-          | StreamMutationTuple<Id, Arg, A, E, R>
+          | StreamMutationCallable<Id, Arg, A, E, R>
       }
       | StreamMutationFactory<Id, Arg, A, E, R>
-      | StreamMutationTuple<Id, Arg, A, E, R>,
+      | StreamMutationCallable<Id, Arg, A, E, R>,
     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-called tuple.
-    const source: StreamMutationFactory<Id, Arg, A, E, R> | StreamMutationTuple<Id, Arg, A, E, R> =
+    // 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" && "mutateStream" in mutation
         ? (mutation.mutateStream as any)
         : (mutation as any)
-    const resolveTuple = (): StreamMutationTuple<Id, Arg, A, E, R> => (typeof source === "function" ? source() : source)
+    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>
     return Object.assign(
       (...combinators: any[]): any => {
         // we capture the definition stack here, so we can append it to later stack traces
@@ -2676,15 +2687,14 @@ export class CommanderImpl<RT, RTHooks> {
         const errorDef = new Error()
         Error.stackTraceLimit = limit
 
-        // Fresh per build: call the factory once per command instance so each
-        // wrap call gets its own ComputedRef + execute pair. `running`/`progress`
+        // 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 tuple = resolveTuple()
-        const [, executeRaw] = tuple
-        const mutate: (_arg: Arg) => Effect.Effect<any, never, R> = Effect.isEffect(executeRaw)
-          ? (_arg: Arg) => executeRaw
-          : executeRaw
-        const streamMeta = { running: tuple.running, progress: tuple.progress }
+        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)(
           Effect.fnUntraced(

package/src/makeClient.ts

@@ -237,33 +237,36 @@ export type MutateStreamCallOptions<A, E> = {
 
 /**
  * The `mutateStream` factory for a stream-type request handler. Always invoke
- * (optionally with `{ progress }`) to get a fresh `[resultRef, execute]` tuple —
- * each call produces a new `ComputedRef` + execute pair so independent invocations
- * don't share state. `execute` updates the ref live with each emitted value.
- * When the request declares a `final` schema, `execute` resolves with the last
- * emitted value typed as `Final`; otherwise it resolves with the success type.
- * The factory itself carries the request `id` so it can be passed to
- * `Command.fn` / `Command.wrapStream` directly.
+ * (optionally with `{ progress }`) to get a fresh callable `execute` — each call
+ * produces a new state + execute pair so independent invocations don't share
+ * state. The callable updates its underlying ref live with each emitted value
+ * and carries `id`, plus `running` and `progress` when the factory was called
+ * with a `progress` formatter. When the request declares a `final` schema,
+ * the callable resolves with the last emitted value typed as `Final`; otherwise
+ * it resolves with the success type. The factory itself carries the request
+ * `id` so it can be passed to `Command.fn` / `Command.wrapStream` directly.
  */
 export type StreamMutationWithExtensions<Req> = Req extends
   RequestStreamHandlerWithInput<infer I, infer A, infer E, infer R, infer _Request, infer Id, infer Final> ?
     & ((options?: MutateStreamCallOptions<A, E>) =>
-      & readonly [ComputedRef<AsyncResult.AsyncResult<A, E>>, (input: I) => Effect.Effect<Final, never, R>]
+      & ((input: I) => Effect.Effect<Final, E, R>)
       & {
         readonly id: Id
+        readonly _streamCallable: true
         readonly running?: ComputedRef<AsyncResult.AsyncResult<A, E>>
         readonly progress?: ComputedRef<Progress | undefined>
       })
-    & { readonly id: Id }
+    & { readonly id: Id; readonly _streamFactory: true }
   : Req extends RequestStreamHandler<infer A, infer E, infer R, infer _Request, infer Id, infer Final> ?
       & ((options?: MutateStreamCallOptions<A, E>) =>
-        & readonly [ComputedRef<AsyncResult.AsyncResult<A, E>>, Effect.Effect<Final, never, R>]
+        & Effect.Effect<Final, E, R>
         & {
           readonly id: Id
+          readonly _streamCallable: true
           readonly running?: ComputedRef<AsyncResult.AsyncResult<A, E>>
           readonly progress?: ComputedRef<Progress | undefined>
         })
-      & { readonly id: Id }
+      & { readonly id: Id; readonly _streamFactory: true }
   : never
 
 /**
@@ -841,20 +844,21 @@ export const makeClient = <RT_, RTHooks>(
         const mergedInvalidation = mergeInvalidation(fromRequest, invalidation?.[key])
         const smFactory = Object.assign(
           (opts?: { progress?: (result: AsyncResult.AsyncResult<any, any>) => Progress | undefined }) => {
-            const tuple = streamMutation(client[key] as any, mergedInvalidation)
+            const [resultRef, execute] = streamMutation(client[key] as any, mergedInvalidation)
             const extras: {
               id: string
+              _streamCallable: true
               running?: ComputedRef<AsyncResult.AsyncResult<any, any>>
               progress?: ComputedRef<Progress | undefined>
-            } = { id: client[key].id }
+            } = { id: client[key].id, _streamCallable: true }
             if (opts?.progress) {
               const fmt = opts.progress
-              extras.running = tuple[0]
-              extras.progress = computed(() => fmt(tuple[0].value))
+              extras.running = resultRef
+              extras.progress = computed(() => fmt(resultRef.value))
             }
-            return Object.assign(tuple, extras)
+            return Object.assign(execute, extras)
           },
-          { id: client[key].id }
+          { id: client[key].id, _streamFactory: true as const }
         )
         ;(acc as any)[camelCase(key) + "Stream"] = Object.assign(smFactory, {
           fn: Command.fn(client[key].id)
@@ -938,20 +942,21 @@ export const makeClient = <RT_, RTHooks>(
               const mergedInvalidation = mergeInvalidation(fromRequest, invalidation?.[key])
               const streamMutFactory = Object.assign(
                 (opts?: { progress?: (result: AsyncResult.AsyncResult<any, any>) => Progress | undefined }) => {
-                  const tuple = streamMutation(client[key] as any, mergedInvalidation)
+                  const [resultRef, execute] = streamMutation(client[key] as any, mergedInvalidation)
                   const extras: {
                     id: string
+                    _streamCallable: true
                     running?: ComputedRef<AsyncResult.AsyncResult<any, any>>
                     progress?: ComputedRef<Progress | undefined>
-                  } = { id: client[key].id }
+                  } = { id: client[key].id, _streamCallable: true }
                   if (opts?.progress) {
                     const fmt = opts.progress
-                    extras.running = tuple[0]
-                    extras.progress = computed(() => fmt(tuple[0].value))
+                    extras.running = resultRef
+                    extras.progress = computed(() => fmt(resultRef.value))
                   }
-                  return Object.assign(tuple, extras)
+                  return Object.assign(execute, extras)
                 },
-                { id: client[key].id }
+                { id: client[key].id, _streamFactory: true as const }
               )
               return {
                 ...client[key],

package/src/mutate.ts

@@ -421,6 +421,7 @@ export const useMakeMutation = () => {
  *
  * When the request declares a `final` schema, `execute` resolves with the last emitted value
  * typed as `Final`; otherwise it resolves with the last emitted value typed as the success type.
+ * Stream failures bubble through the execute effect's typed error channel `E`.
  *
  * Must be called inside a Vue setup context (uses `useQueryClient` internally).
  */
@@ -437,7 +438,7 @@ export const makeStreamMutation = () => {
   ) => {
     const state = shallowRef<AsyncResult.AsyncResult<any, any>>(AsyncResult.initial())
 
-    const runStream = (stream: Stream.Stream<any, any, any>, input?: unknown): Effect.Effect<any, never, any> => {
+    const runStream = (stream: Stream.Stream<any, any, any>, input?: unknown): Effect.Effect<any, any, any> => {
       const invCache = buildInvalidateCache(queryClient, self, mergedInvalidation)
       const keysRef = Ref.makeUnsafe<ReadonlyArray<InvalidationKey>>([])
       // V3: pass onAdded so each mid-stream metadata chunk triggers query
@@ -476,11 +477,14 @@ export const makeStreamMutation = () => {
                 const lastValue = AsyncResult.isSuccess(current) ? current.value : undefined
                 const invExit = exit._tag === "Success" ? Exit.succeed(lastValue) : exit
                 const serverKeys = Ref.getUnsafe(keysRef)
-                // Note: when the stream fails, `lastValue` is undefined. The failure is
-                // communicated via the reactive `state` ref (AsyncResult.failure). The
-                // execute effect always resolves successfully; callers should inspect the
-                // ref to distinguish success from failure.
-                return invCache(input, invExit, serverKeys).pipe(Effect.as(lastValue))
+                // Stream failures bubble through the execute effect's typed error
+                // channel. The reactive `state` ref still mirrors the failure as
+                // `AsyncResult.failure` for live progress UI.
+                return invCache(input, invExit, serverKeys).pipe(
+                  Effect.flatMap(() =>
+                    exit._tag === "Success" ? Effect.succeed(lastValue) : Effect.failCause(exit.cause)
+                  )
+                )
               })
             )
           )

package/test/makeClient.test.ts

@@ -278,8 +278,8 @@ it.skip("stream final type tests", () => {
   const { clientFor } = useClient()
   const client = clientFor(Something, undefined, somethingInvalidationResources)
 
-  const [_refNoFinal, execNoFinal] = client.StreamWithoutFinal.mutateStream()
-  const [_refWithFinal, execWithFinal] = client.StreamWithFinal.mutateStream()
+  const execNoFinal = client.StreamWithoutFinal.mutateStream()
+  const execWithFinal = client.StreamWithFinal.mutateStream()
 
   // Without `final`: execute input is {id: string} and resolves with void
   const _execNoFinalResult: ReturnType<typeof execNoFinal> = execNoFinal({ id: "test" })

package/test/streamFinal.test.ts

@@ -47,7 +47,7 @@ it.skip("mutateStream without final: execute resolves void (type-level)", () =>
   const { clientFor } = useClient()
   const client = clientFor(Something, undefined, somethingInvalidationResources)
 
-  const [_ref, execute] = client.StreamWithoutFinal.mutateStream()
+  const execute = client.StreamWithoutFinal.mutateStream()
 
   // execute returns void — assigning to ExportComplete Effect should fail
   const result = execute({ id: "test" })
@@ -64,7 +64,7 @@ it.skip("mutateStream with final: execute resolves with ExportComplete (type-lev
   const { clientFor } = useClient()
   const client = clientFor(Something, undefined, somethingInvalidationResources)
 
-  const [_ref, execute] = client.StreamWithFinal.mutateStream()
+  const execute = client.StreamWithFinal.mutateStream()
 
   // execute returns ExportComplete — assignment should compile cleanly
   const result = execute({ id: "test" })