@effect-app/vue 2.15.1 → 2.16.0

package/src/mutate.ts

@@ -102,7 +102,8 @@ type MaybeRefDeep<T> = MaybeRef<
     : T
 >
 
-export interface MutationOptions {
+export interface MutationOptions<A, E, R, A2 = A, E2 = E, R2 = R, I = void> {
+  mapHandler?: (handler: Effect<A, E, R>, input: I) => Effect<A2, E2, R2>
   queryInvalidation?: (defaultKey: string[], name: string) => {
     filters?: MaybeRefDeep<InvalidateQueryFilters> | undefined
     options?: MaybeRefDeep<InvalidateOptions> | undefined
@@ -126,33 +127,33 @@ export const makeMutation = () => {
    * Returns a tuple with state ref and execution function which reports errors as Toast.
    */
   const useSafeMutation: {
-    <I, E, A, R, Request extends TaggedRequestClassAny>(
+    <I, E, A, R, Request extends TaggedRequestClassAny, A2 = A, E2 = E, R2 = R>(
       self: RequestHandlerWithInput<I, A, E, R, Request>,
-      options?: MutationOptions
+      options?: MutationOptions<A, E, R, A2, E2, R2, I>
     ): readonly [
-      Readonly<Ref<MutationResult<A, E>>>,
-      (i: I) => Effect<A, E, R>
+      Readonly<Ref<MutationResult<A2, E2>>>,
+      (i: I) => Effect<A2, E2, R2>
     ]
-    <E, A, R, Request extends TaggedRequestClassAny>(
+    <E, A, R, Request extends TaggedRequestClassAny, A2 = A, E2 = E, R2 = R>(
       self: RequestHandler<A, E, R, Request>,
-      options?: MutationOptions
+      options?: MutationOptions<A, E, R, A2, E2, R2>
     ): readonly [
-      Readonly<Ref<MutationResult<A, E>>>,
-      Effect<A, E, R>
+      Readonly<Ref<MutationResult<A2, E2>>>,
+      Effect<A2, E2, R2>
     ]
-  } = <I, E, A, R, Request extends TaggedRequestClassAny>(
+  } = <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
+    options?: MutationOptions<A, E, R, A2, E2, R2, I>
   ) => {
     const queryClient = useQueryClient()
-    const state: Ref<MutationResult<A, E>> = ref<MutationResult<A, E>>({ _tag: "Initial" }) as any
+    const state: Ref<MutationResult<A2, E2>> = ref<MutationResult<A2, E2>>({ _tag: "Initial" }) as any
 
     const invalidateQueries = (
       filters?: MaybeRefDeep<InvalidateQueryFilters>,
       options?: MaybeRefDeep<InvalidateOptions>
     ) => Effect.promise(() => queryClient.invalidateQueries(filters, options))
 
-    function handleExit(exit: Exit.Exit<A, E>) {
+    function handleExit(exit: Exit.Exit<A2, E2>) {
       return Effect.sync(() => {
         if (Exit.isSuccess(exit)) {
           state.value = { _tag: "Success", data: exit.value }
@@ -193,36 +194,30 @@ export const makeMutation = () => {
         .pipe(Effect.withSpan("client.query.invalidation", { captureStackTrace: false }))
     })
 
+    const mapHandler = options?.mapHandler ?? ((_) => _)
+
+    const handle = (self: Effect<A, E, R>, name: string, i: I | void = void 0) =>
+      Effect
+        .sync(() => {
+          state.value = { _tag: "Loading" }
+        })
+        .pipe(
+          Effect.zipRight(
+            mapHandler(
+              Effect.tapBoth(self, { onFailure: () => invalidateCache, onSuccess: () => invalidateCache }),
+              i as I
+            ) as Effect<A2, E2, R2>
+          ),
+          Effect.tapDefect(reportRuntimeError),
+          Effect.onExit(handleExit),
+          Effect.withSpan(`mutation ${name}`, { captureStackTrace: false })
+        )
+
     const handler = self.handler
-    const r = Effect.isEffect(handler)
-      ? tuple(
-        state,
-        Effect
-          .sync(() => {
-            state.value = { _tag: "Loading" }
-          })
-          .pipe(
-            Effect.zipRight(handler),
-            Effect.tap(invalidateCache),
-            Effect.tapDefect(reportRuntimeError),
-            Effect.onExit(handleExit),
-            Effect.withSpan(`mutation ${self.name}`, { captureStackTrace: false })
-          )
-      )
-      : tuple(state, (fst: I) => {
-        const effect = handler(fst)
-        return Effect
-          .sync(() => {
-            state.value = { _tag: "Loading" }
-          })
-          .pipe(
-            Effect.zipRight(effect),
-            Effect.tapBoth({ onFailure: () => invalidateCache, onSuccess: () => invalidateCache }),
-            Effect.tapDefect(reportRuntimeError),
-            Effect.onExit(handleExit),
-            Effect.withSpan(`mutation ${self.name}`, { captureStackTrace: false })
-          )
-      })
+    const r = tuple(
+      state,
+      Effect.isEffect(handler) ? handle(handler, self.name) : (i: I) => handle(handler(i), self.name, i)
+    )
 
     return r as any
   }

package/src/query.ts

@@ -12,7 +12,7 @@ import type {
   UseQueryReturnType
 } from "@tanstack/vue-query"
 import { useQuery } from "@tanstack/vue-query"
-import { Cause, Effect, Option, Runtime, S } from "effect-app"
+import { Array, Cause, Effect, Option, Runtime, S } from "effect-app"
 import { ServiceUnavailableError } from "effect-app/client"
 import type { RequestHandler, RequestHandlerWithInput, TaggedRequestClassAny } from "effect-app/client/clientFor"
 import { isHttpRequestError, isHttpResponseError } from "effect-app/http/http-client"
@@ -203,3 +203,49 @@ export const makeQuery = <R>(runtime: ShallowRef<Runtime.Runtime<R> | undefined>
 
 // eslint-disable-next-line @typescript-eslint/no-empty-object-type
 export interface MakeQuery2<R> extends ReturnType<typeof makeQuery<R>> {}
+
+function orPrevious<E, A>(result: Result.Result<A, E>) {
+  return Result.isFailure(result) && Option.isSome(result.previousValue)
+    ? Result.success(result.previousValue.value, result.waiting)
+    : result
+}
+
+export function composeQueries<
+  R extends Record<string, Result.Result<any, any>>
+>(
+  results: R,
+  renderPreviousOnFailure?: boolean
+): Result.Result<
+  {
+    [Property in keyof R]: R[Property] extends Result.Result<infer A, any> ? A
+      : never
+  },
+  {
+    [Property in keyof R]: R[Property] extends Result.Result<any, infer E> ? E
+      : never
+  }[keyof R]
+> {
+  const values = renderPreviousOnFailure
+    ? Object.values(results).map(orPrevious)
+    : Object.values(results)
+  const error = values.find(Result.isFailure)
+  if (error) {
+    return error
+  }
+  const initial = Array.findFirst(values, (x) => x._tag === "Initial" ? Option.some(x) : Option.none())
+  if (initial.value !== undefined) {
+    return initial.value
+  }
+  const loading = Array.findFirst(values, (x) => Result.isInitial(x) && x.waiting ? Option.some(x) : Option.none())
+  if (loading.value !== undefined) {
+    return loading.value
+  }
+
+  const isRefreshing = values.some((x) => x.waiting)
+
+  const r = Object.entries(results).reduce((prev, [key, value]) => {
+    prev[key] = Result.value(value).value
+    return prev
+  }, {} as any)
+  return Result.success(r, isRefreshing)
+}