@effect-app/vue 4.0.0-beta.2 → 4.0.0-beta.200

package/src/query.ts

@@ -2,16 +2,22 @@
 /* eslint-disable @typescript-eslint/no-unsafe-call */
 /* eslint-disable @typescript-eslint/no-unsafe-return */
 /* eslint-disable @typescript-eslint/no-unsafe-assignment */
-import * as AsyncResult from "effect/unstable/reactivity/AsyncResult"
-import { type DefaultError, type Enabled, type InitialDataFunction, type NonUndefinedGuard, type PlaceholderDataFunction, type QueryKey, type QueryObserverOptions, type QueryObserverResult, type RefetchOptions, useQuery as useTanstackQuery, useQueryClient, type UseQueryDefinedReturnType, type UseQueryReturnType } from "@tanstack/vue-query"
-import { Array, Cause, Effect, Exit, flow, Option, S, type ServiceMap } from "effect-app"
-import { type Req } from "effect-app/client"
-import type { RequestHandler, RequestHandlerWithInput } from "effect-app/client/clientFor"
-import { ServiceUnavailableError } from "effect-app/client/errors"
+/* eslint-disable @typescript-eslint/no-unsafe-member-access */
+import { type DefaultError, type Enabled, experimental_streamedQuery as streamedQuery, type InitialDataFunction, type NonUndefinedGuard, type PlaceholderDataFunction, type QueryKey, type QueryObserverOptions, type QueryObserverResult, type RefetchOptions, useQuery as useTanstackQuery, useQueryClient, type UseQueryDefinedReturnType, type UseQueryReturnType } from "@tanstack/vue-query"
+import { Array, Cause, type Context, Effect, Exit, Option, S } from "effect-app"
+import { makeQueryKey, type Req } from "effect-app/client"
+import type { RequestHandlerWithInput, RequestStreamHandlerWithInput } from "effect-app/client/clientFor"
+import { CauseException, ServiceUnavailableError } from "effect-app/client/errors"
+import * as Channel from "effect/Channel"
+import * as Pull from "effect/Pull"
+import * as Scope from "effect/Scope"
+import type * as Stream from "effect/Stream"
 import { type Span } from "effect/Tracer"
 import { isHttpClientError } from "effect/unstable/http/HttpClientError"
+import * as AsyncResult from "effect/unstable/reactivity/AsyncResult"
 import { computed, type ComputedRef, type MaybeRefOrGetter, ref, shallowRef, watch, type WatchSource } from "vue"
-import { makeQueryKey, reportRuntimeError } from "./lib.js"
+import { reportRuntimeError } from "./lib.js"
+import { makeRunPromise } from "./runtime.js"
 
 // we must use interface extends, or we get the dreaded typescript error of isn't portable blabla @tanstack/vue-query/build/modern/types.js
 // but because how they are dealing with some extends clause, we loose all properties except initialData
@@ -74,20 +80,68 @@ export interface CustomDefinedPlaceholderQueryOptions<
     | PlaceholderDataFunction<NonFunctionGuard<TQueryData>, TError, NonFunctionGuard<TQueryData>, TQueryKey>
 }
 
