packages/effect-fc/src/Query.ts

@@ -1,4 +1,4 @@
-import { type Cause, type Context, type Duration, Effect, Fiber, identity, Option, Pipeable, Predicate, type Scope, Stream, type Subscribable, SubscriptionRef } from "effect"
+import { type Cause, type Context, DateTime, type Duration, Effect, Fiber, HashMap, identity, Option, Pipeable, Predicate, type Scope, Stream, type Subscribable, SubscriptionRef } from "effect"
 import * as QueryClient from "./QueryClient.js"
 import * as Result from "./Result.js"
 
@@ -143,6 +143,31 @@ extends Pipeable.Class() implements Query<K, A, E, R, P> {
             ),
         ) as Effect.Effect<Result.Final<A, E, P>>
     }
+
+    getCacheEntry(
+        key: K
+    ): Effect.Effect<Option.Option<QueryClient.QueryClientCacheEntry>, never, QueryClient.QueryClient> {
+        return QueryClient.QueryClient.pipe(
+            Effect.andThen(client => client.cache),
+            Effect.map(HashMap.get(new QueryClient.QueryClientCacheKey(key, this.f as (key: Query.AnyKey) => Effect.Effect<unknown, unknown, unknown>))),
+        )
+    }
+
+    updateCacheEntry(
+        key: K,
+        result: Result.Success<A>,
+    ): Effect.Effect<QueryClient.QueryClientCacheEntry, never, QueryClient.QueryClient> {
+        return Effect.Do.pipe(
+            Effect.bind("client", () => QueryClient.QueryClient),
+            Effect.bind("now", () => DateTime.now),
+            Effect.let("entry", ({ now }) => new QueryClient.QueryClientCacheEntry(result, now)),
+            Effect.tap(({ client, entry }) => SubscriptionRef.update(
+                client.cache,
+                HashMap.set(new QueryClient.QueryClientCacheKey(key, this.f as (key: Query.AnyKey) => Effect.Effect<unknown, unknown, unknown>), entry),
+            )),
+            Effect.map(({ entry }) => entry),
+        )
+    }
 }
 
 export const isQuery = (u: unknown): u is Query<readonly unknown[], unknown, unknown, unknown, unknown> => Predicate.hasProperty(u, QueryTypeId)

packages/effect-fc/src/QueryClient.ts

@@ -97,7 +97,7 @@ implements Pipeable.Pipeable {
     readonly [QueryClientCacheEntryTypeId]: QueryClientCacheEntryTypeId = QueryClientCacheEntryTypeId
 
     constructor(
-        readonly result: Result.Final<unknown, unknown, unknown>,
+        readonly result: Result.Success<unknown>,
         readonly createdAt: DateTime.DateTime,
     ) {
         super()

packages/effect-fc/src/Result.ts

@@ -4,19 +4,20 @@ import { Cause, Context, Data, Effect, Equal, Exit, type Fiber, Hash, Layer, Mat
 export const ResultTypeId: unique symbol = Symbol.for("@effect-fc/Result/Result")
 export type ResultTypeId = typeof ResultTypeId
 
-export type Result<A, E = never, P = never> = ResultState<A, E, P> & (ResultState<A, E, P> | Optimistic)
+export type Result<A, E = never, P = never> = (
-type ResultState<A, E = never, P = never> = (
     | Initial
     | Running<P>
     | Final<A, E, P>
-)
+// biome-ignore lint/complexity/noBannedTypes: relevant here
+) & ({} | Optimistic)
 
 export type Final<A, E = never, P = never> = (
-    & FinalState<A, E>
+    & (Success<A> | Failure<A, E>)
-    & (FinalState<A, E> | Refreshing<P>)
+    // biome-ignore lint/complexity/noBannedTypes: relevant here
-    & (FinalState<A, E> | Optimistic)
+    & ({} | Refreshing<P>)
+    // biome-ignore lint/complexity/noBannedTypes: relevant here
+    & ({} | Optimistic)
 )
-type FinalState<A, E = never> = Success<A> | Failure<A, E>
 
 export namespace Result {
     export interface Prototype extends Pipeable.Pipeable, Equal.Equal {