@effect-app/vue 4.0.0-beta.187 → 4.0.0-beta.189

package/src/makeClient.ts

@@ -9,11 +9,11 @@ import type * as ExitResult from "effect/Exit"
 import { type Fiber } from "effect/Fiber"
 import * as Stream from "effect/Stream"
 import * as AsyncResult from "effect/unstable/reactivity/AsyncResult"
-import { computed, type ComputedRef, onBeforeUnmount, ref, type WatchSource } from "vue"
+import { type ComputedRef, onBeforeUnmount, ref, type WatchSource } from "vue"
 import { type Commander, CommanderStatic, type Progress } from "./commander.js"
 import { type I18n } from "./intl.js"
 import { type CommanderResolved, makeUseCommand } from "./makeUseCommand.js"
-import { makeMutation, makeStreamMutation, makeStreamMutation2, type MutationOptionsBase, useMakeMutation } from "./mutate.js"
+import { makeMutation, makeStreamMutation2, type MutationOptionsBase, useMakeMutation } from "./mutate.js"
 import { type CustomUndefinedInitialQueryOptions, makeQuery, makeStreamQuery } from "./query.js"
 import { makeRunPromise } from "./runtime.js"
 import { type Toast } from "./toast.js"
@@ -227,74 +227,6 @@ export type MutationWithExtensions<RT, Req> = Req extends
     ? MutationExt<RT, Id, A, E, R, S.Codec.Encoded<Request["success"]>>
   : never
 
-/**
- * Options for invoking a `mutateToResult` factory. Supplying `progress` produces
- * a tuple-with-id that carries `running` (the live AsyncResult ref) and
- * `progress` (a `ComputedRef<Progress | undefined>` formatted from each value),
- * which `Command.fn` / `Command.wrapStream` surface as the command's `running`
- * and `progress`. When omitted, the resulting command exposes neither.
- */
-export type MutateStreamCallOptions<A, E> = {
-  progress?: (result: AsyncResult.AsyncResult<A, E>) => Progress | undefined
-}
-
-/**
- * The `mutateToResult` factory for a stream-type request handler. Always invoke
- * (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>) =>
-      & ((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 _streamFactory: true }
-  : Req extends RequestStreamHandler<infer A, infer E, infer R, infer _Request, infer Id, infer Final> ?
-      & ((options?: MutateStreamCallOptions<A, E>) =>
-        & 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 _streamFactory: true }
-  : never
-
-/**
- * The pre-built `wrapStream` CommanderWrap for a stream-type request handler.
- * The command's `result` and `running` are the live stream ref.
- * Callable like `wrap`: `client.myExport.wrapStream()` returns the CommandOut.
- */
-export type StreamCommandWithExtensions<RT, Req> = Req extends
-  RequestStreamHandlerWithInput<infer I, infer A, infer E, infer R, infer _Request, infer Id, infer _Final>
-  ? Commander.CommanderWrap<RT, Id, Id, undefined, I, A, E, R>
-  : Req extends RequestStreamHandler<infer A, infer E, infer R, infer _Request, infer Id, infer _Final>
-    ? Commander.CommanderWrap<RT, Id, Id, undefined, void, A, E, R>
-  : never
-
-/**
- * The `fn` builder for a stream-type request handler — identical to calling
- * `Command.fn(id)` where `id` comes from the request.
- */
-export type StreamFnExtension<RT, Req> = Req extends
-  RequestStreamHandlerWithInput<infer _I, infer _A, infer _E, infer _R, infer _Request, infer Id, infer _Final>
-  ? Commander.CommanderFn<RT, Id, Id, undefined>
-  : Req extends RequestStreamHandler<infer _A, infer _E, infer _R, infer _Request, infer Id, infer _Final>
-    ? Commander.CommanderFn<RT, Id, Id, undefined>
-  : never
-
 /**
  * The `streamFn` builder for a stream-type request handler, using the stream-specific overloads.
  */
