Refactor Mutation

packages/effect-fc/src/Mutation.ts

@@ -16,6 +16,7 @@ extends Pipeable.Pipeable {
     readonly latestKey: Subscribable.Subscribable<Option.Option<K>>
     readonly fiber: Subscribable.Subscribable<Option.Option<Fiber.Fiber<A, E>>>
     readonly result: Subscribable.Subscribable<Result.Result<A, E, P>>
+    readonly latestFinalResult: Subscribable.Subscribable<Option.Option<Result.Final<A, E, P>>>
 
     mutate(key: K): Effect.Effect<Result.Final<A, E, P>>
     mutateSubscribable(key: K): Effect.Effect<Subscribable.Subscribable<Result.Result<A, E, P>>>
@@ -37,20 +38,23 @@ extends Pipeable.Class() implements Mutation<K, A, E, R, P> {
         readonly latestKey: SubscriptionRef.SubscriptionRef<Option.Option<K>>,
         readonly fiber: SubscriptionRef.SubscriptionRef<Option.Option<Fiber.Fiber<A, E>>>,
         readonly result: SubscriptionRef.SubscriptionRef<Result.Result<A, E, P>>,
+        readonly latestFinalResult: SubscriptionRef.SubscriptionRef<Option.Option<Result.Final<A, E, P>>>,
     ) {
         super()
     }
 
     mutate(key: K): Effect.Effect<Result.Final<A, E, P>> {
         return SubscriptionRef.set(this.latestKey, Option.some(key)).pipe(
-            Effect.andThen(Effect.provide(this.start(key), this.context)),
+            Effect.andThen(this.start(key)),
             Effect.andThen(sub => this.watch(sub)),
+            Effect.provide(this.context),
         )
     }
     mutateSubscribable(key: K): Effect.Effect<Subscribable.Subscribable<Result.Result<A, E, P>>> {
-        return Effect.andThen(
-            SubscriptionRef.set(this.latestKey, Option.some(key)),
-            Effect.provide(this.start(key), this.context)
+        return SubscriptionRef.set(this.latestKey, Option.some(key)).pipe(
+            Effect.andThen(this.start(key)),
+            Effect.tap(sub => Effect.forkScoped(this.watch(sub))),
+            Effect.provide(this.context),
         )
     }
 
@@ -59,12 +63,8 @@ extends Pipeable.Class() implements Mutation<K, A, E, R, P> {
         never,
         Scope.Scope | R
     > {
-        return this.result.pipe(
-            Effect.map(previous => Result.isFinal(previous)
-                ? previous
-                : undefined
-            ),
-            Effect.andThen(previous => Result.unsafeForkEffect(
+        return this.latestFinalResult.pipe(
+            Effect.andThen(initial => Result.unsafeForkEffect(
                 Effect.onExit(this.f(key), () => Effect.andThen(
                     Effect.all([Effect.fiberId, this.fiber]),
                     ([currentFiberId, fiber]) => Option.match(fiber, {
@@ -76,8 +76,8 @@ extends Pipeable.Class() implements Mutation<K, A, E, R, P> {
                 )),
 
                 {
+                    initial: Option.isSome(initial) ? Result.willFetch(initial.value) : Result.initial(),
                     initialProgress: this.initialProgress,
-                    previous,
                 } as Result.unsafeForkEffect.Options<A, E, P>,
             )),
             Effect.tap(([, fiber]) => SubscriptionRef.set(this.fiber, Option.some(fiber))),
@@ -88,14 +88,14 @@ extends Pipeable.Class() implements Mutation<K, A, E, R, P> {
     watch(
         sub: Subscribable.Subscribable<Result.Result<A, E, P>>
     ): Effect.Effect<Result.Final<A, E, P>> {
-        return Effect.andThen(
-            sub.get,
-            initial => Stream.runFoldEffect(
-                Stream.filter(sub.changes, Predicate.not(Result.isInitial)),
+        return sub.get.pipe(
+            Effect.andThen(initial => Stream.runFoldEffect(
+                sub.changes,
                 initial,
                 (_, result) => Effect.as(SubscriptionRef.set(this.result, result), result),
-            ),
-        ) as Effect.Effect<Result.Final<A, E, P>>
+            ) as Effect.Effect<Result.Final<A, E, P>>),
+            Effect.tap(result => SubscriptionRef.set(this.latestFinalResult, Option.some(result))),
+        )
     }
 }
 
@@ -123,5 +123,6 @@ export const make = Effect.fnUntraced(function* <const K extends Mutation.AnyKey
         yield* SubscriptionRef.make(Option.none<K>()),
         yield* SubscriptionRef.make(Option.none<Fiber.Fiber<A, E>>()),
         yield* SubscriptionRef.make(Result.initial<A, E, P>()),
+        yield* SubscriptionRef.make(Option.none<Result.Final<A, E, P>>()),
     )
 })

packages/effect-fc/src/Query.ts

@@ -203,7 +203,7 @@ extends Pipeable.Class() implements Query<K, A, E, R, P> {
     ): Effect.Effect<Result.Final<A, E, P>> {
         return sub.get.pipe(
             Effect.andThen(initial => Stream.runFoldEffect(
-                Stream.filter(sub.changes, Predicate.not(Result.isInitial)),
+                sub.changes,
                 initial,
                 (_, result) => Effect.as(SubscriptionRef.set(this.result, result), result),
             ) as Effect.Effect<Result.Final<A, E, P>>),

packages/example/src/routes/query.tsx

@@ -28,7 +28,7 @@ const ResultView = Component.makeUntraced("Result")(function*() {
                 Effect.andThen(response => response.json),
                 Effect.andThen(Schema.decodeUnknown(Post)),
             ),
-            staleTime: "1 minutes",
+            staleTime: "10 seconds",
         })
 
         const mutation = yield* Mutation.make({
@@ -86,7 +86,6 @@ const ResultView = Component.makeUntraced("Result")(function*() {
 
                 <Flex direction="row" justify="center" align="center" gap="1">
                     <Button onClick={() => runPromise(query.refresh)}>Refresh</Button>
-                    <Button onClick={() => runPromise(query.refetch)}>Refetch</Button>
                     <Button onClick={() => runPromise(query.invalidateCache)}>Invalidate cache</Button>
                 </Flex>