@effect-app/vue 2.32.0 → 2.34.0

package/src/mutate.ts

@@ -2,13 +2,13 @@
 import * as Result from "@effect-rx/rx/Result"
 import type { InvalidateOptions, InvalidateQueryFilters } from "@tanstack/vue-query"
 import { useQueryClient } from "@tanstack/vue-query"
-import type { Cause } from "effect-app"
+import type { Cause, Exit } from "effect-app"
 import { Effect, Option } from "effect-app"
 import type { RequestHandler, RequestHandlerWithInput, TaggedRequestClassAny } from "effect-app/client/clientFor"
 import { tuple } from "effect-app/Function"
 import type { ComputedRef, Ref } from "vue"
 import { computed, shallowRef } from "vue"
-import { makeQueryKey, reportRuntimeError } from "./lib.js"
+import { makeQueryKey } from "./lib.js"
 
 export const getQueryKey = (h: { name: string }) => {
   const key = makeQueryKey(h)
@@ -70,15 +70,6 @@ export function make<A, E, R>(self: Effect<A, E, R>) {
   return tuple(result, latestSuccess, execute)
 }
 
-export type MaybeRef<T> = Ref<T> | ComputedRef<T> | T
-type MaybeRefDeep<T> = MaybeRef<
-  // eslint-disable-next-line @typescript-eslint/no-unsafe-function-type
-  T extends Function ? T
-    : T extends object ? {
-        [Property in keyof T]: MaybeRefDeep<T[Property]>
-      }
-    : T
->
 
 export interface MutationOptions<A, E, R, A2 = A, E2 = E, R2 = R, I = void> {
   /**
@@ -91,8 +82,8 @@ export interface MutationOptions<A, E, R, A2 = A, E2 = E, R2 = R, I = void> {
    * This can be overridden by providing a function that returns an array of filters and options.
    */
   queryInvalidation?: (defaultKey: string[], name: string) => {
-    filters?: MaybeRefDeep<InvalidateQueryFilters> | undefined
-    options?: MaybeRefDeep<InvalidateOptions> | undefined
+    filters?: InvalidateQueryFilters | undefined
+    options?: InvalidateOptions | undefined
   }[]
 }
 
@@ -107,22 +98,46 @@ export interface MutationOptions<A, E, R, A2 = A, E2 = E, R2 = R, I = void> {
                 // }
                 */
 
-export const asResult = <Args extends readonly any[], A, E, R>(
-  handler: (...args: Args) => Effect<A, E, R>
+export const asResult: {
+  <A, E, R>(
+    handler: Effect<A, E, R>
+  ): readonly [ComputedRef<Result.Result<A, E>>, Effect<Exit<A, E>, never, void>]
+  <Args extends readonly any[], A, E, R>(
+    handler: (...args: Args) => Effect<A, E, R>
+  ): readonly [ComputedRef<Result.Result<A, E>>, (...args: Args) => Effect<Exit<A, E>, never, void>]
+} = <Args extends readonly any[], A, E, R>(
+  handler: Effect<A, E, R> | ((...args: Args) => Effect<A, E, R>)
 ) => {
   const state = shallowRef<Result.Result<A, E>>(Result.initial())
 
-  const act = (...args: Args) =>
-    Effect
+  const act = Effect.isEffect(handler)
+    ? Effect
       .sync(() => {
         state.value = Result.initial(true)
       })
       .pipe(
-        Effect.zipRight(Effect.suspend(() => handler(...args))),
-        Effect.onExit((exit) => Effect.sync(() => (state.value = Result.fromExit(exit))))
+        Effect.zipRight(Effect.suspend(() =>
+          handler.pipe(
+            Effect.exit,
+            Effect.tap((exit) => Effect.sync(() => (state.value = Result.fromExit(exit))))
+          )
+        ))
       )
+    : (...args: Args) =>
+      Effect
+        .sync(() => {
+          state.value = Result.initial(true)
+        })
+        .pipe(
+          Effect.zipRight(Effect.suspend(() =>
+            handler(...args).pipe(
+              Effect.exit,
+              Effect.tap((exit) => Effect.sync(() => (state.value = Result.fromExit(exit))))
+            )
+          ))
+        )
 
-  return tuple(state, act)
+  return tuple(computed(() => state.value), act) as any
 }
 
 export const makeMutation = () => {
@@ -130,21 +145,15 @@ export const makeMutation = () => {
    * Pass a function that returns an Effect, e.g from a client action, or an Effect
    * Returns a tuple with state ref and execution function which reports errors as Toast.
    */
-  const useSafeMutation: {
+  const useMutation: {
     <I, E, A, R, Request extends TaggedRequestClassAny, A2 = A, E2 = E, R2 = R>(
       self: RequestHandlerWithInput<I, A, E, R, Request>,
       options?: MutationOptions<A, E, R, A2, E2, R2, I>
-    ): readonly [
-      Readonly<Ref<Result.Result<A2, E2>>>,
-      (i: I) => Effect<A2, E2, R2>
-    ]
+    ): (i: I) => Effect<A2, E2, R2>
     <E, A, R, Request extends TaggedRequestClassAny, A2 = A, E2 = E, R2 = R>(
       self: RequestHandler<A, E, R, Request>,
       options?: MutationOptions<A, E, R, A2, E2, R2>
-    ): readonly [
-      Readonly<Ref<Result.Result<A2, E2>>>,
-      Effect<A2, E2, R2>
-    ]
+    ): Effect<A2, E2, R2>
   } = <I, E, A, R, Request extends TaggedRequestClassAny, A2 = A, E2 = E, R2 = R>(
     self: RequestHandlerWithInput<I, A, E, R, Request> | RequestHandler<A, E, R, Request>,
     options?: MutationOptions<A, E, R, A2, E2, R2, I>
@@ -152,8 +161,8 @@ export const makeMutation = () => {
     const queryClient = useQueryClient()
 
     const invalidateQueries = (
-      filters?: MaybeRefDeep<InvalidateQueryFilters>,
-      options?: MaybeRefDeep<InvalidateOptions>
+      filters?: InvalidateQueryFilters,
+      options?: InvalidateOptions
     ) => Effect.promise(() => queryClient.invalidateQueries(filters, options))
 
     const invalidateCache = Effect.suspend(() => {
@@ -184,26 +193,17 @@ export const makeMutation = () => {
 
     const mapHandler = options?.mapHandler ?? ((_) => _)
 
-    const [state, handle_] = asResult((self: Effect<A, E, R>, i: I | void = void 0) => (mapHandler(
+    const handle = (self: Effect<A, E, R>, i: I | void = void 0) => (mapHandler(
       Effect.tapBoth(self, { onFailure: () => invalidateCache, onSuccess: () => invalidateCache }),
       i as I
-    ) as Effect<A2, E2, R2>))
-
-    const handle = (self: Effect<A, E, R>, name: string, i: I | void = void 0) =>
-      handle_(self, i).pipe(
-        Effect.tapDefect(reportRuntimeError),
-        Effect.withSpan(`mutation ${name}`, { captureStackTrace: false })
-      )
+    ) as Effect<A2, E2, R2>)
 
     const handler = self.handler
-    const r = tuple(
-      state,
-      Effect.isEffect(handler) ? handle(handler, self.name) : (i: I) => handle(handler(i), self.name, i)
-    )
+    const r = Effect.isEffect(handler) ? handle(handler) : (i: I) => handle(handler(i), i)
 
     return r as any
   }
-  return useSafeMutation
+  return useMutation
 }
 
 // eslint-disable-next-line @typescript-eslint/no-empty-object-type