@@ -306,7 +238,7 @@ export type StreamFnStreamExtension<RT, Req> = Req extends
   : never
 
 /**
- * `mutate` factory — like `mutateToResult` but wraps per-invocation invalidation scaffolding
+ * `mutate` factory — wraps per-invocation invalidation scaffolding
  * into the stream itself (via `Stream.unwrap`) for use with `streamFn` combinators.
  */
 export type StreamMutation2WithExtensions<RT, Req> = Req extends
@@ -314,13 +246,13 @@ export type StreamMutation2WithExtensions<RT, Req> = Req extends
     & ((input: I) => Stream.Stream<A, E, R>)
     & {
       readonly id: Id
-      readonly wrapStream: Commander.StreamGen<RT, Id, Id, undefined> & Commander.NonGenStream<RT, Id, Id, undefined>
+      readonly wrap: Commander.StreamerWrap<RT, Id, Id, undefined, I, A, E, R>
     }
   : Req extends RequestStreamHandler<infer A, infer E, infer R, infer _Request, infer Id, infer _Final> ?
       & Stream.Stream<A, E, R>
       & {
         readonly id: Id
-        readonly wrapStream: Commander.StreamGen<RT, Id, Id, undefined> & Commander.NonGenStream<RT, Id, Id, undefined>
+        readonly wrap: Commander.StreamerWrap<RT, Id, Id, undefined, void, A, E, R>
       }
   : never
 
@@ -713,9 +645,6 @@ export const makeClient = <RT_, RTHooks>(
   let m: ReturnType<typeof useMutationInt>
   const useMutation = () => m ??= useMutationInt()
 
-  let sm: ReturnType<typeof makeStreamMutation>
-  const useStreamMutation = () => sm ??= makeStreamMutation()
-
   let sm2: ReturnType<typeof makeStreamMutation2>
   const useStreamMutation2 = () => sm2 ??= makeStreamMutation2()
 
@@ -898,66 +827,6 @@ export const makeClient = <RT_, RTHooks>(
     return mutations
   }
 
-  const mapStreamMutation = <M extends RequestsAny>(
-    client: ClientFrom<M>,
-    queryInvalidation?: (client: ClientFrom<M>) => QueryInvalidation<M>,
-    invalidationResources?: InvalidationResourcesFor<M>
-  ) => {
-    const Command = useCommand()
-    const streamMutation = useStreamMutation()
-    const invalidation = queryInvalidation?.(client)
-    const queryResources = makeQueryResources(invalidationResources)
-    const streams = Struct.keys(client).reduce(
-      (acc, key) => {
-        if (client[key].Request.type !== "stream") {
-          return acc
-        }
-        const fromRequestConfig = client[key].Request.config?.["invalidatesQueries"] as
-          | InvalidationCallback<InvalidationResourcesFor<M>>
-          | undefined
-        const fromRequest = fromRequestConfig
-          ? ((defaultKey: string[], _name: string, input?: unknown, output?: unknown) =>
-            fromRequestConfig(defaultKey, queryResources as never, input as never, output as never).map((entry) => ({
-              filters: entry.filters,
-              options: entry.options
-            })))
-          : undefined
-        const mergedInvalidation = mergeInvalidation(fromRequest, invalidation?.[key])
-        const smFactory = Object.assign(
-          (opts?: { progress?: (result: AsyncResult.AsyncResult<any, any>) => Progress | undefined }) => {
-            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, _streamCallable: true }
-            if (opts?.progress) {
-              const fmt = opts.progress
-              extras.running = resultRef
-              extras.progress = computed(() => fmt(resultRef.value))
-            }
-            return Object.assign(execute, extras)
-          },
-          { id: client[key].id, _streamFactory: true as const }
-        )
-        ;(acc as any)[camelCase(key) + "Stream"] = Object.assign(smFactory, {
-          fn: Command.fn(client[key].id)
-        })
-        return acc
-      },
-      {} as {
-        [
-          Key in keyof typeof client as StreamHandler<typeof client[Key]> extends never ? never
-            : `${ToCamel<string & Key>}Stream`
-        ]:
-          & StreamMutationWithExtensions<StreamHandler<typeof client[Key]>>
-          & { fn: StreamFnExtension<RT | RTHooks, StreamHandler<typeof client[Key]>> }
-      }
-    )
-    return streams
-  }
-
   // make available .query, .suspense and .mutate for each operation
   // and a .helpers with all mutations and queries
   const mapClient = <M extends RequestsAny>(
@@ -969,7 +838,6 @@ export const makeClient = <RT_, RTHooks>(
   ) => {
     const Command = useCommand()
     const mutation = useMutation()
-    const streamMutation = useStreamMutation()
     const invalidation = queryInvalidation?.(client)
     const queryResources = makeQueryResources(invalidationResources)
     const extended = Struct.keys(client).reduce(
@@ -1021,31 +889,10 @@ export const makeClient = <RT_, RTHooks>(
                   })))
                 : undefined
               const mergedInvalidation = mergeInvalidation(fromRequest, invalidation?.[key])
