@playfast/reform 1.2.0 → 1.2.1

package/src/calc/asyncCalc.test.ts

@@ -1,10 +1,36 @@
 import { expect, it } from '@effect/vitest'
-import { Data, Duration, Effect, Layer, Schema as S } from 'effect'
-import { AsyncCalc, Engine, Event, State, StateGroup } from '../index'
-import { makeFlightGate, tick, until } from '../testkit/flight.testkit'
+import { Data, Effect, Layer, MutableRef, Schema as S } from 'effect'
+import { AsyncCalc, Engine, Event, Reducer, State, StateGroup } from '../index'
+import { makeFlightGate, until } from '../testkit/flight.testkit'
 
 class Boom extends Data.TaggedError('Boom')<{ readonly message: string }> {}
 
+interface Notifier {
+  readonly subscribe: (listener: () => void) => () => void
+}
+
+// The notification scheduler drains every listener of a write in one pass, and a
+// driver subscribes before the test does: our own notification proves its
+// trigger already ran, so an inert change can be asserted without waiting.
+const afterNotify = <A, E, R>(
+  source: Notifier,
+  write: Effect.Effect<A, E, R>,
+): Effect.Effect<void, E, R> =>
+  Effect.suspend(() => {
+    const fired = MutableRef.make(false)
+    const off = source.subscribe(() => MutableRef.set(fired, true))
+    return write.pipe(
+      Effect.zipRight(
+        until(
+          () => MutableRef.get(fired),
+          (value) => value,
+        ),
+      ),
+      Effect.ensuring(Effect.sync(off)),
+      Effect.asVoid,
+    )
+  })
+
 it.live('runs the query and resolves Loading -> Success', () => {
   class Count extends State.make('count', S.Number) {}
   class Inputs extends StateGroup.make(Count) {}
@@ -13,16 +39,24 @@ it.live('runs the query and resolves Loading -> Success', () => {
     output: S.Number,
     alwaysOn: true,
   }) {}
+  const gate = makeFlightGate()
+  // Armed before the layer builds, so the very first flight parks at the gate.
+  Effect.runSync(gate.hold)
   const DoubledLive = AsyncCalc.live(Doubled, {
-    query: ({ count }) => Effect.succeed(count * 2).pipe(Effect.delay(Duration.millis(20))),
+    query: ({ count }) => gate.through(Effect.succeed(count * 2)),
   })
   const TestLayer = DoubledLive.pipe(Layer.provideMerge(StateGroup.live(Inputs, { count: 5 })))
 
   return Effect.gen(function* () {
     const store = yield* Doubled.store
+    yield* gate.awaitEntry(1)
     expect(store.get()._tag).toBe('Loading')
-    yield* tick(40)
-    const value = store.get()
+
+    yield* gate.release
+    const value = yield* until(
+      () => store.get(),
+      (state) => state._tag === 'Success',
+    )
     expect(value._tag).toBe('Success')
     if (value._tag === 'Success') {
       expect(value.value).toBe(10)
@@ -47,8 +81,10 @@ it.live('a failing query resolves to Error carrying the failure', () => {
 
   return Effect.gen(function* () {
     const store = yield* Q.store
-    yield* tick()
-    const value = store.get()
+    const value = yield* until(
+      () => store.get(),
+      (state) => state._tag === 'Error',
+    )
     expect(value._tag).toBe('Error')
     if (value._tag === 'Error') {
       expect(value.error.message).toBe('nope')
@@ -65,23 +101,33 @@ it.live('a dependency change re-fetches, keeping the last value with refetching:
     output: S.Number,
     alwaysOn: true,
   }) {}
+  const gate = makeFlightGate()
   const DoubledLive = AsyncCalc.live(Doubled, {
-    query: ({ count }) => Effect.succeed(count * 2).pipe(Effect.delay(Duration.millis(20))),
+    query: ({ count }) => gate.through(Effect.succeed(count * 2)),
   })
   const TestLayer = DoubledLive.pipe(Layer.provideMerge(StateGroup.live(Inputs, { count: 5 })))
 
   return Effect.gen(function* () {
     const source = yield* StateGroup.select(Inputs, 'count').store
     const store = yield* Doubled.store
-    yield* tick(40)
+    yield* until(
+      () => store.get(),
+      (v) => v._tag === 'Success',
+    )
     expect(store.get()).toMatchObject({ _tag: 'Success', value: 10, refetching: false })
 
+    // Hold the re-fetch at the gate: the previous value stays visible under it.
+    yield* gate.hold
     source.set(7)
-    yield* tick(5)
+    yield* gate.awaitEntry(2)
     expect(store.get()).toMatchObject({ _tag: 'Success', value: 10, refetching: true })
 
-    yield* tick(40)
-    expect(store.get()).toMatchObject({ _tag: 'Success', value: 14, refetching: false })
+    yield* gate.release
+    const settled = yield* until(
+      () => store.get(),
+      (v) => v._tag === 'Success' && v.refetching === false,
+    )
+    expect(settled).toMatchObject({ _tag: 'Success', value: 14, refetching: false })
   }).pipe(Effect.provide(TestLayer))
 })
 
@@ -94,24 +140,35 @@ it.live('latest-wins: a rapid second change cancels the in-flight run', () => {
     output: S.Number,
     alwaysOn: true,
   }) {}
+  const gate = makeFlightGate()
   const DoubledLive = AsyncCalc.live(Doubled, {
     query: ({ count }) =>
-      Effect.sync(() => {
-        runs.n += 1
-        return count * 2
-      }).pipe(Effect.delay(Duration.millis(25))),
+      gate.through(
+        Effect.sync(() => {
+          runs.n += 1
+          return count * 2
+        }),
+      ),
   })
   const TestLayer = DoubledLive.pipe(Layer.provideMerge(StateGroup.live(Inputs, { count: 1 })))
 
   return Effect.gen(function* () {
     const source = yield* StateGroup.select(Inputs, 'count').store
     const store = yield* Doubled.store
-    yield* tick(40)
+    yield* until(
+      () => store.get(),
+      (v) => v._tag === 'Success',
+    )
     expect(store.get()).toMatchObject({ _tag: 'Success', value: 2 })
 
+    // `4` lands while `3` is still parked at the gate, so it can only win by
+    // cancelling it.
+    yield* gate.hold
     source.set(3)
-    yield* tick(5)
+    yield* gate.awaitEntry(2)
     source.set(4)
+    yield* gate.awaitEntry(3)
+    yield* gate.release
     const settled = yield* until(
       () => store.get(),
       (v) => v._tag === 'Success' && v.refetching === false && v.value !== 2,
@@ -127,8 +184,9 @@ it.live('a gated query starts Idle while disabled and runs once enabled', () =>
     inputs: [StateGroup.select(Inputs, 'count')],
     output: S.Number,
   }) {}
+  const gate = makeFlightGate()
   const DoubledLive = AsyncCalc.live(Doubled, {
-    query: ({ count }) => Effect.succeed(count * 2),
+    query: ({ count }) => gate.through(Effect.succeed(count * 2)),
     disabled: ({ count }) => count < 0,
   })
   const TestLayer = DoubledLive.pipe(Layer.provideMerge(StateGroup.live(Inputs, { count: -1 })))
@@ -136,12 +194,16 @@ it.live('a gated query starts Idle while disabled and runs once enabled', () =>
   return Effect.gen(function* () {
     const source = yield* StateGroup.select(Inputs, 'count').store
     const store = yield* Doubled.store
-    yield* tick()
     expect(store.get()._tag).toBe('Idle')
 
     source.set(5)
-    yield* tick()
-    expect(store.get()).toMatchObject({ _tag: 'Success', value: 10 })
+    const settled = yield* until(
+      () => store.get(),
+      (v) => v._tag === 'Success',
+    )
+    expect(settled).toMatchObject({ _tag: 'Success', value: 10 })
+    // Exactly one flight ever ran: the disabled window produced none.
+    expect(gate.entered()).toBe(1)
   }).pipe(Effect.provide(TestLayer))
 })
 
@@ -155,12 +217,15 @@ it.live('invalidateBy: an input change outside the key does not re-fetch', () =>
     output: S.Number,
     alwaysOn: true,
   }) {}
+  const gate = makeFlightGate()
   const QLive = AsyncCalc.live(Q, {
     query: ({ page }) =>
-      Effect.sync(() => {
-        runs.n += 1
-        return page
-      }),
+      gate.through(
+        Effect.sync(() => {
+          runs.n += 1
+          return page
+        }),
+      ),
     invalidateBy: ({ page }) => [page],
   })
   const TestLayer = QLive.pipe(
@@ -171,17 +236,27 @@ it.live('invalidateBy: an input change outside the key does not re-fetch', () =>
     const status = yield* StateGroup.select(Inputs, 'status').store
     const page = yield* StateGroup.select(Inputs, 'page').store
     const store = yield* Q.store
-    yield* tick()
+    yield* until(
+      () => store.get(),
+      (v) => v._tag === 'Success',
+    )
     expect(runs.n).toBe(1)
 
-    status.set('b')
-    yield* tick()
+    // Holding the gate means any flight the status churn triggered would still
+    // be marked fetching here, and could not have settled back out of view.
+    yield* gate.hold
+    yield* afterNotify(status, Effect.sync(() => status.set('b')))
+    expect(store.get()).toMatchObject({ _tag: 'Success', refetching: false })
     expect(runs.n).toBe(1)
+    yield* gate.release
 
     page.set(2)
-    yield* tick()
+    const settled = yield* until(
+      () => store.get(),
+      (v) => v._tag === 'Success' && v.refetching === false && v.value === 2,
+    )
     expect(runs.n).toBe(2)
-    expect(store.get()).toMatchObject({ _tag: 'Success', value: 2 })
+    expect(settled).toMatchObject({ _tag: 'Success', value: 2 })
   }).pipe(Effect.provide(TestLayer))
 })
 
@@ -258,14 +333,13 @@ it.live(
       )
       expect(completed).toEqual([1])
 
-      // Hold the `2` flight at the gate so 3 and 4 land while it is in flight.
+      // Hold the `2` flight at the gate so 3 and 4 land, in that order, while it
+      // is in flight.
       yield* gate.hold
       source.set(2)
       yield* gate.awaitEntry(2)
-      source.set(3)
-      yield* tick(5)
-      source.set(4)
-      yield* tick(5)
+      yield* afterNotify(source, Effect.sync(() => source.set(3)))
+      yield* afterNotify(source, Effect.sync(() => source.set(4)))
       yield* gate.release
       const settled = yield* until(
         () => store.get(),
@@ -287,8 +361,15 @@ it.live(
       output: S.Number,
       alwaysOn: true,
     }) {}
+    // Two gates: one parks the flight the burst interrupts, the other parks the
+    // trailing run, so the stale settle in between is a stable state, not a race.
+    const firstGate = makeFlightGate()
+    const trailingGate = makeFlightGate()
     const DoubledLive = AsyncCalc.live(Doubled, {
-      query: ({ count }) => Effect.succeed(count * 2).pipe(Effect.delay(Duration.millis(30))),
+      query: ({ count }) =>
+        count === 3
+          ? trailingGate.through(Effect.succeed(count * 2))
+          : firstGate.through(Effect.succeed(count * 2)),
       coalesce: 'trailing',
     })
     const TestLayer = DoubledLive.pipe(Layer.provideMerge(StateGroup.live(Inputs, { count: 1 })))
@@ -301,15 +382,17 @@ it.live(
         (v) => v._tag === 'Success',
       )
 
+      yield* firstGate.hold
+      yield* trailingGate.hold
       source.set(2)
-      yield* tick(5)
-      source.set(3)
-      const midflight = yield* until(
-        () => store.get(),
-        (v) => v._tag === 'Success' && v.value === 4,
-      )
-      expect(midflight).toMatchObject({ _tag: 'Success', value: 4, refetching: true })
+      yield* firstGate.awaitEntry(2)
+      yield* afterNotify(source, Effect.sync(() => source.set(3)))
 
+      yield* firstGate.release
+      yield* trailingGate.awaitEntry(1)
+      expect(store.get()).toMatchObject({ _tag: 'Success', value: 4, refetching: true })
+
+      yield* trailingGate.release
       const settled = yield* until(
         () => store.get(),
         (v) => v._tag === 'Success' && v.refetching === false,
@@ -354,17 +437,14 @@ it.live('coalesce trailing: a disable while a request waits in the slot skips th
     yield* gate.hold
     source.set(2)
     yield* gate.awaitEntry(2)
-    source.set(3)
-    yield* tick(5)
-    source.set(-1)
-    yield* tick(5)
+    yield* afterNotify(source, Effect.sync(() => source.set(3)))
+    yield* afterNotify(source, Effect.sync(() => source.set(-1)))
     yield* gate.release
-    // Asserting an absence: give the consumer a real window to wake and (wrongly)
-    // run the queued key. A slow machine only widens the window, never narrows it.
-    yield* tick(60)
     expect(store.get()._tag).toBe('Idle')
     expect(completed).toEqual([1, 2])
 
+    // The queue is FIFO: once 5 has landed, 3's fate is settled, and it must not
+    // appear between them.
     source.set(5)
     const settled = yield* until(
       () => store.get(),
@@ -385,12 +465,15 @@ it.live('invalidateOn: dispatching a listed event re-fetches with refetching: tr
     output: S.Number,
     alwaysOn: true,
   }) {}
+  const gate = makeFlightGate()
   const QLive = AsyncCalc.live(Q, {
     query: ({ count }) =>
-      Effect.sync(() => {
-        runs.n += 1
-        return count * 2
-      }).pipe(Effect.delay(Duration.millis(15))),
+      gate.through(
+        Effect.sync(() => {
+          runs.n += 1
+          return count * 2
+        }),
+      ),
     invalidateOn: [Poke],
   })
   const TestLayer = QLive.pipe(
@@ -400,15 +483,24 @@ it.live('invalidateOn: dispatching a listed event re-fetches with refetching: tr
 
   return Effect.gen(function* () {
     const store = yield* Q.store
-    yield* tick(30)
+    yield* until(
+      () => store.get(),
+      (v) => v._tag === 'Success' && v.refetching === false,
+    )
     expect(store.get()).toMatchObject({ _tag: 'Success', value: 4, refetching: false })
     expect(runs.n).toBe(1)
 
+    yield* gate.hold
     yield* Event.dispatch(Poke, {})
-    yield* tick(5)
+    yield* gate.awaitEntry(2)
     expect(store.get()).toMatchObject({ _tag: 'Success', value: 4, refetching: true })
-    yield* tick(30)
-    expect(store.get()).toMatchObject({ _tag: 'Success', value: 4, refetching: false })
+
+    yield* gate.release
+    const settled = yield* until(
+      () => store.get(),
+      (v) => v._tag === 'Success' && v.refetching === false,
+    )
+    expect(settled).toMatchObject({ _tag: 'Success', value: 4, refetching: false })
     expect(runs.n).toBe(2)
   }).pipe(Effect.provide(TestLayer))
 })
@@ -426,12 +518,15 @@ it.live(
       output: S.Number,
       alwaysOn: true,
     }) {}
+    const gate = makeFlightGate()
     const QLive = AsyncCalc.live(Q, {
       query: ({ page }) =>
-        Effect.sync(() => {
-          runs.n += 1
-          return page
-        }),
+        gate.through(
+          Effect.sync(() => {
+            runs.n += 1
+            return page
+          }),
+        ),
       invalidateBy: ({ page }) => [page],
       invalidateOn: [Poke],
     })
@@ -442,15 +537,21 @@ it.live(
 
     return Effect.gen(function* () {
       const status = yield* StateGroup.select(Inputs, 'status').store
-      yield* tick()
+      const store = yield* Q.store
+      yield* until(
+        () => store.get(),
+        (v) => v._tag === 'Success' && v.refetching === false,
+      )
       expect(runs.n).toBe(1)
 
-      status.set('b')
-      yield* tick()
+      yield* gate.hold
+      yield* afterNotify(status, Effect.sync(() => status.set('b')))
+      expect(store.get()).toMatchObject({ _tag: 'Success', refetching: false })
       expect(runs.n).toBe(1)
+      yield* gate.release
 
       yield* Event.dispatch(Poke, {})
-      yield* tick()
+      yield* gate.awaitEntry(2)
       expect(runs.n).toBe(2)
     }).pipe(Effect.provide(TestLayer))
   },
@@ -462,6 +563,10 @@ it.live(
     class Count extends State.make('count', S.Number) {}
     class Inputs extends StateGroup.make(Count) {}
     class Poke extends Event.make('Poke', S.Struct({})) {}
+    // A second reducer on the same event: reducers of one frame apply in a single
+    // pass, so this state landing proves the query's revision write landed too.
+    class Pokes extends State.make('pokes', S.Number) {}
+    const PokesReducer = Reducer.make('pokes', { states: [Pokes], events: [Poke] })
     const runs = { n: 0 }
     class Q extends AsyncCalc.make('Q', {
       inputs: [StateGroup.select(Inputs, 'count')],
@@ -476,25 +581,33 @@ it.live(
       disabled: ({ count }) => count < 0,
       invalidateOn: [Poke],
     })
-    const TestLayer = QLive.pipe(
+    const TestLayer = Layer.mergeAll(
+      QLive,
+      Reducer.live(PokesReducer, (seen) => seen + 1),
+    ).pipe(
       Layer.provideMerge(StateGroup.live(Inputs, { count: -1 })),
+      Layer.provideMerge(State.live(Pokes, 0)),
       Layer.provideMerge(Engine),
     )
 
     return Effect.gen(function* () {
       const source = yield* StateGroup.select(Inputs, 'count').store
+      const pokes = yield* Pokes.store
       const store = yield* Q.store
-      yield* tick()
       expect(store.get()._tag).toBe('Idle')
 
-      yield* Event.dispatch(Poke, {})
-      yield* tick()
+      // An enqueued run marks the state fetching before it can run, so staying
+      // Idle across the frame is proof that nothing was enqueued.
+      yield* afterNotify(pokes, Event.dispatch(Poke, {}))
       expect(store.get()._tag).toBe('Idle')
       expect(runs.n).toBe(0)
 
       source.set(5)
-      yield* tick()
-      expect(store.get()).toMatchObject({ _tag: 'Success', value: 10 })
+      const settled = yield* until(
+        () => store.get(),
+        (v) => v._tag === 'Success',
+      )
+      expect(settled).toMatchObject({ _tag: 'Success', value: 10 })
       expect(runs.n).toBe(1)
     }).pipe(Effect.provide(TestLayer))
   },
@@ -516,35 +629,62 @@ it.live('invalidateOn: two async calcs keep independent hidden revisions', () =>
     output: S.Number,
     alwaysOn: true,
   }) {}
+  const gateA = makeFlightGate()
+  const gateB = makeFlightGate()
   const TestLayer = Layer.mergeAll(
     AsyncCalc.live(QA, {
       query: ({ count }) =>
-        Effect.sync(() => {
-          runs.a += 1
-          return count
-        }),
+        gateA.through(
+          Effect.sync(() => {
+            runs.a += 1
+            return count
+          }),
+        ),
       invalidateOn: [PokeA],
     }),
     AsyncCalc.live(QB, {
       query: ({ count }) =>
-        Effect.sync(() => {
-          runs.b += 1
-          return count
-        }),
+        gateB.through(
+          Effect.sync(() => {
+            runs.b += 1
+            return count
+          }),
+        ),
       invalidateOn: [PokeB],
     }),
   ).pipe(Layer.provideMerge(StateGroup.live(Inputs, { count: 1 })), Layer.provideMerge(Engine))
 
   return Effect.gen(function* () {
-    yield* tick()
+    const storeA = yield* QA.store
+    const storeB = yield* QB.store
+    yield* until(
+      () => storeA.get()._tag === 'Success' && storeB.get()._tag === 'Success',
+      (both) => both,
+    )
     expect(runs).toEqual({ a: 1, b: 1 })
 
+    // B's gate is held, so a revision leak from PokeA would leave B visibly
+    // fetching instead of settling back out of sight.
+    yield* gateB.hold
     yield* Event.dispatch(PokeA, {})
-    yield* tick()
+    yield* gateA.awaitEntry(2)
+    yield* until(
+      () => storeA.get(),
+      (v) => v._tag === 'Success' && v.refetching === false,
+    )
+    expect(storeB.get()).toMatchObject({ _tag: 'Success', refetching: false })
     expect(runs).toEqual({ a: 2, b: 1 })
+    yield* gateB.release
 
+    yield* gateA.hold
     yield* Event.dispatch(PokeB, {})
-    yield* tick()
+    yield* gateB.awaitEntry(2)
+    yield* until(
+      () => storeB.get(),
+      (v) => v._tag === 'Success' && v.refetching === false,
+    )
+    expect(storeA.get()).toMatchObject({ _tag: 'Success', refetching: false })
     expect(runs).toEqual({ a: 2, b: 2 })
+    yield* gateA.release
   }).pipe(Effect.provide(TestLayer))
 })