-export class KnownFiberFailure<E> extends Error {
-  readonly error: unknown
-  constructor(public effectCause: Cause.Cause<E>) {
-    super("Query failed with cause: " + Cause.squash(effectCause))
-    this.error = Cause.squash(effectCause)
+function swrToQuery<E, A>(r: {
+  error: CauseException<E> | undefined
+  data: A | undefined
+  isValidating: boolean
+}): AsyncResult.AsyncResult<A, E> {
+  if (r.error !== undefined) {
+    return AsyncResult.failureWithPrevious(
+      r.error.originalCause,
+      {
+        previous: r.data === undefined ? Option.none() : Option.some(AsyncResult.success(r.data)),
+        waiting: r.isValidating
+      }
+    )
   }
+  if (r.data !== undefined) {
+    return AsyncResult.success<A, E>(r.data, { waiting: r.isValidating })
+  }
+
+  return AsyncResult.initial(r.isValidating)
 }
 
-export const makeQuery = <R>(getRuntime: () => ServiceMap.ServiceMap<R>) => {
+function streamToAsyncIterableWithCauseException<A, E, R>(
+  self: Stream.Stream<A, E, R>,
+  context: Context.Context<R>,
+  id: string
+): AsyncIterable<A> {
+  return {
+    [Symbol.asyncIterator]() {
+      const runPromise = Effect.runPromiseWith(context)
+      const runPromiseExit = Effect.runPromiseExitWith(context)
+      const scope = Scope.makeUnsafe()
+      let pull: any
+      let currentIter: Iterator<A> | undefined
+      return {
+        async next(): Promise<IteratorResult<A>> {
+          if (currentIter) {
+            const next = currentIter.next()
+            if (!next.done) return next
+            currentIter = undefined
+          }
+          pull ??= await runPromise(Channel.toPullScoped((self as any).channel, scope))
+          const exit = await runPromiseExit(pull)
+          if (Exit.isSuccess(exit)) {
+            currentIter = (exit.value as any)[Symbol.iterator]()
+            return currentIter!.next()
+          } else if (Pull.isDoneCause((exit as any).cause)) {
+            return { done: true, value: undefined }
+          }
+          throw new CauseException((exit as any).cause, id)
+        },
+        return(_) {
+          return runPromise(Effect.as(Scope.close(scope, Exit.void), { done: true, value: undefined }) as any)
+        }
+      }
+    }
+  }
+}
+
+export const makeQuery = <R>(getRuntime: () => Context.Context<R>) => {
   const useQuery_: {
     <I, A, E, Request extends Req, Name extends string>(
-      q:
-        | RequestHandlerWithInput<I, A, E, R, Request, Name>
-        | RequestHandler<A, E, R, Request, Name>
+      q: RequestHandlerWithInput<I, A, E, R, Request, Name>
     ): {
       <TData = A>(
         arg: I | WatchSource<I> | undefined,
@@ -95,8 +149,8 @@ export const makeQuery = <R>(getRuntime: () => ServiceMap.ServiceMap<R>) => {
       ): readonly [
         ComputedRef<AsyncResult.AsyncResult<TData, E>>,
         ComputedRef<TData | undefined>,
-        (options?: RefetchOptions) => Effect.Effect<QueryObserverResult<TData, KnownFiberFailure<E>>, never, never>,
-        UseQueryDefinedReturnType<TData, KnownFiberFailure<E>>
+        (options?: RefetchOptions) => Effect.Effect<QueryObserverResult<TData, CauseException<E>>>,
+        UseQueryDefinedReturnType<TData, CauseException<E>>
       ]
 
       <TData = A>(
@@ -105,8 +159,8 @@ export const makeQuery = <R>(getRuntime: () => ServiceMap.ServiceMap<R>) => {
       ): readonly [
         ComputedRef<AsyncResult.AsyncResult<TData, E>>,
         ComputedRef<TData>,
-        (options?: RefetchOptions) => Effect.Effect<QueryObserverResult<TData, KnownFiberFailure<E>>, never, never>,
-        UseQueryDefinedReturnType<TData, KnownFiberFailure<E>>
+        (options?: RefetchOptions) => Effect.Effect<QueryObserverResult<TData, CauseException<E>>>,
+        UseQueryDefinedReturnType<TData, CauseException<E>>
       ]
 
       <TData = A>(
@@ -115,14 +169,12 @@ export const makeQuery = <R>(getRuntime: () => ServiceMap.ServiceMap<R>) => {
       ): readonly [
         ComputedRef<AsyncResult.AsyncResult<TData, E>>,
         ComputedRef<TData>,
-        (options?: RefetchOptions) => Effect.Effect<QueryObserverResult<TData, KnownFiberFailure<E>>, never, never>,
-        UseQueryDefinedReturnType<TData, KnownFiberFailure<E>>
+        (options?: RefetchOptions) => Effect.Effect<QueryObserverResult<TData, CauseException<E>>>,
+        UseQueryDefinedReturnType<TData, CauseException<E>>
       ]
     }
   } = <I, A, E, Request extends Req, Name extends string>(
-    q:
-      | RequestHandlerWithInput<I, A, E, R, Request, Name>
-      | RequestHandler<A, E, R, Request, Name>
+    q: RequestHandlerWithInput<I, A, E, R, Request, Name>
   ) =>
   <TData = A>(
     arg: I | WatchSource<I> | undefined,
@@ -130,76 +182,56 @@ export const makeQuery = <R>(getRuntime: () => ServiceMap.ServiceMap<R>) => {
     options?: any
     // TODO
   ) => {
-    // we wrap into KnownFiberFailure because we want to keep the full cause of the failure.
-    const runPromise = flow(Effect.runPromiseExitWith(getRuntime()), (_) =>
-      _.then(
-        Exit.match({
-          onFailure: (cause) => Promise.reject(new KnownFiberFailure(cause)),
-          onSuccess: (value) => Promise.resolve(value)
-        })
-      ))
+    // we wrap into CauseException because we want to keep the full cause of the failure.
+    const runPromise = makeRunPromise(getRuntime())
     const arr = arg
-    const req: { value: I } = !arg
+    const req: { value: I } | undefined = !arg
       ? undefined
       : typeof arr === "function"
       ? ({
         get value() {
           return (arr as any)()
         }
-      } as any)
-      : ref(arg)
+      })
+      : ref(arg) as any
     const queryKey = makeQueryKey(q)
-    const handler = q.handler
+    const projectionHash = (q as { queryKeyProjectionHash?: string }).queryKeyProjectionHash
 
-    const r = useTanstackQuery<A, KnownFiberFailure<E>, TData>(
-      Effect.isEffect(handler)
-        ? {
-          ...options,
-          retry: (retryCount, error) => {
-            if (error instanceof KnownFiberFailure) {
-              if (!isHttpClientError(error.error) && !S.is(ServiceUnavailableError)(error.error)) {
-                return false
-              }
-            }
+    const defaultOptions = {
+      // we do not want to throw errors, because we turn the success and error responses into a Result type
+      // why don't we turn the error/success response into a Result type before returning to tanstack query? because we want to leverage tanstack query's retry and caching mechanism, which relies on throwing errors to trigger retries, and we don't want to interfere with that by catching the errors too early.
+      // but if we allow tanstack query to throw, it will trigger the error boundary in Vue - via a "watcher callback" error - which we currently report and log, which is not what we want.
+      // TODO: we might want to rethink the strategy of how to handle errors that happen after the initial load.
+      // For suspense, the initial load is captured by the suspense boundary.
+      // For subsequent loads (or non suspense use) we currently are required to use the QueryResult component to conditionally render error/loading/etc.
+      throwOnError: false
+    }
 
-            return retryCount < 5
-          },
-          queryKey,
-          queryFn: ({ meta, signal }) =>
-            runPromise(
-              handler
-                .pipe(
-                  Effect.tapCauseIf(Cause.hasDies, (cause) => reportRuntimeError(cause)),
-                  Effect.withSpan(`query ${q.id}`, {}, { captureStackTrace: false }),
-                  meta?.["span"] ? Effect.withParentSpan(meta["span"] as Span) : (_) => _
-                ),
-              { signal }
-            )
+    const r = useTanstackQuery<A, CauseException<E>, TData>({
+      ...defaultOptions,
+      ...options,
+      retry: (retryCount, error) => {
+        if (error instanceof CauseException) {
+          if (!isHttpClientError(error.cause) && !S.is(ServiceUnavailableError)(error.cause)) {
+            return false
+          }
         }
-        : {
-          ...options,
-          retry: (retryCount, error) => {
-            if (error instanceof KnownFiberFailure) {
-              if (!isHttpClientError(error.error) && !S.is(ServiceUnavailableError)(error.error)) {
-                return false
-              }
-            }
 
-            return retryCount < 5
-          },
-          queryKey: [...queryKey, req],
-          queryFn: ({ meta, signal }) =>
-            runPromise(
-              handler(req.value)
-                .pipe(
-                  Effect.tapCauseIf(Cause.hasDies, (cause) => reportRuntimeError(cause)),
-                  Effect.withSpan(`query ${q.id}`, {}, { captureStackTrace: false }),
-                  meta?.["span"] ? Effect.withParentSpan(meta["span"] as Span) : (_) => _
-                ),
-              { signal }
-            )
-        }
-    )
+        return retryCount < 5
+      },
+      queryKey: projectionHash === undefined ? [...queryKey, req] : [...queryKey, req, projectionHash],
+      queryFn: ({ meta, signal }) =>
+        runPromise(
+          q
+            .handler(req?.value as I)
+            .pipe(
+              Effect.tapCauseIf(Cause.hasDies, (cause) => reportRuntimeError(cause)),
+              Effect.withSpan(`query ${q.id}`, {}, { captureStackTrace: false }),
+              meta?.["span"] ? Effect.withParentSpan(meta["span"] as Span) : (_) => _
+            ),
+          { signal }
+        )
+    })
 
     const latestSuccess = shallowRef<TData>()
     const result = computed((): AsyncResult.AsyncResult<TData, E> =>
@@ -227,129 +259,130 @@ export const makeQuery = <R>(getRuntime: () => ServiceMap.ServiceMap<R>) => {
     ] as any
   }
 
-  function swrToQuery<E, A>(r: {
-    error: KnownFiberFailure<E> | undefined
-    data: A | undefined
-    isValidating: boolean
-  }): AsyncResult.AsyncResult<A, E> {
-    if (r.error !== undefined) {
-      return AsyncResult.failureWithPrevious(
-        r.error.effectCause,
-        {
-          previous: r.data === undefined ? Option.none() : Option.some(AsyncResult.success(r.data)),
-          waiting: r.isValidating
-        }
-      )
-    }
-    if (r.data !== undefined) {
-      return AsyncResult.success<A, E>(r.data, { waiting: r.isValidating })
-    }
-
-    return AsyncResult.initial(r.isValidating)
-  }
-
   const useQuery: {
     /**
      * Effect results are passed to the caller, including errors.
+     * When `I = void` the input argument may be omitted.
      * @deprecated use client helpers instead (.query())
      */
-    <E, A, Request extends Req, Name extends string>(
-      self: RequestHandler<A, E, R, Request, Name>
-    ): {
-      // required options, with initialData
-      /**
-       * Effect results are passed to the caller, including errors.
-       */
-      <TData = A>(
-        options: CustomDefinedInitialQueryOptions<A, KnownFiberFailure<E>, TData>
-      ): readonly [
-        ComputedRef<AsyncResult.AsyncResult<TData, E>>,
-        ComputedRef<TData>,
-        (options?: RefetchOptions) => Effect.Effect<QueryObserverResult<TData, KnownFiberFailure<E>>>,
-        UseQueryReturnType<any, any>
-      ]
-      <TData = A>(
-        options: CustomDefinedPlaceholderQueryOptions<A, E, TData>
-      ): readonly [
-        ComputedRef<AsyncResult.AsyncResult<TData, E>>,
-        ComputedRef<TData>,
-        (options?: RefetchOptions) => Effect.Effect<QueryObserverResult<TData, KnownFiberFailure<E>>, never, never>,
-        UseQueryDefinedReturnType<TData, KnownFiberFailure<E>>
-      ]
-      // optional options, optional A
-      /**
-       * Effect results are passed to the caller, including errors.
-       */
-      <TData = A>(options?: CustomUndefinedInitialQueryOptions<A, KnownFiberFailure<E>, TData>): readonly [
-        ComputedRef<AsyncResult.AsyncResult<A, E>>,
-        ComputedRef<A | undefined>,
-        (options?: RefetchOptions) => Effect.Effect<QueryObserverResult<TData, KnownFiberFailure<E>>>,
-        UseQueryReturnType<any, any>
-      ]
-    }
-    /**
-     * Effect results are passed to the caller, including errors.
-     * @deprecated use client helpers instead (.query())
-     */
-    <Arg, E, A, Request extends Req, Name extends string>(
-      self: RequestHandlerWithInput<Arg, A, E, R, Request, Name>
+    <I, E, A, Request extends Req, Name extends string>(
+      self: RequestHandlerWithInput<I, A, E, R, Request, Name>
     ): {
-      // required options, with initialData
-      /**
-       * Effect results are passed to the caller, including errors.
-       */
       <TData = A>(
-        arg: Arg | WatchSource<Arg>,
-        options: CustomDefinedInitialQueryOptions<A, KnownFiberFailure<E>, TData>
+        arg: I | WatchSource<I>,
+        options: CustomDefinedInitialQueryOptions<A, CauseException<E>, TData>
       ): readonly [
         ComputedRef<AsyncResult.AsyncResult<TData, E>>,
         ComputedRef<TData>,
-        (options?: RefetchOptions) => Effect.Effect<QueryObserverResult<TData, KnownFiberFailure<E>>>,
+        (options?: RefetchOptions) => Effect.Effect<QueryObserverResult<TData, CauseException<E>>>,
         UseQueryReturnType<any, any>
       ]
-      // required options, with placeholderData
-      /**
-       * Effect results are passed to the caller, including errors.
-       */
       <TData = A>(
-        arg: Arg | WatchSource<Arg>,
-        options: CustomDefinedPlaceholderQueryOptions<A, KnownFiberFailure<E>, TData>
+        arg: I | WatchSource<I>,
+        options: CustomDefinedPlaceholderQueryOptions<A, CauseException<E>, TData>
       ): readonly [
         ComputedRef<AsyncResult.AsyncResult<TData, E>>,
         ComputedRef<TData>,
-        (options?: RefetchOptions) => Effect.Effect<QueryObserverResult<TData, KnownFiberFailure<E>>>,
+        (options?: RefetchOptions) => Effect.Effect<QueryObserverResult<TData, CauseException<E>>>,
         UseQueryReturnType<any, any>
       ]
-      // optional options, optional A
-      /**
-       * Effect results are passed to the caller, including errors.
-       */
       <TData = A>(
-        arg: Arg | WatchSource<Arg>,
-        options?: CustomUndefinedInitialQueryOptions<A, KnownFiberFailure<E>, TData>
+        arg: I | WatchSource<I>,
+        options?: CustomUndefinedInitialQueryOptions<A, CauseException<E>, TData>
       ): readonly [
         ComputedRef<AsyncResult.AsyncResult<TData, E>>,
         ComputedRef<TData | undefined>,
-        (options?: RefetchOptions) => Effect.Effect<QueryObserverResult<TData, KnownFiberFailure<E>>>,
+        (options?: RefetchOptions) => Effect.Effect<QueryObserverResult<TData, CauseException<E>>>,
         UseQueryReturnType<any, any>
       ]
     }
-  } = (
+  } = ((
     self: any
   ) => {
     const q = useQuery_(self)
-
-    return (argOrOptions?: any, options?: any) =>
-      Effect.isEffect(self.handler)
-        ? q(undefined, argOrOptions)
-        : q(argOrOptions, options)
-  }
+    return (arg?: any, options?: any) => q(arg, options)
+  }) as any
   return useQuery
 }
 
 // eslint-disable-next-line @typescript-eslint/no-empty-object-type
 export interface MakeQuery2<R> extends ReturnType<typeof makeQuery<R>> {}
 
+type StreamQueryResult<A, E> = readonly [
+  ComputedRef<AsyncResult.AsyncResult<A[], E>>,
+  ComputedRef<A[] | undefined>,
+  (options?: RefetchOptions) => Effect.Effect<QueryObserverResult<A[], CauseException<E>>>,
+  UseQueryReturnType<any, any>
+]
+
+export const makeStreamQuery = <R>(getRuntime: () => Context.Context<R>) => {
+  const streamQuery_: {
+    <I, E, A, Request extends Req, Name extends string>(
+      q: RequestStreamHandlerWithInput<I, A, E, R, Request, Name>
+    ): (arg: I | WatchSource<I>) => StreamQueryResult<A, E>
+  } = (q: any) => (arg?: any) => {
+    const context = getRuntime()
+    const arr = arg
+    const req: { value: any } | undefined = !arg
+      ? undefined
+      : typeof arr === "function"
+      ? ({
+        get value() {
+          return arr()
+        }
+      })
+      : ref(arg)
+    const queryKey = makeQueryKey(q)
+
+    const r = useTanstackQuery<any[], CauseException<any>, any[]>(
+      {
+        throwOnError: false,
+        retry: (retryCount: number, error: unknown) => {
+          if (error instanceof CauseException) {
+            if (!isHttpClientError(error.cause) && !S.is(ServiceUnavailableError)(error.cause)) {
+              return false
+            }
+          }
+          return retryCount < 5
+        },
+        queryKey: [...queryKey, req],
+        queryFn: streamedQuery({
+          streamFn: () => {
+            const stream = q.handler(req?.value)
+            return streamToAsyncIterableWithCauseException(stream, context, q.id)
+          }
+        })
+      }
+    )
+
+    const latestSuccess = shallowRef<any[]>()
+    const result = computed((): AsyncResult.AsyncResult<any[], any> =>
+      swrToQuery({
+        error: r.error.value ?? undefined,
+        data: r.data.value === undefined ? latestSuccess.value : r.data.value,
+        isValidating: r.isFetching.value
+      })
+    )
+    watch(result, (value) => latestSuccess.value = Option.getOrUndefined(AsyncResult.value(value)), { immediate: true })
+
+    return [
+      result,
+      computed(() => latestSuccess.value),
+      (options?: RefetchOptions) =>
+        Effect.currentSpan.pipe(
+          Effect.orElseSucceed(() => null),
+          Effect.flatMap((span) => Effect.promise(() => r.refetch({ ...options, updateMeta: { span } })))
+        ),
+      r
+    ] as any
+  }
+
+  return streamQuery_
+}
+
+// eslint-disable-next-line @typescript-eslint/no-empty-object-type
+export interface MakeStreamQuery2<R> extends ReturnType<typeof makeStreamQuery<R>> {}
+
 function orPrevious<E, A>(result: AsyncResult.AsyncResult<A, E>) {
   return AsyncResult.isFailure(result) && Option.isSome(result.previousSuccess)
     ? AsyncResult.success(result.previousSuccess.value, { waiting: result.waiting })
@@ -400,20 +433,13 @@ export const useUpdateQuery = () => {
   const queryClient = useQueryClient()
 
   const f: {
-    <A>(
-      query: RequestHandler<A, any, any, any, any>,
-      updater: (data: NoInfer<A>) => NoInfer<A>
-    ): void
     <I, A>(
       query: RequestHandlerWithInput<I, A, any, any, any, any>,
       input: I,
       updater: (data: NoInfer<A>) => NoInfer<A>
     ): void
-  } = (query: any, updateOrInput: any, updaterMaybe?: any) => {
-    const updater = updaterMaybe !== undefined ? updaterMaybe : updateOrInput
-    const key = updaterMaybe !== undefined
-      ? [...makeQueryKey(query), updateOrInput]
-      : makeQueryKey(query)
+  } = (query: any, input: any, updater: any) => {
+    const key = [...makeQueryKey(query), input]
     const data = queryClient.getQueryData(key)
     if (data) {
       queryClient.setQueryData(key, updater)

package/src/runtime.ts

@@ -1,31 +1,52 @@
-import { ManagedRuntime } from "effect"
+import { Exit, flow, ManagedRuntime } from "effect"
 import { Effect, Layer, Logger } from "effect-app"
+import { CauseException } from "effect-app/client/errors"
+import { type Context } from "effect-app/Context"
 
-export function makeAppRuntime<A, E>(layer: Layer.Layer<A, E>) {
-  return Effect.gen(function*() {
-    const l = layer.pipe(
-      Layer.provide(Logger.layer([Logger.consolePretty()]))
-    ) as Layer.Layer<A, never>
-    const mrt = ManagedRuntime.make(l)
-    yield* mrt.servicesEffect
-    return Object.assign(mrt, {
-      [Symbol.dispose]() {
-        return Effect.runSync(mrt.disposeEffect)
-      },
+export const makeAppRuntime = Effect.fnUntraced(function*<A, E>(layer: Layer.Layer<A, E>) {
+  const l = layer.pipe(
+    Layer.provide(Logger.layer([Logger.consolePretty()]))
+  ) as Layer.Layer<A>
+  const mrt = ManagedRuntime.make(l)
+  yield* mrt.contextEffect
+  return Object.assign(mrt, {
+    [Symbol.dispose]() {
+      return Effect.runSync(mrt.disposeEffect)
+    },
 
-      [Symbol.asyncDispose]() {
-        return mrt.dispose()
-      }
-    }) // as we initialise here, there is no more error left.
-  })
-}
+    [Symbol.asyncDispose]() {
+      return mrt.dispose()
+    }
+  }) // as we initialise here, there is no more error left.
+})
 
-export function initializeSync<A, E>(layer: Layer.Layer<A, E, never>) {
+export function initializeSync<A, E>(layer: Layer.Layer<A, E>) {
   const runtime = Effect.runSync(makeAppRuntime(layer))
   return runtime
 }
 
-export function initializeAsync<A, E>(layer: Layer.Layer<A, E, never>) {
+export function initializeAsync<A, E>(layer: Layer.Layer<A, E>) {
   return Effect
     .runPromise(makeAppRuntime(layer))
 }
+
+// we wrap into CauseException because we want to keep the full cause of the failure.
+export const makeRunPromise = <T>(services: Context<T>) =>
+  flow(Effect.runPromiseExitWith(services), (_) =>
+    _.then(
+      Exit.match({
+        onFailure: (cause) => Promise.reject(new CauseException(cause, "runPromise")),
+        onSuccess: (value) => Promise.resolve(value)
+      })
+    ))
+
+export const makeRunSync = <T>(services: Context<T>) =>
+  flow(
+    Effect.runSyncExitWith(services),
+    Exit.match({
+      onFailure: (cause) => {
+        throw new CauseException(cause, "runSync")
+      },
+      onSuccess: (value) => value
+    })
+  )

package/src/{experimental/toast.ts → toast.ts}

@@ -1,5 +1,5 @@
-import { Effect, Option, ServiceMap } from "effect-app"
-import { proxify } from "effect-app/ServiceMap"
+import { Context, Effect, Option } from "effect-app"
+import { accessEffectFn } from "effect-app/Context"
 
 export type ToastId = string | number
 export type ToastOpts = { id?: ToastId; timeout?: number }
@@ -13,7 +13,7 @@ export type UseToast = () => {
   dismiss: (this: void, id: ToastId) => void
 }
 
-export class CurrentToastId extends ServiceMap.Opaque<CurrentToastId, { toastId: ToastId }>()("CurrentToastId") {}
+export class CurrentToastId extends Context.Opaque<CurrentToastId, { toastId: ToastId }>()("CurrentToastId") {}
 
 /** fallback to CurrentToastId when available unless id is explicitly set to a value or null */
 export const wrap = (toast: ReturnType<UseToast>) => {
@@ -41,26 +41,12 @@ export const wrap = (toast: ReturnType<UseToast>) => {
   }
 }
 
-export class Toast
-  extends proxify(ServiceMap.Opaque<Toast, ReturnType<typeof wrap>>()("Toast"))<Toast, ReturnType<typeof wrap>>()
-{
-}
-
-// const a = Layer.effect(Toast, Effect.sync(() => Toast.of(null as any)))
-
-// const A = Toast.of({
-//   error: () => Effect.succeed(null as any),
-//   info: () => Effect.succeed(null as any),
-//   success: () => Effect.succeed(null as any),
-//   warning: () => Effect.succeed(null as any),
-//   dismiss: () => Effect.succeed(null as any)
-// })
+type ToastShape = ReturnType<typeof wrap>
 
-// const b = Toast.info("test")
-
-// const a2 = Toast.use((_) => _.error("test"))
-
-// const b2 = Effect.gen(function*() {
-//   const toast = yield* Toast
-//   toast.error("test")
-// })
+export class Toast extends Context.Opaque<Toast, ToastShape>()("Toast") {
+  static readonly error = accessEffectFn(this, "error")
+  static readonly info = accessEffectFn(this, "info")
+  static readonly success = accessEffectFn(this, "success")
+  static readonly warning = accessEffectFn(this, "warning")
+  static readonly dismiss = accessEffectFn(this, "dismiss")
+}