@effect-app/vue 1.25.2 → 1.26.1

package/src/mutate2.ts

@@ -0,0 +1,191 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { tuple } from "@effect-app/core/Function"
+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 } from "effect-app"
+import type { ComputedRef, Ref } from "vue"
+import { computed, ref, shallowRef } from "vue"
+import { reportRuntimeError } from "./internal.js"
+import { getQueryKey } from "./mutate.js"
+
+export type WatchSource<T = any> = Ref<T> | ComputedRef<T> | (() => T)
+export function make<A, E, R>(self: Effect<A, E, R>) {
+  const result = shallowRef(Result.initial() as Result.Result<A, E>)
+
+  const execute = Effect
+    .sync(() => {
+      result.value = Result.waiting(result.value)
+    })
+    .pipe(
+      Effect.andThen(self),
+      Effect.exit,
+      Effect.andThen(Result.fromExit),
+      Effect.flatMap((r) => Effect.sync(() => result.value = r))
+    )
+
+  const latestSuccess = computed(() => Option.getOrUndefined(Result.value(result.value)))
+
+  return tuple(result, latestSuccess, execute)
+}
+
+export interface MutationInitial {
+  readonly _tag: "Initial"
+}
+
+export interface MutationLoading {
+  readonly _tag: "Loading"
+}
+
+export interface MutationSuccess<A> {
+  readonly _tag: "Success"
+  readonly data: A
+}
+
+export interface MutationError<E> {
+  readonly _tag: "Error"
+  readonly error: E
+}
+
+export type MutationResult<A, E> = MutationInitial | MutationLoading | MutationSuccess<A> | MutationError<E>
+
+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 {
+  queryInvalidation?: (defaultKey: string[], name: string) => {
+    filters?: MaybeRefDeep<InvalidateQueryFilters> | undefined
+    options?: MaybeRefDeep<InvalidateOptions> | undefined
+  }[]
+}
+
+// TODO: more efficient invalidation, including args etc
+// return Effect.promise(() => queryClient.invalidateQueries({
+//   predicate: (_) => nses.includes(_.queryKey.filter((_) => _.startsWith("$")).join("/"))
+// }))
+/*
+            // const nses: string[] = []
+                // for (let i = 0; i < ns.length; i++) {
+                //   nses.push(ns.slice(0, i + 1).join("/"))
+                // }
+                */
+
+export const makeMutation2 = () => {
+  type HandlerWithInput<I, A, E, R> = {
+    handler: (i: I) => Effect<A, E, R>
+    name: string
+  }
+  type Handler<A, E, R> = { handler: Effect<A, E, R>; name: string }
+
+  /**
+   * 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, R>(
+      self: HandlerWithInput<I, A, E, R>,
+      options?: MutationOptions
+    ): readonly [
+      Readonly<Ref<MutationResult<A, E>>>,
+      (i: I) => Effect<A, E, R>
+    ]
+    <E, A, R>(self: Handler<A, E, R>, options?: MutationOptions): readonly [
+      Readonly<Ref<MutationResult<A, E>>>,
+      () => Effect<A, E, R> // TODO: remove () =>
+    ]
+  } = <I, E, A, R>(
+    self: {
+      handler:
+        | HandlerWithInput<I, A, E, R>["handler"]
+        | Handler<A, E, R>["handler"]
+      name: string
+    },
+    options?: MutationOptions
+  ) => {
+    const queryClient = useQueryClient()
+    const state: Ref<MutationResult<A, E>> = ref<MutationResult<A, E>>({ _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>) {
+      return Effect.sync(() => {
+        if (Exit.isSuccess(exit)) {
+          state.value = { _tag: "Success", data: exit.value }
+          return
+        }
+
+        const err = Cause.failureOption(exit.cause)
+        if (Option.isSome(err)) {
+          state.value = { _tag: "Error", error: err.value }
+          return
+        }
+      })
+    }
+
+    const invalidateCache = Effect.suspend(() => {
+      const queryKey = getQueryKey(self.name)
+
+      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
+
+      return Effect
+        .andThen(
+          Effect.annotateCurrentSpan({ queryKey }),
+          invalidateQueries({ queryKey })
+        )
+        .pipe(Effect.withSpan("client.query.invalidation", { captureStackTrace: false }))
+    })
+
+    const exec = (fst?: I) => {
+      let effect: Effect<A, E, R>
+      if (Effect.isEffect(self.handler)) {
+        effect = self.handler as any
+      } else {
+        effect = self.handler(fst as I)
+      }
+
+      return Effect
+        .sync(() => {
+          state.value = { _tag: "Loading" }
+        })
+        .pipe(
+          Effect.zipRight(effect),
+          Effect.tap(invalidateCache),
+          Effect.tapDefect(reportRuntimeError),
+          Effect.onExit(handleExit),
+          Effect.withSpan(`mutation ${self.name}`, { captureStackTrace: false })
+        )
+    }
+
+    return tuple(
+      state,
+      exec
+    )
+  }
+  return useSafeMutation
+}
+
+// eslint-disable-next-line @typescript-eslint/no-empty-object-type
+export interface MakeMutation2 extends ReturnType<typeof makeMutation2> {}

package/src/query2.ts

@@ -0,0 +1,231 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/* eslint-disable @typescript-eslint/no-unsafe-call */
+/* eslint-disable @typescript-eslint/no-unsafe-return */
+/* eslint-disable @typescript-eslint/no-unsafe-assignment */
+import { isHttpRequestError, isHttpResponseError } from "@effect-app/core/http/http-client"
+import * as Result from "@effect-rx/rx/Result"
+import type {
+  QueryKey,
+  QueryObserverOptions,
+  QueryObserverResult,
+  RefetchOptions,
+  UseQueryReturnType
+} from "@tanstack/vue-query"
+import { useQuery } from "@tanstack/vue-query"
+import { Cause, Effect, Option, Runtime, S } from "effect-app"
+import { ServiceUnavailableError } from "effect-app/client"
+import { computed, ref } from "vue"
+import type { ComputedRef, Ref, WatchSource } from "vue"
+import { makeQueryKey, reportRuntimeError } from "./internal.js"
+
+// eslint-disable-next-line @typescript-eslint/no-empty-object-type
+export interface QueryObserverOptionsCustom<
+  TQueryFnData = unknown,
+  TError = Error,
+  TData = TQueryFnData,
+  TQueryData = TQueryFnData,
+  TQueryKey extends QueryKey = QueryKey,
+  TPageParam = never
+> extends
+  Omit<QueryObserverOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey, TPageParam>, "queryKey" | "queryFn">
+{}
+
+export interface KnownFiberFailure<E> extends Runtime.FiberFailure {
+  readonly [Runtime.FiberFailureCauseId]: Cause.Cause<E>
+}
+
+export const makeQuery2 = <R>(runtime: Ref<Runtime.Runtime<R>>) => {
+  // 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>(
+    q:
+      | {
+        readonly handler: (
+          req: I
+        ) => Effect<
+          A,
+          E,
+          R
+        >
+        mapPath: (req: I) => string
+        name: string
+      }
+      | {
+        readonly handler: Effect<
+          A,
+          E,
+          R
+        >
+        mapPath: string
+        name: string
+      },
+    arg?: I | WatchSource<I>,
+    options: QueryObserverOptionsCustom<unknown, KnownFiberFailure<E>, A> = {} // TODO
+  ) => {
+    const runPromise = Runtime.runPromise(runtime.value)
+    const arr = arg
+    const req: { value: I } = !arg
+      ? undefined
+      : typeof arr === "function"
+      ? ({
+        get value() {
+          return (arr as any)()
+        }
+      } as any)
+      : ref(arg)
+    const queryKey = makeQueryKey(q.name)
+    const handler = q.handler
+    const r = useQuery<unknown, KnownFiberFailure<E>, A>(
+      Effect.isEffect(handler)
+        ? {
+          ...options,
+          retry: (retryCount, error) => {
+            if (Runtime.isFiberFailure(error)) {
+              const cause = error[Runtime.FiberFailureCauseId]
+              const sq = Cause.squash(cause)
+              if (!isHttpRequestError(sq) && !isHttpResponseError(sq) && !S.is(ServiceUnavailableError)(sq)) {
+                return false
+              }
+            }
+
+            return retryCount < 5
+          },
+          queryKey,
+          queryFn: ({ signal }) =>
+            runPromise(
+              handler
+                .pipe(
+                  Effect.tapDefect(reportRuntimeError),
+                  Effect.withSpan(`query ${q.name}`, { captureStackTrace: false })
+                ),
+              { signal }
+            )
+        }
+        : {
+          ...options,
+          retry: (retryCount, error) => {
+            if (Runtime.isFiberFailure(error)) {
+              const cause = error[Runtime.FiberFailureCauseId]
+              const sq = Cause.squash(cause)
+              if (!isHttpRequestError(sq) && !isHttpResponseError(sq) && !S.is(ServiceUnavailableError)(sq)) {
+                return false
+              }
+            }
+
+            return retryCount < 5
+          },
+          queryKey: [...queryKey, req],
+          queryFn: ({ signal }) =>
+            runPromise(
+              handler(req.value)
+                .pipe(
+                  Effect.tapDefect(reportRuntimeError),
+                  Effect.withSpan(`query ${q.name}`, { captureStackTrace: false })
+                ),
+              { signal }
+            )
+        }
+    )
+
+    const result = computed(() =>
+      swrToQuery({
+        error: r.error.value ?? undefined,
+        data: r.data.value,
+        isValidating: r.isFetching.value
+      })
+    )
+    const latestSuccess = computed(() => Option.getOrUndefined(Result.value(result.value)))
+    return [
+      result,
+      latestSuccess,
+      // one thing to keep in mind is that span will be disconnected as Context does not pass from outside.
+      (options?: RefetchOptions) => Effect.promise(() => r.refetch(options)),
+      r
+    ] as const
+  }
+
+  function swrToQuery<E, A>(r: {
+    error: KnownFiberFailure<E> | undefined
+    data: A | undefined
+    isValidating: boolean
+  }): Result.Result<A, E> {
+    if (r.error) {
+      return Result.failureWithPrevious(
+        r.error[Runtime.FiberFailureCauseId],
+        r.data === undefined ? Option.none() : Option.some(Result.success(r.data)),
+        r.isValidating
+      )
+    }
+    if (r.data !== undefined) {
+      return Result.success<A, E>(r.data, r.isValidating)
+    }
+
+    return Result.initial(r.isValidating)
+  }
+
+  function useSafeQuery<E, A>(
+    self: {
+      handler: Effect<A, E, R>
+      mapPath: string
+      name: string
+    },
+    options?: QueryObserverOptionsCustom // TODO
+  ): readonly [
+    ComputedRef<Result.Result<A, E>>,
+    ComputedRef<A | undefined>,
+    (options?: RefetchOptions) => Effect<QueryObserverResult<A, KnownFiberFailure<E>>>,
+    UseQueryReturnType<any, any>
+  ]
+  function useSafeQuery<Arg, E, A>(
+    self: {
+      handler: (arg: Arg) => Effect<A, E, R>
+      mapPath: (arg: Arg) => string
+      name: string
+    },
+    arg: Arg | WatchSource<Arg>,
+    options?: QueryObserverOptionsCustom // TODO
+  ): readonly [
+    ComputedRef<Result.Result<A, E>>,
+    ComputedRef<A | undefined>,
+    (options?: RefetchOptions) => Effect<QueryObserverResult<A, KnownFiberFailure<E>>>,
+    UseQueryReturnType<any, any>
+  ]
+  function useSafeQuery(
+    self: any,
+    /*
+  q:
+    | {
+      handler: (
+        req: I
+      ) => Effect<
+        A,
+        E,
+        R
+      >
+      mapPath: (req: I) => string
+      name: string
+    }
+    | {
+      handler: Effect<
+        A,
+        E,
+        R
+      >
+      mapPath: string
+      name: string
+    },
+  */
+    argOrOptions?: any,
+    options?: any
+  ) {
+    return Effect.isEffect(self.handler)
+      ? useSafeQuery_(self, undefined, argOrOptions)
+      : useSafeQuery_(self, argOrOptions, options)
+  }
+  return useSafeQuery
+}
+
+// eslint-disable-next-line @typescript-eslint/no-empty-object-type
+export interface MakeQuery2<R> extends ReturnType<typeof makeQuery2<R>> {}