@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/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> {
-    readonly ErrorHandler: Context.Tag<EH, ErrorHandler.ErrorHandler<HandledE>>
+export interface QueryClient<FallbackA, 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 GenericTagClass<EH, HandledE> = Context.TagClass<TagClassShape<EH, HandledE>, typeof id, QueryClient<EH, HandledE>>
-export const makeGenericTagClass = <EH = never, HandledE = never>(): GenericTagClass<EH, HandledE> => Context.Tag(id)()
+export type TagClassShape<FallbackA, HandledE> = Context.TagClassShape<typeof id, QueryClient<FallbackA, HandledE>>
+export type GenericTagClass<FallbackA, HandledE> = Context.TagClass<
+    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> {
-    readonly ErrorHandler?: Context.Tag<EH, ErrorHandler.ErrorHandler<HandledE>>
+export interface ServiceProps<EH, FallbackA, 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>> {
-    readonly Live: Layer.Layer<Self>
+export interface ServiceResult<Self, EH, FallbackA, HandledE> extends Context.TagClass<
+    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,
-        HandledE = ErrorHandler.Error<Context.Tag.Service<ErrorHandler.DefaultErrorHandler>>,
+        EH = QueryErrorHandler.DefaultQueryErrorHandler,
+        FallbackA = QueryErrorHandler.Fallback<Context.Tag.Service<QueryErrorHandler.DefaultQueryErrorHandler>>,
+        HandledE = QueryErrorHandler.Error<Context.Tag.Service<QueryErrorHandler.DefaultQueryErrorHandler>>,
     >(
-        props?: ServiceProps<EH, HandledE>
-    ): ServiceResult<Self, EH, HandledE> => {
-        const TagClass = Context.Tag(id)() as ServiceResult<Self, EH, HandledE>
-        (TagClass as Mutable<typeof TagClass>).Live = Layer.succeed(TagClass, {
-            ErrorHandler: (props?.ErrorHandler ?? ErrorHandler.DefaultErrorHandler) as Context.Tag<EH, ErrorHandler.ErrorHandler<HandledE>>
-        })
+        props?: ServiceProps<EH, FallbackA, HandledE>
+    ): ServiceResult<Self, EH, FallbackA, HandledE> => {
+        const TagClass = Context.Tag(id)() as ServiceResult<Self, EH, FallbackA, 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> {
-    readonly QueryClient: QueryClient.GenericTagClass<EH, HandledE>
+export interface MakeProps<K extends readonly unknown[], A, FallbackA, E, HandledE, R> {
+    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 globalStateRef = yield* SubscriptionRef.make(AsyncData.noData<A, Exclude<E, HandledE>>())
+    const context = yield* Effect.context<R | QueryClient.TagClassShape<FallbackA, 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([
-        queryStateTag,
-        QueryClient.pipe(Effect.flatMap(client => client.ErrorHandler)),
-    ]).pipe(
-        Effect.flatMap(([state, errorHandler]) => state.set(AsyncData.loading()).pipe(
+    const run = (key: K) => Effect.Do.pipe(
+        Effect.bind("state", () => queryStateTag),
+        Effect.bind("client", () => QueryClient),
+
+        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([
-        Ref.make(AsyncData.noData<A, Exclude<E, HandledE>>()),
-        Queue.unbounded<AsyncData.AsyncData<A, Exclude<E, HandledE>>>(),
-    ]).pipe(
-        Effect.flatMap(([stateRef, stateQueue]) =>
+    const forkMutate = (...key: K) => Effect.Do.pipe(
+        Effect.bind("stateRef", () => Ref.make(AsyncData.noData<A | FallbackA, Exclude<E, HandledE>>())),
+        Effect.bind("stateQueue", () => Queue.unbounded<AsyncData.AsyncData<A | FallbackA, Exclude<E, HandledE>>>()),
+
+        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> {
-    readonly QueryClient: QueryClient.GenericTagClass<EH, HandledE>
+export interface MakeProps<K extends readonly unknown[], A, FallbackA, E, HandledE, R> {
+    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([
-        queryStateTag,
-        QueryClient.pipe(Effect.flatMap(client => client.ErrorHandler)),
-    ]).pipe(
-        Effect.flatMap(([state, errorHandler]) => latestKeyRef.pipe(
-            Effect.flatMap(identity),
-            Effect.flatMap(key => query(key).pipe(
-                errorHandler.handle,
-                Effect.matchCauseEffect({
-                    onSuccess: v => Effect.succeed(AsyncData.success(v)).pipe(
-                        Effect.tap(state.set)
-                    ),
-                    onFailure: c => Effect.succeed(AsyncData.failure(c)).pipe(
-                        Effect.tap(state.set)
-                    ),
-                }),
-            )),
+    const run = Effect.Do.pipe(
+        Effect.bind("state", () => queryStateTag),
+        Effect.bind("client", () => QueryClient),
+        Effect.bind("latestKey", () => latestKeyRef.pipe(Effect.flatMap(identity))),
+
+        Effect.flatMap(({ state, client, latestKey }) => query(latestKey).pipe(
+            client.errorHandler.handle,
+            Effect.matchCauseEffect({
+                onSuccess: v => Effect.succeed(AsyncData.success(v)).pipe(
+                    Effect.tap(state.set)
+                ),
+                onFailure: c => Effect.succeed(AsyncData.failure(c)).pipe(
+                    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))