@effect-app/vue 4.0.0-beta.177 → 4.0.0-beta.179

package/dist/mutate.js

@@ -1,10 +1,11 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 import { matchQuery } from "@tanstack/query-core";
 import { useQueryClient } from "@tanstack/vue-query";
-import { Effect, Option } from "effect-app";
+import { Effect, Exit, Option } from "effect-app";
 import { InvalidationKeysFromServer, makeInvalidationKeysService, makeQueryKey } from "effect-app/client";
 import { tuple } from "effect-app/Function";
 import * as Ref from "effect/Ref";
+import * as Stream from "effect/Stream";
 import * as AsyncResult from "effect/unstable/reactivity/AsyncResult";
 import { computed, shallowRef } from "vue";
 export const getQueryKey = (h) => {
@@ -63,12 +64,44 @@ export const asResult = (handler) => {
             .pipe(Effect.andThen(Effect.suspend(() => handler(...args).pipe(Effect.exit, Effect.tap((exit) => Effect.sync(() => (state.value = AsyncResult.fromExit(exit))))))));
     return tuple(computed(() => state.value), act);
 };
-export const invalidateQueries = (queryClient, self, options) => {
-    const invalidateQueries = (filters, options) => Effect.currentSpan.pipe(Effect.orElseSucceed(() => null), Effect.flatMap((span) => Effect.promise(() => queryClient.invalidateQueries(filters, { ...options, updateMeta: { span } }))));
+/**
+ * Like `asResult`, but for streams. The ref is updated with each emitted value
+ * (keeping `waiting: true`) and is finalised (with `waiting: false`) once the
+ * stream terminates successfully. Errors are surfaced as `AsyncResult.failure`.
+ */
+export const asStreamResult = (handler) => {
+    const state = shallowRef(AsyncResult.initial());
+    const runStream = (stream) => Effect
+        .sync(() => {
+        state.value = AsyncResult.initial(true);
+    })
+        .pipe(Effect.andThen(stream.pipe(Stream.runForEach((value) => Effect.sync(() => {
+        state.value = AsyncResult.success(value, { waiting: true });
+    })), Effect.exit, Effect.flatMap((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);
+        }
+    })))));
+    const act = Stream.isStream(handler)
+        ? runStream(handler)
+        : (...args) => runStream(handler(...args));
+    return tuple(computed(() => state.value), act);
+};
+const buildInvalidateCache = (queryClient, self, queryInvalidation) => {
+    const invalidateQueriesFn = (filters, options) => Effect.currentSpan.pipe(Effect.orElseSucceed(() => null), Effect.flatMap((span) => Effect.promise(() => queryClient.invalidateQueries(filters, { ...options, updateMeta: { span } }))));
     const getClientInvalidationTargets = (input, output) => {
         const queryKey = getQueryKey(self);
-        if (options?.queryInvalidation) {
-            return options.queryInvalidation(queryKey, self.id, input, output).map((_) => ({
+        if (queryInvalidation) {
+            return queryInvalidation(queryKey, self.id, input, output).map((_) => ({
                 filters: _.filters,
                 options: _.options
             }));
@@ -99,7 +132,7 @@ export const invalidateQueries = (queryClient, self, options) => {
             }
         }
         return Effect
-            .andThen(Effect.annotateCurrentSpan({ clientTargets, serverKeys }), Effect.forEach(groups.values(), ({ options, refetchType, targets }) => invalidateQueries({
+            .andThen(Effect.annotateCurrentSpan({ clientTargets, serverKeys }), Effect.forEach(groups.values(), ({ options, refetchType, targets }) => invalidateQueriesFn({
             ...(refetchType !== undefined ? { refetchType } : {}),
             predicate: (query) => targets.some((t) => t.filters ? matchQuery(t.filters, query) : true)
         }, options), { discard: true, concurrency: "inherit" }))
@@ -108,6 +141,10 @@ export const invalidateQueries = (queryClient, self, options) => {
         // TODO: should we do this in general on any mutation, regardless of invalidation?
         Effect.sleep(0)), Effect.withSpan("client.query.invalidation", {}, { captureStackTrace: false }));
     });
+    return invalidateCache;
+};
+export const invalidateQueries = (queryClient, self, options) => {
+    const invalidateCache = buildInvalidateCache(queryClient, self, options?.queryInvalidation);
     const select = options?.select;
     const handle = (eff, input) => Effect.gen(function* () {
         const keysRef = yield* Ref.make([]);
@@ -148,4 +185,58 @@ export const useMakeMutation = () => {
     };
     return useMutation;
 };
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"mutate.js","sourceRoot":"","sources":["../src/mutate.ts"],"names":[],"mappings":"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"}
+/**
+ * Like `makeMutation`, but for stream-type request handlers.
+ * Returns a `[ref, execute]` tuple where `ref` is a reactive `AsyncResult` updated per
+ * stream element. Queries are invalidated once when the stream finishes, regardless of
+ * success or failure.
+ *
+ * When the request declares a `final` schema, `execute` resolves with the last emitted value
+ * typed as `Final`; otherwise it resolves with `void`.
+ *
+ * Must be called inside a Vue setup context (uses `useQueryClient` internally).
+ */
+export const makeStreamMutation = () => {
+    const queryClient = useQueryClient();
+    return (self, mergedInvalidation) => {
+        const state = shallowRef(AsyncResult.initial());
+        const runStream = (stream, input) => {
+            const invCache = buildInvalidateCache(queryClient, self, mergedInvalidation);
+            return Effect
+                .sync(() => {
+                state.value = AsyncResult.initial(true);
+            })
+                .pipe(Effect.andThen(stream.pipe(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;
+                // 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, []).pipe(Effect.as(lastValue));
+            }))));
+        };
+        const handler = self.handler;
+        const act = Stream.isStream(handler)
+            ? runStream(handler)
+            : (i) => runStream(handler(i), i);
+        return tuple(computed(() => state.value), act);
+    };
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"mutate.js","sourceRoot":"","sources":["../src/mutate.ts"],"names":[],"mappings":"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"}

package/examples/streamMutation.ts

@@ -0,0 +1,83 @@
+/**
+ * Example: stream-based mutation for a long-running operation.
+ *
+ * The server streams a tagged union of progress updates and a final result.
+ * The Vue ref is updated for every emitted value; `AsyncResult` stays in the
+ * `waiting` state until the stream ends.
+ *
+ * When using `makeClient` / `clientFor`, stream-type requests are exposed as
+ * `mutateStream` on the client object (and as `XxxStream` in `.helpers`).
+ * The example below shows both the low-level `asStreamResult` API and how the
+ * same functionality appears on the generated client.
+ */
+import { Effect, S, Stream } from "effect-app"
+import { asStreamResult } from "../src/mutate.js"
+
+// ---------------------------------------------------------------------------
+// Domain model
+// ---------------------------------------------------------------------------
+
+/** Intermediate progress report, e.g. "5 of 400 items processed". */
+export class OperationProgress extends S.TaggedClass<OperationProgress>()("OperationProgress", {
+  completed: S.NonNegativeInt,
+  total: S.NonNegativeInt
+}) {}
+
+/** The final result produced once the operation is complete. */
+export class ExportComplete extends S.TaggedClass<ExportComplete>()("ExportComplete", {
+  fileUrl: S.NonEmptyString
+}) {}
+
+/** Tagged union emitted by the stream. */
+export type ExportEvent = OperationProgress | ExportComplete
+
+// ---------------------------------------------------------------------------
+// Simulated stream (replace with a real RPC / SSE stream in production)
+// ---------------------------------------------------------------------------
+
+/**
+ * Produces `total` progress updates followed by a single `ExportComplete`.
+ * Each step is separated by a 50 ms delay to simulate real async work.
+ */
+const makeExportStream = (total: S.NonNegativeInt): Stream.Stream<ExportEvent> =>
+  Stream.concat(
+    Stream.range(1, total).pipe(
+      Stream.map((completed) => new OperationProgress({ completed: S.NonNegativeInt(completed), total })),
+      Stream.tap(() => Effect.sleep("50 millis"))
+    ),
+    Stream.make(new ExportComplete({ fileUrl: S.NonEmptyString("https://example.com/export.csv") }))
+  )
+
+// ---------------------------------------------------------------------------
+// Option A: low-level `asStreamResult` (call inside a `setup()` function)
+// ---------------------------------------------------------------------------
+
+export const useExportMutation = () => {
+  /**
+   * `result`   - reactive ref, always reflects the latest stream event.
+   *              `AsyncResult` tag:
+   *                - Initial (waiting=true)  - operation in progress
+   *                - Success (waiting=true)  - progress update received, still running
+   *                - Success (waiting=false) - final result, operation complete
+   *                - Failure                 - operation failed
+   *
+   * `execute`  - call with the desired `total` to kick off the stream.
+   */
+  const [result, execute] = asStreamResult((total: S.NonNegativeInt) => makeExportStream(total))
+
+  return { result, execute }
+}
+
+// ---------------------------------------------------------------------------
+// Option B: via `makeClient` / `clientFor` (stream requests -> `mutateStream`)
+//
+// When a request schema has `type: "stream"`, `clientFor` exposes:
+//
+//   client.exportData.mutateStream
+//   // -> [ComputedRef<AsyncResult<ExportEvent, E>>, (input: I) => Effect<void, never, R>]
+//
+// which is equivalent to calling `asStreamResult(client.exportData.handler)`.
+//
+// The `.helpers` object also includes `exportDataStream` (the camelCase key
+// plus "Stream" suffix) with the same [ref, execute] tuple.
+// ---------------------------------------------------------------------------

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@effect-app/vue",
-  "version": "4.0.0-beta.177",
+  "version": "4.0.0-beta.179",
   "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.177"
+    "effect-app": "4.0.0-beta.179"
   },
   "peerDependencies": {
     "@effect/atom-vue": "^4.0.0-beta.59",

package/src/makeClient.ts

@@ -3,7 +3,7 @@ import { type InvalidateOptions, type InvalidateQueryFilters, isCancelledError,
 import { camelCase } from "change-case"
 import { type Context, Effect, Exit, Hash, type Layer, type ManagedRuntime, S, Struct } from "effect-app"
 import { type ApiClientFactory, type Req } from "effect-app/client"
-import type { ExtractModuleName, RequestHandler, RequestHandlers, RequestHandlerWithInput, RequestInputFromMake, RequestsAny } from "effect-app/client/clientFor"
+import type { ExtractModuleName, RequestHandler, RequestHandlers, RequestHandlerWithInput, RequestInputFromMake, RequestsAny, RequestStreamHandler, RequestStreamHandlerWithInput } from "effect-app/client/clientFor"
 import type { InvalidationCallback } from "effect-app/client/makeClient"
 import type * as ExitResult from "effect/Exit"
 import { type Fiber } from "effect/Fiber"
@@ -12,7 +12,7 @@ import { type ComputedRef, onBeforeUnmount, ref, type WatchSource } from "vue"
 import { type Commander, CommanderStatic } from "./commander.js"
 import { type I18n } from "./intl.js"
 import { type CommanderResolved, makeUseCommand } from "./makeUseCommand.js"
-import { makeMutation, type MutationOptionsBase, useMakeMutation } from "./mutate.js"
+import { makeMutation, makeStreamMutation, type MutationOptionsBase, useMakeMutation } from "./mutate.js"
 import { type CustomUndefinedInitialQueryOptions, makeQuery } from "./query.js"
 import { makeRunPromise } from "./runtime.js"
 import { type Toast } from "./toast.js"
@@ -125,6 +125,13 @@ type CommandHandler<Req> = Req extends
     ? Request["type"] extends "command" ? RequestHandler<A, E, R, Request, Id> : never
   : never
 
+type StreamHandler<Req> = Req extends
+  RequestStreamHandlerWithInput<infer I, infer A, infer E, infer R, infer Request, infer Id, infer Final>
+  ? Request["type"] extends "stream" ? RequestStreamHandlerWithInput<I, A, E, R, Request, Id, Final> : never
+  : Req extends RequestStreamHandler<infer A, infer E, infer R, infer Request, infer Id, infer Final>
+    ? Request["type"] extends "stream" ? RequestStreamHandler<A, E, R, Request, Id, Final> : never
+  : never
+
 export interface MutationExtensions<RT, Id extends string, I, A, E, R> {
   /** Defines a Command based on this mutation, taking the `id` of the mutation as the `id` of the Command.
    * The Mutation function will be taken as the first member of the Command, the Command required input will be the Mutation input.
@@ -217,6 +224,19 @@ export type MutationWithExtensions<RT, Req> = Req extends
     ? MutationExt<RT, Id, A, E, R, S.Codec.Encoded<Request["success"]>>
   : never
 
+/**
+ * The `mutateStream` tuple for a stream-type request handler:
+ * `[resultRef, execute]` where `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 `void`.
+ */
+export type StreamMutationWithExtensions<Req> = Req extends
+  RequestStreamHandlerWithInput<infer I, infer A, infer E, infer R, infer _Request, infer _Id, infer Final>
+  ? readonly [ComputedRef<AsyncResult.AsyncResult<A, E>>, (input: I) => Effect.Effect<Final, never, R>]
+  : Req extends RequestStreamHandler<infer A, infer E, infer R, infer _Request, infer _Id, infer Final>
+    ? readonly [ComputedRef<AsyncResult.AsyncResult<A, E>>, Effect.Effect<Final, never, R>]
+  : never
+
 // we don't really care about the RT, as we are in charge of ensuring runtime safety anyway
 // eslint-disable-next-line unused-imports/no-unused-vars
 declare const useQuery_: QueryImpl<any>["useQuery"]
@@ -571,6 +591,9 @@ export const makeClient = <RT_, RTHooks>(
   let m: ReturnType<typeof useMutationInt>
   const useMutation = () => m ??= useMutationInt()
 
+  let sm: ReturnType<typeof makeStreamMutation>
+  const useStreamMutation = () => sm ??= makeStreamMutation()
+
   const query = new QueryImpl(getBaseRt)
   const useQuery = query.useQuery
   const useSuspenseQuery = query.useSuspenseQuery
@@ -739,6 +762,43 @@ 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 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])
+        ;(acc as any)[camelCase(key) + "Stream"] = streamMutation(client[key] as any, mergedInvalidation)
+        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]>>
+      }
+    )
+    return streams
+  }
+
   // make available .query, .suspense and .mutate for each operation
   // and a .helpers with all mutations and queries
   const mapClient = <M extends RequestsAny>(
@@ -750,6 +810,7 @@ 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(
@@ -786,6 +847,27 @@ export const makeClient = <RT_, RTHooks>(
                 }
               }
             }
+            : requestType === "stream"
+            ? (() => {
+              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])
+              return {
+                ...client[key],
+                request: h_,
+                mutateStream: streamMutation(client[key] as any, mergedInvalidation)
+              }
+            })()
             : {
               mutate: ((handler: any) => {
                 const fromRequestConfig = client[key].Request.config?.["invalidatesQueries"] as
@@ -844,6 +926,8 @@ export const makeClient = <RT_, RTHooks>(
             : CommandRequestWithExtensions<RT | RTHooks, CommandHandler<typeof client[Key]>>)
           & (CommandHandler<typeof client[Key]> extends never ? {}
             : { mutate: MutationWithExtensions<RT | RTHooks, CommandHandler<typeof client[Key]>> })
+          & (StreamHandler<typeof client[Key]> extends never ? {}
+            : { mutateStream: StreamMutationWithExtensions<StreamHandler<typeof client[Key]>> })
           & { Input: typeof client[Key] extends RequestHandlerWithInput<infer I, any, any, any, any, any> ? I : never }
       }
     )
@@ -851,6 +935,7 @@ export const makeClient = <RT_, RTHooks>(
       helpers: {
         ...mapRequest(client),
         ...mapMutation(client, queryInvalidation, invalidationResources),
+        ...mapStreamMutation(client, queryInvalidation, invalidationResources),
         ...mapQuery(client)
       }
     })

