@effect-app/vue 2.14.0 → 2.15.0

package/src/mutate.ts

@@ -2,14 +2,55 @@
 import * as Result from "@effect-rx/rx/Result"
 import type { InvalidateOptions, InvalidateQueryFilters } from "@tanstack/vue-query"
 import { useQueryClient } from "@tanstack/vue-query"
-import { Cause, Effect, Exit, Option, Runtime } from "effect-app"
+import { Cause, Effect, Exit, Option } from "effect-app"
+import type { RequestHandler, RequestHandlerWithInput, TaggedRequestClassAny } from "effect-app/client/clientFor"
 import { tuple } from "effect-app/Function"
-import { dropUndefinedT } from "effect-app/utils"
-import { InterruptedException } from "effect/Cause"
-import * as Either from "effect/Either"
-import type { ComputedRef, Ref, ShallowRef } from "vue"
+import type { ComputedRef, Ref } from "vue"
 import { computed, ref, shallowRef } from "vue"
-import { getRuntime, makeQueryKey, reportRuntimeError } from "./lib.js"
+import { makeQueryKey, reportRuntimeError } from "./lib.js"
+
+export const getQueryKey = (h: { name: string }) => {
+  const key = makeQueryKey(h)
+  const ns = key.filter((_) => _.startsWith("$"))
+  // we invalidate the parent namespace e.g $project/$configuration.get, we invalidate $project
+  // for $project/$configuration/$something.get, we invalidate $project/$configuration
+  const k = ns.length ? ns.length > 1 ? ns.slice(0, ns.length - 1) : ns : undefined
+  if (!k) throw new Error("empty query key for: " + h.name)
+  return k
+}
+
+export function mutationResultToVue<A, E>(
+  mutationResult: MutationResult<A, E>
+): Res<A, E> {
+  switch (mutationResult._tag) {
+    case "Loading": {
+      return { loading: true, data: undefined, error: undefined }
+    }
+    case "Success": {
+      return {
+        loading: false,
+        data: mutationResult.data,
+        error: undefined
+      }
+    }
+    case "Error": {
+      return {
+        loading: false,
+        data: undefined,
+        error: mutationResult.error
+      }
+    }
+    case "Initial": {
+      return { loading: false, data: undefined, error: undefined }
+    }
+  }
+}
+
+export interface Res<A, E> {
+  readonly loading: boolean
+  readonly data: A | undefined
+  readonly error: E | undefined
+}
 
 export type WatchSource<T = any> = Ref<T> | ComputedRef<T> | (() => T)
 export function make<A, E, R>(self: Effect<A, E, R>) {
@@ -61,24 +102,13 @@ type MaybeRefDeep<T> = MaybeRef<
     : T
 >
 
-export interface MutationOptions<A, I = void> {
+export interface MutationOptions {
   queryInvalidation?: (defaultKey: string[], name: string) => {
     filters?: MaybeRefDeep<InvalidateQueryFilters> | undefined
     options?: MaybeRefDeep<InvalidateOptions> | undefined
   }[]
-  /** @deprecated use mapHandler with Effect.andThen/tap accordingly */
-  onSuccess?: (a: A, i: I) => Promise<unknown>
 }
 
-export const getQueryKey = (h: { name: string }) => {
-  const key = makeQueryKey(h)
-  const ns = key.filter((_) => _.startsWith("$"))
-  // we invalidate the parent namespace e.g $project/$configuration.get, we invalidate $project
-  // for $project/$configuration/$something.get, we invalidate $project/$configuration
-  const k = ns.length ? ns.length > 1 ? ns.slice(0, ns.length - 1) : ns : undefined
-  if (!k) throw new Error("empty query key for: " + h.name)
-  return k
-}
 // TODO: more efficient invalidation, including args etc
 // return Effect.promise(() => queryClient.invalidateQueries({
 //   predicate: (_) => nses.includes(_.queryKey.filter((_) => _.startsWith("$")).join("/"))
@@ -90,174 +120,114 @@ export const getQueryKey = (h: { name: string }) => {
                 // }
                 */
 
-export const makeMutation = <R>(runtime: ShallowRef<Runtime.Runtime<R> | undefined>) => {
-  type HandlerWithInput<I, A, E> = {
-    handler: (i: I) => Effect<A, E, R>
-    name: string
-  }
-  type Handler<A, E> = { handler: Effect<A, E, R>; name: string }
-
+export const makeMutation2 = () => {
   /**
    * 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: {
-    <I, E, A>(self: HandlerWithInput<I, A, E>, options?: MutationOptions<A, I>): readonly [
+    <I, E, A, R, Request extends TaggedRequestClassAny>(
+      self: RequestHandlerWithInput<I, A, E, R, Request>,
+      options?: MutationOptions
+    ): readonly [
       Readonly<Ref<MutationResult<A, E>>>,
-      (
-        i: I,
-        signal?: AbortSignal
-      ) => Promise<Either.Either<A, E>>
+      (i: I) => Effect<A, E, R>
     ]
-    <E, A>(self: Handler<A, E>, options?: MutationOptions<A>): readonly [
+    <E, A, R, Request extends TaggedRequestClassAny>(
+      self: RequestHandler<A, E, R, Request>,
+      options?: MutationOptions
+    ): readonly [
       Readonly<Ref<MutationResult<A, E>>>,
-      (
-        signal?: AbortSignal
-      ) => Promise<Either.Either<A, E>>
+      Effect<A, E, R>
     ]
-  } = <I, E, A>(
-    self: {
-      handler:
-        | HandlerWithInput<I, A, E>["handler"]
-        | Handler<A, E>["handler"]
-      name: string
-    },
-    options?: MutationOptions<A>
+  } = <I, E, A, R, Request extends TaggedRequestClassAny>(
+    self: RequestHandlerWithInput<I, A, E, R, Request> | RequestHandler<A, E, R, Request>,
+    options?: MutationOptions
   ) => {
-    const runPromise = Runtime.runPromise(getRuntime(runtime))
-
     const queryClient = useQueryClient()
     const state: Ref<MutationResult<A, E>> = ref<MutationResult<A, E>>({ _tag: "Initial" }) as any
-    const onSuccess = options?.onSuccess
 
     const invalidateQueries = (
       filters?: MaybeRefDeep<InvalidateQueryFilters>,
       options?: MaybeRefDeep<InvalidateOptions>
     ) => Effect.promise(() => queryClient.invalidateQueries(filters, options))
 
-    function handleExit(exit: Exit.Exit<A, E>): Effect<Either.Either<A, E>, never, never> {
+    function handleExit(exit: Exit.Exit<A, E>) {
       return Effect.sync(() => {
         if (Exit.isSuccess(exit)) {
           state.value = { _tag: "Success", data: exit.value }
-          return Either.right(exit.value)
+          return
         }
 
         const err = Cause.failureOption(exit.cause)
         if (Option.isSome(err)) {
           state.value = { _tag: "Error", error: err.value }
-          return Either.left(err.value)
-        }
-
-        const died = Cause.dieOption(exit.cause)
-        if (Option.isSome(died)) {
-          throw died.value
-        }
-        const interrupted = Cause.interruptOption(exit.cause)
-        if (Option.isSome(interrupted)) {
-          throw new InterruptedException()
+          return
         }
-        throw new Error("Invalid state")
       })
     }
 
-    const exec = (fst?: I | AbortSignal, snd?: AbortSignal) => {
-      let effect: Effect<A, E, R>
-      let signal: AbortSignal | undefined
-      if (Effect.isEffect(self.handler)) {
-        effect = self.handler as any
-        signal = fst as AbortSignal | undefined
-      } else {
-        effect = self.handler(fst as I)
-        signal = snd
-      }
-
-      const invalidateCache = Effect
-        .suspend(() => {
-          const queryKey = getQueryKey(self)
+    const invalidateCache = Effect.suspend(() => {
+      const queryKey = getQueryKey(self)
 
-          if (options?.queryInvalidation) {
-            const opts = options.queryInvalidation(queryKey, self.name)
-            if (!opts.length) {
-              return Effect.void
-            }
-            return Effect
-              .andThen(
-                Effect.annotateCurrentSpan({ queryKey, opts }),
-                Effect.forEach(opts, (_) => invalidateQueries(_.filters, _.options), { concurrency: "inherit" })
-              )
-              .pipe(Effect.withSpan("client.query.invalidation", { captureStackTrace: false }))
-          }
+      if (options?.queryInvalidation) {
+        const opts = options.queryInvalidation(queryKey, self.name)
+        if (!opts.length) {
+          return Effect.void
+        }
+        return Effect
+          .andThen(
+            Effect.annotateCurrentSpan({ queryKey, opts }),
+            Effect.forEach(opts, (_) => invalidateQueries(_.filters, _.options), { concurrency: "inherit" })
+          )
+          .pipe(Effect.withSpan("client.query.invalidation", { captureStackTrace: false }))
+      }
 
-          if (!queryKey) return Effect.void
+      if (!queryKey) return Effect.void
 
-          return Effect
-            .andThen(
-              Effect.annotateCurrentSpan({ queryKey }),
-              invalidateQueries({ queryKey })
-            )
-            .pipe(Effect.withSpan("client.query.invalidation", { captureStackTrace: false }))
-        })
+      return Effect
+        .andThen(
+          Effect.annotateCurrentSpan({ queryKey }),
+          invalidateQueries({ queryKey })
+        )
+        .pipe(Effect.withSpan("client.query.invalidation", { captureStackTrace: false }))
+    })
 
-      return runPromise(
+    const handler = self.handler
+    const r = Effect.isEffect(handler)
+      ? tuple(
+        state,
         Effect
           .sync(() => {
             state.value = { _tag: "Loading" }
           })
           .pipe(
-            Effect.andThen(effect),
-            Effect.tapBoth({ onFailure: () => invalidateCache, onSuccess: () => invalidateCache }),
-            Effect.tap((a) =>
-              onSuccess ? Effect.promise(() => onSuccess(a, (fst !== signal ? fst : undefined) as any)) : Effect.void
-            ),
+            Effect.zipRight(handler),
+            Effect.tap(invalidateCache),
             Effect.tapDefect(reportRuntimeError),
-            Effect.exit,
-            Effect.flatMap(handleExit),
+            Effect.onExit(handleExit),
             Effect.withSpan(`mutation ${self.name}`, { captureStackTrace: false })
-          ),
-        dropUndefinedT({ signal })
+          )
       )
-    }
+      : 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 })
+          )
+      })
 
-    return tuple(
-      state,
-      exec
-    )
+    return r as any
   }
   return useSafeMutation
 }
 
 // eslint-disable-next-line @typescript-eslint/no-empty-object-type
-export interface MakeMutation<R> extends ReturnType<typeof makeMutation<R>> {}
-
-export function mutationResultToVue<A, E>(
-  mutationResult: MutationResult<A, E>
-): Res<A, E> {
-  switch (mutationResult._tag) {
-    case "Loading": {
-      return { loading: true, data: undefined, error: undefined }
-    }
-    case "Success": {
-      return {
-        loading: false,
-        data: mutationResult.data,
-        error: undefined
-      }
-    }
-    case "Error": {
-      return {
-        loading: false,
-        data: undefined,
-        error: mutationResult.error
-      }
-    }
-    case "Initial": {
-      return { loading: false, data: undefined, error: undefined }
-    }
-  }
-}
-
-export interface Res<A, E> {
-  readonly loading: boolean
-  readonly data: A | undefined
-  readonly error: E | undefined
-}
+export interface MakeMutation2 extends ReturnType<typeof makeMutation2> {}

package/src/query.ts

@@ -12,8 +12,9 @@ import type {
   UseQueryReturnType
 } from "@tanstack/vue-query"
 import { useQuery } from "@tanstack/vue-query"
-import { Array, Cause, Effect, Option, Runtime, S } from "effect-app"
+import { 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"
 import { computed, ref } from "vue"
 import type { ComputedRef, ShallowRef, WatchSource } from "vue"
@@ -35,31 +36,15 @@ export interface KnownFiberFailure<E> extends Runtime.FiberFailure {
   readonly [Runtime.FiberFailureCauseId]: Cause.Cause<E>
 }
 
-export const makeQuery = <R>(runtime: ShallowRef<Runtime.Runtime<R> | undefined>) => {
+export const makeQuery2 = <R>(runtime: ShallowRef<Runtime.Runtime<R> | undefined>) => {
   // TODO: options
   // declare function useQuery<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: UndefinedInitialQueryOptions<TQueryFnData, TError, TData, TQueryKey>, queryClient?: QueryClient): UseQueryReturnType<TData, TError>;
   // declare function useQuery<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: DefinedInitialQueryOptions<TQueryFnData, TError, TData, TQueryKey>, queryClient?: QueryClient): UseQueryDefinedReturnType<TData, TError>;
   // declare function useQuery<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: UseQueryOptions<TQueryFnData, TError, TData, TQueryFnData, TQueryKey>, queryClient?: QueryClient): UseQueryReturnType<TData, TError>;
-  const useSafeQuery_ = <I, A, E>(
+  const useSafeQuery_ = <I, A, E, Request extends TaggedRequestClassAny>(
     q:
-      | {
-        readonly handler: (
-          req: I
-        ) => Effect<
-          A,
-          E,
-          R
-        >
-        name: string
-      }
-      | {
-        readonly handler: Effect<
-          A,
-          E,
-          R
-        >
-        name: string
-      },
+      | RequestHandlerWithInput<I, A, E, R, Request>
+      | RequestHandler<A, E, R, Request>,
     arg?: I | WatchSource<I>,
     options: QueryObserverOptionsCustom<unknown, KnownFiberFailure<E>, A> = {} // TODO
   ) => {
@@ -136,7 +121,15 @@ export const makeQuery = <R>(runtime: ShallowRef<Runtime.Runtime<R> | undefined>
       })
     )
     const latestSuccess = computed(() => Option.getOrUndefined(Result.value(result.value)))
-    return [result, latestSuccess, r.refetch, r] as const
+    return [
+      result,
+      latestSuccess,
+      // one thing to keep in mind is that span will be disconnected as Context does not pass from outside.
+      // TODO: consider how we should handle the Result here which is `QueryObserverResult<A, KnownFiberFailure<E>>`
+      // and always ends up in the success channel, even when error..
+      (options?: RefetchOptions) => Effect.promise(() => r.refetch(options)),
+      r
+    ] as const
   }
 
   function swrToQuery<E, A>(r: {
@@ -158,79 +151,46 @@ export const makeQuery = <R>(runtime: ShallowRef<Runtime.Runtime<R> | undefined>
     return Result.initial(r.isValidating)
   }
 
-  function useSafeQuery<E, A>(
-    self: {
-      handler: Effect<A, E, R>
-      name: string
-    },
-    options: QueryObserverOptionsCustom<A, E> & { initialData: A | InitialDataFunction<A> }
+  function useSafeQuery<E, A, Request extends TaggedRequestClassAny>(
+    self: RequestHandler<A, E, R, Request>,
+    options?: QueryObserverOptionsCustom<A, E> & { initialData: A | InitialDataFunction<A> }
   ): readonly [
     ComputedRef<Result.Result<A, E>>,
     ComputedRef<A>,
-    (options?: RefetchOptions) => Promise<QueryObserverResult<any, any>>,
+    (options?: RefetchOptions) => Effect<QueryObserverResult<A, KnownFiberFailure<E>>>,
     UseQueryReturnType<any, any>
   ]
-  function useSafeQuery<Arg, E, A>(
-    self: {
-      handler: (arg: Arg) => Effect<A, E, R>
-      name: string
-    },
+  function useSafeQuery<Arg, E, A, Request extends TaggedRequestClassAny>(
+    self: RequestHandlerWithInput<Arg, A, E, R, Request>,
     arg: Arg | WatchSource<Arg>,
-    options: QueryObserverOptionsCustom<A, E>
+    options?: QueryObserverOptionsCustom<A, E> & { initialData: A | InitialDataFunction<A> }
   ): readonly [
     ComputedRef<Result.Result<A, E>>,
     ComputedRef<A>,
-    (options?: RefetchOptions) => Promise<QueryObserverResult<any, any>>,
+    (options?: RefetchOptions) => Effect<QueryObserverResult<A, KnownFiberFailure<E>>>,
     UseQueryReturnType<any, any>
   ]
-  function useSafeQuery<E, A>(
-    self: {
-      handler: Effect<A, E, R>
-      name: string
-    },
+  function useSafeQuery<E, A, Request extends TaggedRequestClassAny>(
+    self: RequestHandler<A, E, R, Request>,
     options?: QueryObserverOptionsCustom<A, E>
   ): readonly [
     ComputedRef<Result.Result<A, E>>,
     ComputedRef<A | undefined>,
-    (options?: RefetchOptions) => Promise<QueryObserverResult<any, any>>,
+    (options?: RefetchOptions) => Effect<QueryObserverResult<A, KnownFiberFailure<E>>>,
     UseQueryReturnType<any, any>
   ]
-  function useSafeQuery<Arg, E, A>(
-    self: {
-      handler: (arg: Arg) => Effect<A, E, R>
-      name: string
-    },
+  function useSafeQuery<Arg, E, A, Request extends TaggedRequestClassAny>(
+    self: RequestHandlerWithInput<Arg, A, E, R, Request>,
     arg: Arg | WatchSource<Arg>,
     options?: QueryObserverOptionsCustom<A, E>
   ): readonly [
     ComputedRef<Result.Result<A, E>>,
     ComputedRef<A | undefined>,
-    (options?: RefetchOptions) => Promise<QueryObserverResult<any, any>>,
+    (options?: RefetchOptions) => Effect<QueryObserverResult<A, KnownFiberFailure<E>>>,
     UseQueryReturnType<any, any>
   ]
   function useSafeQuery(
     self: any,
-    /*
-  q:
-    | {
-      handler: (
-        req: I
-      ) => Effect<
-        A,
-        E,
-        R
-      >
-      name: string
-    }
-    | {
-      handler: Effect<
-        A,
-        E,
-        R
-      >
-      name: string
-    },
-  */
     argOrOptions?: any,
     options?: any
   ) {
@@ -242,50 +202,4 @@ export const makeQuery = <R>(runtime: ShallowRef<Runtime.Runtime<R> | undefined>
 }
 
 // eslint-disable-next-line @typescript-eslint/no-empty-object-type
-export interface MakeQuery<R> extends ReturnType<typeof makeQuery<R>> {}
-
-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)
-}
-
-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 interface MakeQuery2<R> extends ReturnType<typeof makeQuery2<R>> {}

package/_cjs/hooks.cjs

@@ -1,28 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-var _mutate = require("./mutate.cjs");
-Object.keys(_mutate).forEach(function (key) {
-  if (key === "default" || key === "__esModule") return;
-  if (key in exports && exports[key] === _mutate[key]) return;
-  Object.defineProperty(exports, key, {
-    enumerable: true,
-    get: function () {
-      return _mutate[key];
-    }
-  });
-});
-var _query = require("./query.cjs");
-Object.keys(_query).forEach(function (key) {
-  if (key === "default" || key === "__esModule") return;
-  if (key in exports && exports[key] === _query[key]) return;
-  Object.defineProperty(exports, key, {
-    enumerable: true,
-    get: function () {
-      return _query[key];
-    }
-  });
-});
-//# sourceMappingURL=hooks.cjs.map

package/_cjs/hooks.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"hooks.cjs","names":["_mutate","require","Object","keys","forEach","key","exports","defineProperty","enumerable","get","_query"],"sources":["../src/hooks.ts"],"sourcesContent":[null],"mappings":";;;;;AAEA,IAAAA,OAAA,GAAAC,OAAA;AAAAC,MAAA,CAAAC,IAAA,CAAAH,OAAA,EAAAI,OAAA,WAAAC,GAAA;EAAA,IAAAA,GAAA,kBAAAA,GAAA;EAAA,IAAAA,GAAA,IAAAC,OAAA,IAAAA,OAAA,CAAAD,GAAA,MAAAL,OAAA,CAAAK,GAAA;EAAAH,MAAA,CAAAK,cAAA,CAAAD,OAAA,EAAAD,GAAA;IAAAG,UAAA;IAAAC,GAAA,WAAAA,CAAA;MAAA,OAAAT,OAAA,CAAAK,GAAA;IAAA;EAAA;AAAA;AACA,IAAAK,MAAA,GAAAT,OAAA;AAAAC,MAAA,CAAAC,IAAA,CAAAO,MAAA,EAAAN,OAAA,WAAAC,GAAA;EAAA,IAAAA,GAAA,kBAAAA,GAAA;EAAA,IAAAA,GAAA,IAAAC,OAAA,IAAAA,OAAA,CAAAD,GAAA,MAAAK,MAAA,CAAAL,GAAA;EAAAH,MAAA,CAAAK,cAAA,CAAAD,OAAA,EAAAD,GAAA;IAAAG,UAAA;IAAAC,GAAA,WAAAA,CAAA;MAAA,OAAAC,MAAA,CAAAL,GAAA;IAAA;EAAA;AAAA","ignoreList":[]}