-              const streamMutFactory = Object.assign(
-                (opts?: { progress?: (result: AsyncResult.AsyncResult<any, any>) => Progress | undefined }) => {
-                  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, _streamCallable: true }
-                  if (opts?.progress) {
-                    const fmt = opts.progress
-                    extras.running = resultRef
-                    extras.progress = computed(() => fmt(resultRef.value))
-                  }
-                  return Object.assign(execute, extras)
-                },
-                { id: client[key].id, _streamFactory: true as const }
-              )
               return {
                 ...client[key],
                 request: h_,
                 streamQuery: useStreamQuery(client[key] as any),
-                mutateToResult: streamMutFactory,
-                wrapStream: Command.wrapStream(streamMutFactory),
-                fn: Command.fn(client[key].id),
                 streamFn: useCommand().streamFn(client[key].id as any) as any,
                 mutate: (() => {
                   const sm2Act = useStreamMutation2()(client[key] as any, mergedInvalidation)
@@ -1055,10 +902,7 @@ export const makeClient = <RT_, RTHooks>(
                     : (input: any, _ctx: any) => (sm2Act as (i: any) => any)(input)
                   return Object.assign(sm2Act, {
                     id: client[key].id,
-                    wrapStream: (...combinators: any[]) => {
-                      const sfn = useCommand().streamFn(client[key].id as any) as any
-                      return sfn(sm2Handler, ...combinators)
-                    }
+                    wrap: useCommand().streamWrap(sm2Handler, client[key].id as any)
                   })
                 })()
               }
@@ -1125,9 +969,6 @@ export const makeClient = <RT_, RTHooks>(
             : { mutate: MutationWithExtensions<RT | RTHooks, CommandHandler<typeof client[Key]>> })
           & (StreamHandler<typeof client[Key]> extends never ? {}
             : {
-              mutateToResult: StreamMutationWithExtensions<StreamHandler<typeof client[Key]>>
-              wrapStream: StreamCommandWithExtensions<RT | RTHooks, StreamHandler<typeof client[Key]>>
-              fn: StreamFnExtension<RT | RTHooks, StreamHandler<typeof client[Key]>>
               streamFn: StreamFnStreamExtension<RT | RTHooks, StreamHandler<typeof client[Key]>>
               mutate: StreamMutation2WithExtensions<RT | RTHooks, StreamHandler<typeof client[Key]>>
             })
@@ -1138,7 +979,6 @@ export const makeClient = <RT_, RTHooks>(
       helpers: {
         ...mapRequest(client),
         ...mapMutation(client, queryInvalidation, invalidationResources),
-        ...mapStreamMutation(client, queryInvalidation, invalidationResources),
         ...mapQuery(client)
       }
     })