package/src/mutate.ts

@@ -1,11 +1,12 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 import { matchQuery } from "@tanstack/query-core"
 import { type InvalidateOptions, type InvalidateQueryFilters, type QueryClient, useQueryClient } from "@tanstack/vue-query"
-import { type Cause, Effect, type Exit, Option } from "effect-app"
+import { type Cause, Effect, Exit, Option } from "effect-app"
 import { type InvalidationKey, InvalidationKeysFromServer, makeInvalidationKeysService, makeQueryKey, type Req } from "effect-app/client"
 import type { ClientForOptions, RequestHandler, RequestHandlerWithInput } from "effect-app/client/clientFor"
 import { tuple } from "effect-app/Function"
 import * as Ref from "effect/Ref"
+import * as Stream from "effect/Stream"
 import * as AsyncResult from "effect/unstable/reactivity/AsyncResult"
 import { computed, type ComputedRef, shallowRef } from "vue"
 
@@ -137,17 +138,73 @@ export const asResult: {
   return tuple(computed(() => state.value), act) as any
 }
 
-export const invalidateQueries = (
+/**
+ * Like `asResult`, but for streams. The ref is updated with each emitted value
+ * (keeping `waiting: true`) and is finalised (with `waiting: false`) once the
+ * stream terminates successfully. Errors are surfaced as `AsyncResult.failure`.
+ */
+export const asStreamResult: {
+  <A, E, R>(
+    handler: Stream.Stream<A, E, R>
+  ): readonly [ComputedRef<AsyncResult.AsyncResult<A, E>>, Effect.Effect<void, never, R>]
+  <Args extends readonly any[], A, E, R>(
+    handler: (...args: Args) => Stream.Stream<A, E, R>
+  ): readonly [ComputedRef<AsyncResult.AsyncResult<A, E>>, (...args: Args) => Effect.Effect<void, never, R>]
+} = <Args extends readonly any[], A, E, R>(
+  handler: Stream.Stream<A, E, R> | ((...args: Args) => Stream.Stream<A, E, R>)
+) => {
+  const state = shallowRef<AsyncResult.AsyncResult<A, E>>(AsyncResult.initial())
+
+  const runStream = (stream: Stream.Stream<A, E, R>): Effect.Effect<void, never, R> =>
+    Effect
+      .sync(() => {
+        state.value = AsyncResult.initial(true)
+      })
+      .pipe(
+        Effect.andThen(
+          stream.pipe(
+            Stream.runForEach((value) =>
+              Effect.sync(() => {
+                state.value = AsyncResult.success(value, { waiting: true })
+              })
+            ),
+            Effect.exit,
+            Effect.flatMap((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)
+                }
+              })
+            )
+          )
+        )
+      )
+
+  const act = Stream.isStream(handler)
+    ? runStream(handler)
+    : (...args: Args) => runStream(handler(...args))
+
+  return tuple(computed(() => state.value), act) as any
+}
+
+const buildInvalidateCache = (
   queryClient: QueryClient,
   self: { id: string; options?: ClientForOptions },
-  options?: MutationOptionsBase
+  queryInvalidation?: MutationOptionsBase["queryInvalidation"]
 ) => {
   type InvalidationTarget = {
     readonly filters: InvalidateQueryFilters | undefined
     readonly options: InvalidateOptions | undefined
   }
 
-  const invalidateQueries = (
+  const invalidateQueriesFn = (
     filters?: InvalidateQueryFilters,
     options?: InvalidateOptions
   ) =>
@@ -164,8 +221,8 @@ export const invalidateQueries = (
   ): ReadonlyArray<InvalidationTarget> => {
     const queryKey = getQueryKey(self)
 
-    if (options?.queryInvalidation) {
-      return options.queryInvalidation(queryKey, self.id, input, output).map((_) => ({
+    if (queryInvalidation) {
+      return queryInvalidation(queryKey, self.id, input, output).map((_) => ({
         filters: _.filters,
         options: _.options
       }))
@@ -219,7 +276,7 @@ export const invalidateQueries = (
           Effect.forEach(
             groups.values(),
             ({ options, refetchType, targets }) =>
-              invalidateQueries(
+              invalidateQueriesFn(
                 {
                   ...(refetchType !== undefined ? { refetchType } : {}),
                   predicate: (query) => targets.some((t) => t.filters ? matchQuery(t.filters, query) : true)
@@ -239,6 +296,16 @@ export const invalidateQueries = (
         )
     })
 
+  return invalidateCache
+}
+
+export const invalidateQueries = (
+  queryClient: QueryClient,
+  self: { id: string; options?: ClientForOptions },
+  options?: MutationOptionsBase
+) => {
+  const invalidateCache = buildInvalidateCache(queryClient, self, options?.queryInvalidation)
+
   const select = options?.select
 
   const handle = <A, E, R>(eff: Effect.Effect<A, E, R>, input?: unknown) =>
@@ -345,3 +412,80 @@ export const useMakeMutation = () => {
   }
   return useMutation
 }
+
+/**
+ * Like `makeMutation`, but for stream-type request handlers.
+ * Returns a `[ref, execute]` tuple where `ref` is a reactive `AsyncResult` updated per
+ * stream element. Queries are invalidated once when the stream finishes, regardless of
+ * success or failure.
+ *
+ * When the request declares a `final` schema, `execute` resolves with the last emitted value
+ * typed as `Final`; otherwise it resolves with `void`.
+ *
+ * Must be called inside a Vue setup context (uses `useQueryClient` internally).
+ */
+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, never, any> => {
+      const invCache = buildInvalidateCache(queryClient, self, mergedInvalidation)
+      return Effect
+        .sync(() => {
+          state.value = AsyncResult.initial(true)
+        })
+        .pipe(
+          Effect.andThen(
+            stream.pipe(
+              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
+                // 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, []).pipe(Effect.as(lastValue))
+              })
+            )
+          )
+        )
+    }
+
+    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/test/dist/streamFinal.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"streamFinal.test.d.ts","sourceRoot":"","sources":["../streamFinal.test.ts"],"names":[],"mappings":""}