@reffuse/extension-query 0.1.2 (#8)

Co-authored-by: Julien Valverdé <julien.valverde@mailo.com>
Reviewed-on: https://gitea:3000/Thilawyn/reffuse/pulls/8

packages/example/src/QueryErrorHandler.tsx

@@ -1,5 +1,5 @@
 import { AlertDialog, Button, Flex, Text } from "@radix-ui/themes"
-import { ErrorHandler } from "@reffuse/extension-query"
+import { QueryErrorHandler } from "@reffuse/extension-query"
 import { Cause, Console, Context, Effect, Either, flow, Match, Option, Stream } from "effect"
 import { useState } from "react"
 import { AppQueryErrorHandler } from "./query"
@@ -8,7 +8,7 @@ import { R } from "./reffuse"
 
 export function VQueryErrorHandler() {
     const [failure, setFailure] = useState(Option.none<Cause.Cause<
-        ErrorHandler.Error<Context.Tag.Service<AppQueryErrorHandler>>
+        QueryErrorHandler.Error<Context.Tag.Service<AppQueryErrorHandler>>
     >>())
 
     R.useFork(() => AppQueryErrorHandler.pipe(Effect.flatMap(handler =>

packages/example/src/main.tsx

@@ -6,17 +6,17 @@ import { StrictMode } from "react"
 import { createRoot } from "react-dom/client"
 import { ReffuseRuntime } from "reffuse"
 import { AppQueryClient, AppQueryErrorHandler } from "./query"
-import { GlobalContext } from "./reffuse"
+import { RootContext } from "./reffuse"
 import { routeTree } from "./routeTree.gen"
 
 
 const layer = Layer.empty.pipe(
+    Layer.provideMerge(AppQueryClient.Live),
+    Layer.provideMerge(AppQueryErrorHandler.Live),
     Layer.provideMerge(Clipboard.layer),
     Layer.provideMerge(Geolocation.layer),
     Layer.provideMerge(Permissions.layer),
     Layer.provideMerge(FetchHttpClient.layer),
-    Layer.provideMerge(AppQueryClient.Live),
-    Layer.provideMerge(AppQueryErrorHandler.Live),
 )
 
 const router = createRouter({ routeTree })
@@ -31,9 +31,9 @@ declare module "@tanstack/react-router" {
 createRoot(document.getElementById("root")!).render(
     <StrictMode>
         <ReffuseRuntime.Provider>
-            <GlobalContext.Provider layer={layer}>
+            <RootContext.Provider layer={layer}>
                 <RouterProvider router={router} />
-            </GlobalContext.Provider>
+            </RootContext.Provider>
         </ReffuseRuntime.Provider>
     </StrictMode>
 )

packages/example/src/query.ts

@@ -1,9 +1,9 @@
 import { HttpClientError } from "@effect/platform"
-import { ErrorHandler, QueryClient } from "@reffuse/extension-query"
+import { QueryClient, QueryErrorHandler } from "@reffuse/extension-query"
 import { Effect } from "effect"
 
 
-export class AppQueryErrorHandler extends ErrorHandler.Service<AppQueryErrorHandler,
+export class AppQueryErrorHandler extends QueryErrorHandler.Service<AppQueryErrorHandler,
     HttpClientError.HttpClientError
 >()(
     "AppQueryErrorHandler",

packages/example/src/query/reffuse.ts

@@ -1,10 +1,10 @@
-import { GlobalReffuse } from "@/reffuse"
+import { RootReffuse } from "@/reffuse"
 import { Reffuse, ReffuseContext } from "reffuse"
 import { Uuid4Query } from "./services"
 
 
 export const QueryContext = ReffuseContext.make<Uuid4Query.Uuid4Query>()
 
-export const R = new class QueryReffuse extends GlobalReffuse.pipe(
+export const R = new class QueryReffuse extends RootReffuse.pipe(
     Reffuse.withContexts(QueryContext)
 ) {}

packages/example/src/reffuse.ts

@@ -6,19 +6,19 @@ import { Reffuse, ReffuseContext } from "reffuse"
 import { AppQueryClient, AppQueryErrorHandler } from "./query"
 
 
-export const GlobalContext = ReffuseContext.make<
+export const RootContext = ReffuseContext.make<
+    | AppQueryClient
+    | AppQueryErrorHandler
     | Clipboard.Clipboard
     | Geolocation.Geolocation
     | Permissions.Permissions
     | HttpClient.HttpClient
-    | AppQueryClient
-    | AppQueryErrorHandler
 >()
 
-export class GlobalReffuse extends Reffuse.Reffuse.pipe(
+export class RootReffuse extends Reffuse.Reffuse.pipe(
     Reffuse.withExtension(LazyRefExtension),
     Reffuse.withExtension(QueryExtension),
-    Reffuse.withContexts(GlobalContext),
+    Reffuse.withContexts(RootContext),
 ) {}
 
-export const R = new GlobalReffuse()
+export const R = new RootReffuse()

packages/example/src/todos/reffuse.ts

@@ -1,10 +1,10 @@
-import { GlobalReffuse } from "@/reffuse"
+import { RootReffuse } from "@/reffuse"
 import { Reffuse, ReffuseContext } from "reffuse"
 import { TodosState } from "./services"
 
 
 export const TodosContext = ReffuseContext.make<TodosState.TodosState>()
 
-export const R = new class TodosReffuse extends GlobalReffuse.pipe(
+export const R = new class TodosReffuse extends RootReffuse.pipe(
     Reffuse.withContexts(TodosContext)
 ) {}

packages/extension-query/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reffuse/extension-query",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "type": "module",
   "files": [
     "./README.md",

packages/extension-query/src/ErrorHandler.ts

@@ -1,54 +0,0 @@
-import { Cause, Context, Effect, identity, Layer, Queue, Stream } from "effect"
-import type { Mutable } from "effect/Types"
-
-
-export interface ErrorHandler<E> {
-    readonly errors: Stream.Stream<Cause.Cause<E>>
-    readonly handle: <A, SelfE, R>(self: Effect.Effect<A, SelfE, R>) => Effect.Effect<A, Exclude<SelfE, E>, R>
-}
-
-export type Error<T> = T extends ErrorHandler<infer E> ? E : never
-
-
-export interface ServiceResult<Self, Id extends string, E> extends Context.TagClass<Self, Id, ErrorHandler<E>> {
-    readonly Live: Layer.Layer<Self>
-}
-
-export const Service = <Self, E = never>() => (
-    <const Id extends string>(
-        id: Id,
-        f: <A, R>(
-            self: Effect.Effect<A, E, R>,
-            failure: (failure: E) => Effect.Effect<never>,
-            defect: (defect: unknown) => Effect.Effect<never>,
-        ) => Effect.Effect<A, never, R>,
-    ): ServiceResult<Self, Id, E> => {
-        const TagClass = Context.Tag(id)() as ServiceResult<Self, Id, E>
-
-        (TagClass as Mutable<typeof TagClass>).Live = Layer.effect(TagClass, Effect.gen(function*() {
-            const queue = yield* Queue.unbounded<Cause.Cause<E>>()
-            const errors = Stream.fromQueue(queue)
-
-            const handle = <A, SelfE, R>(
-                self: Effect.Effect<A, SelfE, R>
-            ): Effect.Effect<A, Exclude<SelfE, E>, R> => f(self as unknown as Effect.Effect<A, E, R>,
-                (failure: E) => Queue.offer(queue, Cause.fail(failure)).pipe(
-                    Effect.andThen(Effect.failCause(Cause.empty))
-                ),
-                (defect: unknown) => Queue.offer(queue, Cause.die(defect)).pipe(
-                    Effect.andThen(Effect.failCause(Cause.empty))
-                ),
-            )
-
-            return { errors, handle }
-        }))
-
-        return TagClass
-    }
-)
-
-
-export class DefaultErrorHandler extends Service<DefaultErrorHandler>()(
-    "@reffuse/extension-query/DefaultErrorHandler",
-    identity,
-) {}

packages/extension-query/src/QueryClient.ts

@@ -1,39 +1,65 @@
-import { Context, Layer } from "effect"
+import { Context, Effect, Layer } from "effect"
 import type { Mutable } from "effect/Types"
-import * as ErrorHandler from "./ErrorHandler.js"
+import * as QueryErrorHandler from "./QueryErrorHandler.js"
 
 
-export interface QueryClient<EH, HandledE> {
+export interface QueryClient<FallbackA, HandledE> {
-    readonly ErrorHandler: Context.Tag<EH, ErrorHandler.ErrorHandler<HandledE>>
+    readonly errorHandler: QueryErrorHandler.QueryErrorHandler<FallbackA, HandledE>
 }
 
 
 const id = "@reffuse/extension-query/QueryClient"
 
-export type TagClassShape<EH, HandledE> = Context.TagClassShape<typeof id, QueryClient<EH, HandledE>>
+export type TagClassShape<FallbackA, HandledE> = Context.TagClassShape<typeof id, QueryClient<FallbackA, HandledE>>
-export type GenericTagClass<EH, HandledE> = Context.TagClass<TagClassShape<EH, HandledE>, typeof id, QueryClient<EH, HandledE>>
+export type GenericTagClass<FallbackA, HandledE> = Context.TagClass<
-export const makeGenericTagClass = <EH = never, HandledE = never>(): GenericTagClass<EH, HandledE> => Context.Tag(id)()
+    TagClassShape<FallbackA, HandledE>,
+    typeof id,
+    QueryClient<FallbackA, HandledE>
+>
+export const makeGenericTagClass = <FallbackA = never, HandledE = never>(): GenericTagClass<FallbackA, HandledE> => Context.Tag(id)()
 
 
-export interface ServiceProps<EH, HandledE> {
+export interface ServiceProps<EH, FallbackA, HandledE> {
-    readonly ErrorHandler?: Context.Tag<EH, ErrorHandler.ErrorHandler<HandledE>>
+    readonly ErrorHandler?: Context.Tag<EH, QueryErrorHandler.QueryErrorHandler<FallbackA, HandledE>>
 }
 
-export interface ServiceResult<Self, EH, HandledE> extends Context.TagClass<Self, typeof id, QueryClient<EH, HandledE>> {
+export interface ServiceResult<Self, EH, FallbackA, HandledE> extends Context.TagClass<
-    readonly Live: Layer.Layer<Self>
+    Self,
+    typeof id,
+    QueryClient<FallbackA, HandledE>
+> {
+    readonly Live: Layer.Layer<
+        Self | (EH extends QueryErrorHandler.DefaultQueryErrorHandler ? EH : never),
+        never,
+        EH extends QueryErrorHandler.DefaultQueryErrorHandler ? never : EH
+    >
 }
 
 export const Service = <Self>() => (
     <
-        EH = ErrorHandler.DefaultErrorHandler,
+        EH = QueryErrorHandler.DefaultQueryErrorHandler,
-        HandledE = ErrorHandler.Error<Context.Tag.Service<ErrorHandler.DefaultErrorHandler>>,
+        FallbackA = QueryErrorHandler.Fallback<Context.Tag.Service<QueryErrorHandler.DefaultQueryErrorHandler>>,
+        HandledE = QueryErrorHandler.Error<Context.Tag.Service<QueryErrorHandler.DefaultQueryErrorHandler>>,
     >(
-        props?: ServiceProps<EH, HandledE>
+        props?: ServiceProps<EH, FallbackA, HandledE>
-    ): ServiceResult<Self, EH, HandledE> => {
+    ): ServiceResult<Self, EH, FallbackA, HandledE> => {
-        const TagClass = Context.Tag(id)() as ServiceResult<Self, EH, HandledE>
+        const TagClass = Context.Tag(id)() as ServiceResult<Self, EH, FallbackA, HandledE>
-        (TagClass as Mutable<typeof TagClass>).Live = Layer.succeed(TagClass, {
+
-            ErrorHandler: (props?.ErrorHandler ?? ErrorHandler.DefaultErrorHandler) as Context.Tag<EH, ErrorHandler.ErrorHandler<HandledE>>
+        (TagClass as Mutable<typeof TagClass>).Live = Layer.effect(TagClass, Effect.Do.pipe(
-        })
+            Effect.bind("errorHandler", () =>
+                (props?.ErrorHandler ?? QueryErrorHandler.DefaultQueryErrorHandler) as Effect.Effect<
+                    QueryErrorHandler.QueryErrorHandler<FallbackA, HandledE>,
+                    never,
+                    EH extends QueryErrorHandler.DefaultQueryErrorHandler ? never : EH
+                >
+            )
+        )).pipe(
+            Layer.provideMerge((props?.ErrorHandler
+                ? Layer.empty
+                : QueryErrorHandler.DefaultQueryErrorHandler.Live
+            ) as Layer.Layer<EH>)
+        )
+
         return TagClass
     }
 )

packages/extension-query/src/QueryErrorHandler.ts

@@ -0,0 +1,65 @@
+import { Cause, Context, Effect, identity, Layer, Queue, Stream } from "effect"
+import type { Mutable } from "effect/Types"
+
+
+export interface QueryErrorHandler<FallbackA, HandledE> {
+    readonly errors: Stream.Stream<Cause.Cause<HandledE>>
+    readonly handle: <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A | FallbackA, Exclude<E, HandledE>, R>
+}
+
+export type Fallback<T> = T extends QueryErrorHandler<infer A, any> ? A : never
+export type Error<T> = T extends QueryErrorHandler<any, infer E> ? E : never
+
+
+export interface ServiceResult<
+    Self,
+    Id extends string,
+    FallbackA,
+    HandledE,
+> extends Context.TagClass<
+    Self,
+    Id,
+    QueryErrorHandler<FallbackA, HandledE>
+> {
+    readonly Live: Layer.Layer<Self>
+}
+
+export const Service = <Self, HandledE = never>() => (
+    <const Id extends string, FallbackA>(
+        id: Id,
+        f: (
+            self: Effect.Effect<never, HandledE>,
+            failure: (failure: HandledE) => Effect.Effect<never>,
+            defect: (defect: unknown) => Effect.Effect<never>,
+        ) => Effect.Effect<FallbackA>,
+    ): ServiceResult<Self, Id, FallbackA, HandledE> => {
+        const TagClass = Context.Tag(id)() as ServiceResult<Self, Id, FallbackA, HandledE>
+
+        (TagClass as Mutable<typeof TagClass>).Live = Layer.effect(TagClass, Effect.gen(function*() {
+            const queue = yield* Queue.unbounded<Cause.Cause<HandledE>>()
+            const errors = Stream.fromQueue(queue)
+
+            const handle = <A, E, R>(
+                self: Effect.Effect<A, E, R>
+            ): Effect.Effect<A | FallbackA, Exclude<E, HandledE>, R> => f(
+                self as unknown as Effect.Effect<never, HandledE, never>,
+                (failure: HandledE) => Queue.offer(queue, Cause.fail(failure)).pipe(
+                    Effect.andThen(Effect.failCause(Cause.empty))
+                ),
+                (defect: unknown) => Queue.offer(queue, Cause.die(defect)).pipe(
+                    Effect.andThen(Effect.failCause(Cause.empty))
+                ),
+            )
+
+            return { errors, handle }
+        }))
+
+        return TagClass
+    }
+)
+
+
+export class DefaultQueryErrorHandler extends Service<DefaultQueryErrorHandler>()(
+    "@reffuse/extension-query/DefaultQueryErrorHandler",
+    identity,
+) {}

packages/extension-query/src/QueryExtension.ts

@@ -51,19 +51,19 @@ export interface UseMutationResult<K extends readonly unknown[], A, E> {
 
 export const QueryExtension = ReffuseExtension.make(() => ({
     useQuery<
-        EH,
         QK extends readonly unknown[],
         QA,
+        FallbackA,
         QE,
         HandledE,
         QR extends R,
         R,
     >(
-        this: ReffuseHelpers.ReffuseHelpers<R | QueryClient.TagClassShape<EH, HandledE> | EH>,
+        this: ReffuseHelpers.ReffuseHelpers<R | QueryClient.TagClassShape<FallbackA, HandledE>>,
         props: UseQueryProps<QK, QA, QE, QR>,
-    ): UseQueryResult<QK, QA, Exclude<QE, HandledE>> {
+    ): UseQueryResult<QK, QA | FallbackA, Exclude<QE, HandledE>> {
         const runner = this.useMemo(() => QueryRunner.make({
-            QueryClient: QueryClient.makeGenericTagClass<EH, HandledE>(),
+            QueryClient: QueryClient.makeGenericTagClass<FallbackA, HandledE>(),
             key: props.key,
             query: props.query,
         }), [props.key])
@@ -90,19 +90,19 @@ export const QueryExtension = ReffuseExtension.make(() => ({
     },
 
     useMutation<
-        EH,
         QK extends readonly unknown[],
         QA,
+        FallbackA,
         QE,
         HandledE,
         QR extends R,
         R,
     >(
-        this: ReffuseHelpers.ReffuseHelpers<R | QueryClient.TagClassShape<EH, HandledE> | EH>,
+        this: ReffuseHelpers.ReffuseHelpers<R | QueryClient.TagClassShape<FallbackA, HandledE>>,
         props: UseMutationProps<QK, QA, QE, QR>,
-    ): UseMutationResult<QK, QA, Exclude<QE, HandledE>> {
+    ): UseMutationResult<QK, QA | FallbackA, Exclude<QE, HandledE>> {
         const runner = this.useMemo(() => MutationRunner.make({
-            QueryClient: QueryClient.makeGenericTagClass<EH, HandledE>(),
+            QueryClient: QueryClient.makeGenericTagClass<FallbackA, HandledE>(),
             mutation: props.mutation,
         }), [])
 

packages/extension-query/src/index.ts

@@ -1,6 +1,6 @@
-export * as ErrorHandler from "./ErrorHandler.js"
 export * as MutationService from "./MutationService.js"
 export * as QueryClient from "./QueryClient.js"
+export * as QueryErrorHandler from "./QueryErrorHandler.js"
 export * from "./QueryExtension.js"
 export * as QueryProgress from "./QueryProgress.js"
 export * as QueryService from "./QueryService.js"

packages/extension-query/src/internal/MutationRunner.ts

@@ -17,33 +17,33 @@ export interface MutationRunner<K extends readonly unknown[], A, E, R> {
 }
 
 
-export interface MakeProps<EH, K extends readonly unknown[], A, E, HandledE, R> {
+export interface MakeProps<K extends readonly unknown[], A, FallbackA, E, HandledE, R> {
-    readonly QueryClient: QueryClient.GenericTagClass<EH, HandledE>
+    readonly QueryClient: QueryClient.GenericTagClass<FallbackA, HandledE>
     readonly mutation: (key: K) => Effect.Effect<A, E, R | QueryProgress.QueryProgress>
 }
 
-export const make = <EH, K extends readonly unknown[], A, E, HandledE, R>(
+export const make = <K extends readonly unknown[], A, FallbackA, E, HandledE, R>(
     {
         QueryClient,
         mutation,
-    }: MakeProps<EH, K, A, E, HandledE, R>
+    }: MakeProps<K, A, FallbackA, E, HandledE, R>
 ): Effect.Effect<
-    MutationRunner<K, A, Exclude<E, HandledE>, R>,
+    MutationRunner<K, A | FallbackA, Exclude<E, HandledE>, R>,
     never,
-    R | QueryClient.TagClassShape<EH, HandledE> | EH
+    R | QueryClient.TagClassShape<FallbackA, HandledE>
 > => Effect.gen(function*() {
-    const context = yield* Effect.context<R | QueryClient.TagClassShape<EH, HandledE> | EH>()
+    const context = yield* Effect.context<R | QueryClient.TagClassShape<FallbackA, HandledE>>()
-    const globalStateRef = yield* SubscriptionRef.make(AsyncData.noData<A, Exclude<E, HandledE>>())
+    const globalStateRef = yield* SubscriptionRef.make(AsyncData.noData<A | FallbackA, Exclude<E, HandledE>>())
 
-    const queryStateTag = QueryState.makeTag<A, Exclude<E, HandledE>>()
+    const queryStateTag = QueryState.makeTag<A | FallbackA, Exclude<E, HandledE>>()
 
-    const run = (key: K) => Effect.all([
+    const run = (key: K) => Effect.Do.pipe(
-        queryStateTag,
+        Effect.bind("state", () => queryStateTag),
-        QueryClient.pipe(Effect.flatMap(client => client.ErrorHandler)),
+        Effect.bind("client", () => QueryClient),
-    ]).pipe(
+
-        Effect.flatMap(([state, errorHandler]) => state.set(AsyncData.loading()).pipe(
+        Effect.flatMap(({ state, client }) => state.set(AsyncData.loading()).pipe(
             Effect.andThen(mutation(key)),
-            errorHandler.handle,
+            client.errorHandler.handle,
             Effect.matchCauseEffect({
                 onSuccess: v => Effect.succeed(AsyncData.success(v)).pipe(
                     Effect.tap(state.set)
@@ -64,11 +64,11 @@ export const make = <EH, K extends readonly unknown[], A, E, HandledE, R>(
         value => Ref.set(globalStateRef, value),
     ))
 
-    const forkMutate = (...key: K) => Effect.all([
+    const forkMutate = (...key: K) => Effect.Do.pipe(
-        Ref.make(AsyncData.noData<A, Exclude<E, HandledE>>()),
+        Effect.bind("stateRef", () => Ref.make(AsyncData.noData<A | FallbackA, Exclude<E, HandledE>>())),
-        Queue.unbounded<AsyncData.AsyncData<A, Exclude<E, HandledE>>>(),
+        Effect.bind("stateQueue", () => Queue.unbounded<AsyncData.AsyncData<A | FallbackA, Exclude<E, HandledE>>>()),
-    ]).pipe(
+
-        Effect.flatMap(([stateRef, stateQueue]) =>
+        Effect.flatMap(({ stateRef, stateQueue }) =>
             Effect.addFinalizer(() => Queue.shutdown(stateQueue)).pipe(
                 Effect.andThen(run(key)),
                 Effect.scoped,

packages/extension-query/src/internal/QueryRunner.ts

@@ -31,33 +31,33 @@ export interface QueryRunner<K extends readonly unknown[], A, E, R> {
 }
 
 
-export interface MakeProps<EH, K extends readonly unknown[], A, E, HandledE, R> {
+export interface MakeProps<K extends readonly unknown[], A, FallbackA, E, HandledE, R> {
-    readonly QueryClient: QueryClient.GenericTagClass<EH, HandledE>
+    readonly QueryClient: QueryClient.GenericTagClass<FallbackA, HandledE>
     readonly key: Stream.Stream<K>
     readonly query: (key: K) => Effect.Effect<A, E, R | QueryProgress.QueryProgress>
 }
 
-export const make = <EH, K extends readonly unknown[], A, E, HandledE, R>(
+export const make = <K extends readonly unknown[], A, FallbackA, E, HandledE, R>(
     {
         QueryClient,
         key,
         query,
-    }: MakeProps<EH, K, A, E, HandledE, R>
+    }: MakeProps<K, A, FallbackA, E, HandledE, R>
 ): Effect.Effect<
-    QueryRunner<K, A, Exclude<E, HandledE>, R>,
+    QueryRunner<K, A | FallbackA, Exclude<E, HandledE>, R>,
     never,
-    R | QueryClient.TagClassShape<EH, HandledE> | EH
+    R | QueryClient.TagClassShape<FallbackA, HandledE>
 > => Effect.gen(function*() {
-    const context = yield* Effect.context<R | QueryClient.TagClassShape<EH, HandledE> | EH>()
+    const context = yield* Effect.context<R | QueryClient.TagClassShape<FallbackA, HandledE>>()
 
     const latestKeyRef = yield* SubscriptionRef.make(Option.none<K>())
-    const stateRef = yield* SubscriptionRef.make(AsyncData.noData<A, Exclude<E, HandledE>>())
+    const stateRef = yield* SubscriptionRef.make(AsyncData.noData<A | FallbackA, Exclude<E, HandledE>>())
     const fiberRef = yield* SubscriptionRef.make(Option.none<Fiber.RuntimeFiber<
-        AsyncData.Success<A> | AsyncData.Failure<Exclude<E, HandledE>>,
+        AsyncData.Success<A | FallbackA> | AsyncData.Failure<Exclude<E, HandledE>>,
         Cause.NoSuchElementException
     >>())
 
-    const queryStateTag = QueryState.makeTag<A, Exclude<E, HandledE>>()
+    const queryStateTag = QueryState.makeTag<A | FallbackA, Exclude<E, HandledE>>()
 
     const interrupt = fiberRef.pipe(
         Effect.flatMap(Option.match({
@@ -80,30 +80,28 @@ export const make = <EH, K extends readonly unknown[], A, E, HandledE, R>(
         }))
     )
 
-    const run = Effect.all([
+    const run = Effect.Do.pipe(
-        queryStateTag,
+        Effect.bind("state", () => queryStateTag),
-        QueryClient.pipe(Effect.flatMap(client => client.ErrorHandler)),
+        Effect.bind("client", () => QueryClient),
-    ]).pipe(
+        Effect.bind("latestKey", () => latestKeyRef.pipe(Effect.flatMap(identity))),
-        Effect.flatMap(([state, errorHandler]) => latestKeyRef.pipe(
+
-            Effect.flatMap(identity),
+        Effect.flatMap(({ state, client, latestKey }) => query(latestKey).pipe(
-            Effect.flatMap(key => query(key).pipe(
+            client.errorHandler.handle,
-                errorHandler.handle,
+            Effect.matchCauseEffect({
-                Effect.matchCauseEffect({
+                onSuccess: v => Effect.succeed(AsyncData.success(v)).pipe(
-                    onSuccess: v => Effect.succeed(AsyncData.success(v)).pipe(
+                    Effect.tap(state.set)
-                        Effect.tap(state.set)
+                ),
-                    ),
+                onFailure: c => Effect.succeed(AsyncData.failure(c)).pipe(
-                    onFailure: c => Effect.succeed(AsyncData.failure(c)).pipe(
+                    Effect.tap(state.set)
-                        Effect.tap(state.set)
+                ),
-                    ),
+            }),
-                }),
-            )),
         )),
 
         Effect.provide(context),
         Effect.provide(QueryProgress.QueryProgress.Live),
     )
 
-    const forkFetch = Queue.unbounded<AsyncData.AsyncData<A, Exclude<E, HandledE>>>().pipe(
+    const forkFetch = Queue.unbounded<AsyncData.AsyncData<A | FallbackA, Exclude<E, HandledE>>>().pipe(
         Effect.flatMap(stateQueue => queryStateTag.pipe(
             Effect.flatMap(state => interrupt.pipe(
                 Effect.andThen(Effect.addFinalizer(() => Ref.set(fiberRef, Option.none()).pipe(
@@ -139,7 +137,7 @@ export const make = <EH, K extends readonly unknown[], A, E, HandledE, R>(
         }))
     )
 
-    const forkRefresh = Queue.unbounded<AsyncData.AsyncData<A, Exclude<E, HandledE>>>().pipe(
+    const forkRefresh = Queue.unbounded<AsyncData.AsyncData<A | FallbackA, Exclude<E, HandledE>>>().pipe(
         Effect.flatMap(stateQueue => interrupt.pipe(
             Effect.andThen(Effect.addFinalizer(() => Ref.set(fiberRef, Option.none()).pipe(
                 Effect.andThen(Queue.shutdown(stateQueue))