@@ -1191,7 +1031,6 @@ export const makeClient = <RT_, RTHooks>(
       // delay initialisation until first use...
       fn: (...args: [any]) => useCommand().fn(...args),
       wrap: (...args: [any]) => useCommand().wrap(...args),
-      wrapStream: (...args: [any]) => useCommand().wrapStream(...args),
       streamFn: (...args: [any]) => useCommand().streamFn(...args),
       alt: (...args: [any]) => useCommand().alt(...args),
       alt2: (...args: [any]) => useCommand().alt2(...args)

package/src/makeUseCommand.ts

@@ -7,7 +7,7 @@ type X<X> = X
 export interface CommanderResolved<RT, RTHooks>
   extends
     X<typeof CommanderStatic>,
-    Pick<CommanderImpl<RT, RTHooks>, "fn" | "wrap" | "wrapStream" | "streamFn" | "alt" | "alt2">
+    Pick<CommanderImpl<RT, RTHooks>, "fn" | "wrap" | "streamWrap" | "streamFn" | "alt" | "alt2">
 {
 }
 

package/src/mutate.ts

@@ -414,13 +414,12 @@ export const useMakeMutation = () => {
 }
 
 /**
- * Like `makeStreamMutation`, but returns an `Effect<Stream>` per invocation instead of a
- * `[ref, execute]` tuple. The outer Effect sets up per-invocation invalidation scaffolding
+ * Returns a stream-based mutation factory for use with `streamFn`.
+ * The outer Effect sets up per-invocation invalidation scaffolding
  * and returns a stream that triggers query invalidation via `Stream.ensuring` when it completes.
  *
- * Use this with `streamFn` / `Command.streamFn(id)(mutateHandler, ...combinators)` so that
- * the command manages its own reactive state internally. Unlike `makeStreamMutation`, no external
- * reactive result ref is created.
+ * Use with `streamFn` / `Command.streamFn(id)(mutateHandler, ...combinators)` so that
+ * the command manages its own reactive state internally.
  *
  * Must be called inside a Vue setup context (uses `useQueryClient` internally).
  */
@@ -463,78 +462,3 @@ export const makeStreamMutation2 = () => {
     return act
   }
 }
-
-export const makeStreamMutation = () => {
-  const queryClient = useQueryClient()
-
-  return (
-    self: {
-      id: string
-      options?: ClientForOptions
-      handler: Stream.Stream<any, any, any> | ((i: any) => Stream.Stream<any, any, any>)
-    },
-    mergedInvalidation?: MutationOptionsBase["queryInvalidation"]
-  ) => {
-    const state = shallowRef<AsyncResult.AsyncResult<any, any>>(AsyncResult.initial())
-
-    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
-      // invalidation immediately rather than waiting for stream completion.
-      const invKeys = makeInvalidationKeysService(keysRef, (key) => invCache(input, Exit.succeed(undefined), [key]))
-      return Effect
-        .sync(() => {
-          state.value = AsyncResult.initial(true)
-        })
-        .pipe(
-          Effect.andThen(
-            stream.pipe(
-              Stream.provideService(InvalidationKeysFromServer, invKeys),
-              Stream.runForEach((value) =>
-                Effect.sync(() => {
-                  state.value = AsyncResult.success(value, { waiting: true })
-                })
-              ),
-              Effect.exit,
-              Effect.tap((exit) =>
-                Effect.sync(() => {
-                  if (exit._tag === "Success") {
-                    const current = state.value
-                    if (AsyncResult.isSuccess(current)) {
-                      state.value = AsyncResult.success(current.value, { waiting: false })
-                    } else {
-                      state.value = AsyncResult.initial(false)
-                    }
-                  } else {
-                    state.value = AsyncResult.failure(exit.cause)
-                  }
-                })
-              ),
-              Effect.flatMap((exit) => {
-                const current = state.value
-                const lastValue = AsyncResult.isSuccess(current) ? current.value : undefined
-                const invExit = exit._tag === "Success" ? Exit.succeed(lastValue) : exit
-                const serverKeys = Ref.getUnsafe(keysRef)
-                // 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)
-                  )
-                )
-              })
-            )
-          )
-        )
-    }
-
-    const handler = self.handler
-    const act = Stream.isStream(handler)
-      ? runStream(handler)
-      : (i: any) => runStream((handler as (i: any) => Stream.Stream<any, any, any>)(i), i)
-
-    return tuple(computed(() => state.value), act)
-  }
-}

package/src/withToast.ts

@@ -1,6 +1,6 @@
-import { Cause, Context, Effect, Layer, type Option } from "effect-app"
+import { Cause, Context, Effect, Fiber, Layer, type Option } from "effect-app"
 import { wrapEffect } from "effect-app/utils"
-import { CurrentToastId, Toast } from "./toast.js"
+import { CurrentToastId, Toast, type ToastId } from "./toast.js"
 
 export interface ToastOptions<A, E, Args extends ReadonlyArray<unknown>, WaiR, SucR, ErrR> {
   stableToastId?: undefined | string | ((...args: Args) => string | undefined)
@@ -48,12 +48,20 @@ export class WithToast extends Context.Service<WithToast>()("WithToast", {
           : options.stableToastId
 
         const t = yield* wrapEffect(options.onWaiting)(...args)
-        const toastId = t === null ? stableToastId : yield* toast.info(
-          t,
-          { id: stableToastId ?? null } // TODO: timeout forever?
+        const toastId: ToastId | undefined = t === null
+          ? stableToastId
+          : stableToastId ?? `wait-${Math.random().toString(36).slice(2)}`
+
+        const waitingFiber = t === null ? undefined : yield* Effect.forkChild(
+          Effect.sleep("1 seconds").pipe(
+            Effect.andThen(toast.info(t, { id: toastId!, timeout: Infinity }))
+          )
         )
+        const interruptWaiting = waitingFiber ? Fiber.interrupt(waitingFiber) : Effect.void
+
         return yield* self.pipe(
           Effect.tap(Effect.fnUntraced(function*(a) {
+            yield* interruptWaiting
             const t = yield* wrapEffect(options.onSuccess)(a, ...args)
             if (t === null) {
               return
@@ -64,6 +72,7 @@ export class WithToast extends Context.Service<WithToast>()("WithToast", {
             )
           })),
           Effect.tapCause(Effect.fnUntraced(function*(cause) {
+            yield* interruptWaiting
             yield* Effect.logDebug(
               "WithToast - caught error cause: " + Cause.squash(cause),
               Cause.hasInterruptsOnly(cause),

package/test/Mutation.test.ts

@@ -1,7 +1,6 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 import { it } from "@effect/vitest"
 import { Cause, Effect, Exit, Fiber, Option } from "effect-app"
-import { OperationFailure } from "effect-app/Operations"
 import { CommandContext, DefaultIntl } from "../src/commander.js"
 import { AsyncResult } from "../src/lib.js"
 import { useExperimental } from "./stubs.js"
@@ -425,31 +424,6 @@ it.live("fail with showSpanInfo disabled", () =>
       expect(toasts.length).toBe(1)
       expect(toasts[0].message).toBe("Test Action Failed:\nBoom!")
     }))
-
-it.live("fail with custom errorRenderer uses warning toast", () =>
-  Effect
-    .gen(function*() {
-      const toasts: any[] = []
-      const Command = useExperimental({ toasts, messages: DefaultIntl.en })
-
-      const command = Command.fn("Test Action")(
-        function*() {
-          return yield* Effect.fail(OperationFailure.make({ message: null }))
-        },
-        Command.withDefaultToast({
-          errorRenderer: () => "Rendered Boom!"
-        })
-      )
-
-      yield* Fiber.join(command.handle())
-
-      expect(toasts.length).toBe(1)
-      expect(toasts[0].type).toBe("warning")
-      expect(toasts[0].message).toContain("Test Action, with warnings\nRendered Boom!")
-      expect(toasts[0].message).toMatch(/Trace: [a-f0-9]{32}/)
-      expect(toasts[0].message).toMatch(/Span: [a-f0-9]{16}/)
-    }))
-
 it.live("fail and recover", () =>
   Effect
     .gen(function*() {