@playfast/reform 1.1.1 → 1.2.0

package/src/calc/asyncCalc.test.ts

@@ -1,16 +1,7 @@
 import { expect, it } from '@effect/vitest'
 import { Data, Duration, Effect, Layer, Schema as S } from 'effect'
 import { AsyncCalc, Engine, Event, State, StateGroup } from '../index'
-
-const tick = (ms = 10) => Effect.sleep(Duration.millis(ms))
-
-const until = <A>(read: () => A, pred: (a: A) => boolean, rounds = 200): Effect.Effect<A> =>
-  Effect.suspend(() => {
-    const a = read()
-    return pred(a) || rounds <= 0
-      ? Effect.succeed(a)
-      : Effect.flatMap(tick(10), () => until(read, pred, rounds - 1))
-  })
+import { makeFlightGate, tick, until } from '../testkit/flight.testkit'
 
 class Boom extends Data.TaggedError('Boom')<{ readonly message: string }> {}
 
@@ -216,7 +207,10 @@ it.live('reuse: a refetch returning mostly-equal data keeps unchanged element id
   return Effect.gen(function* () {
     const source = yield* StateGroup.select(Inputs, 'page').store
     const store = yield* Rows.store
-    const first = yield* until(() => store.get(), (v) => v._tag === 'Success')
+    const first = yield* until(
+      () => store.get(),
+      (v) => v._tag === 'Success',
+    )
     if (first._tag !== 'Success') return
 
     source.set(2)
@@ -231,80 +225,99 @@ it.live('reuse: a refetch returning mostly-equal data keeps unchanged element id
   }).pipe(Effect.provide(TestLayer))
 })
 
-it.live('coalesce trailing: a burst during one flight completes it and runs ONE trailing refetch', () => {
-  class Count extends State.make('count', S.Number) {}
-  class Inputs extends StateGroup.make(Count) {}
-  const completed: number[] = []
-  class Doubled extends AsyncCalc.make('Doubled', {
-    inputs: [StateGroup.select(Inputs, 'count')],
-    output: S.Number,
-    alwaysOn: true,
-  }) {}
-  const DoubledLive = AsyncCalc.live(Doubled, {
-    query: ({ count }) =>
-      Effect.sync(() => {
-        completed.push(count)
-        return count * 2
-      }).pipe(Effect.delay(Duration.millis(25))),
-    coalesce: 'trailing',
-  })
-  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* until(() => store.get(), (v) => v._tag === 'Success')
-    expect(completed).toEqual([1])
-
-    source.set(2)
-    yield* tick(5)
-    source.set(3)
-    yield* tick(5)
-    source.set(4)
-    const settled = yield* until(
-      () => store.get(),
-      (v) => v._tag === 'Success' && v.refetching === false && v.value === 8,
-    )
-    expect(settled).toMatchObject({ _tag: 'Success', value: 8, refetching: false })
-    expect(completed).toEqual([1, 2, 4])
-  }).pipe(Effect.provide(TestLayer))
-})
-
-it.live('coalesce trailing: the stale settle re-flags refetching until the trailing run lands', () => {
-  class Count extends State.make('count', S.Number) {}
-  class Inputs extends StateGroup.make(Count) {}
-  class Doubled extends AsyncCalc.make('Doubled', {
-    inputs: [StateGroup.select(Inputs, 'count')],
-    output: S.Number,
-    alwaysOn: true,
-  }) {}
-  const DoubledLive = AsyncCalc.live(Doubled, {
-    query: ({ count }) => Effect.succeed(count * 2).pipe(Effect.delay(Duration.millis(30))),
-    coalesce: 'trailing',
-  })
-  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* until(() => store.get(), (v) => v._tag === 'Success')
-
-    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 })
-
-    const settled = yield* until(
-      () => store.get(),
-      (v) => v._tag === 'Success' && v.refetching === false,
-    )
-    expect(settled).toMatchObject({ _tag: 'Success', value: 6 })
-  }).pipe(Effect.provide(TestLayer))
-})
+it.live(
+  'coalesce trailing: a burst during one flight completes it and runs ONE trailing refetch',
+  () => {
+    class Count extends State.make('count', S.Number) {}
+    class Inputs extends StateGroup.make(Count) {}
+    const completed: number[] = []
+    class Doubled extends AsyncCalc.make('Doubled', {
+      inputs: [StateGroup.select(Inputs, 'count')],
+      output: S.Number,
+      alwaysOn: true,
+    }) {}
+    const gate = makeFlightGate()
+    const DoubledLive = AsyncCalc.live(Doubled, {
+      query: ({ count }) =>
+        gate.through(
+          Effect.sync(() => {
+            completed.push(count)
+            return count * 2
+          }),
+        ),
+      coalesce: 'trailing',
+    })
+    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* until(
+        () => store.get(),
+        (v) => v._tag === 'Success',
+      )
+      expect(completed).toEqual([1])
+
+      // Hold the `2` flight at the gate so 3 and 4 land 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* gate.release
+      const settled = yield* until(
+        () => store.get(),
+        (v) => v._tag === 'Success' && v.refetching === false && v.value === 8,
+      )
+      expect(settled).toMatchObject({ _tag: 'Success', value: 8, refetching: false })
+      expect(completed).toEqual([1, 2, 4])
+    }).pipe(Effect.provide(TestLayer))
+  },
+)
+
+it.live(
+  'coalesce trailing: the stale settle re-flags refetching until the trailing run lands',
+  () => {
+    class Count extends State.make('count', S.Number) {}
+    class Inputs extends StateGroup.make(Count) {}
+    class Doubled extends AsyncCalc.make('Doubled', {
+      inputs: [StateGroup.select(Inputs, 'count')],
+      output: S.Number,
+      alwaysOn: true,
+    }) {}
+    const DoubledLive = AsyncCalc.live(Doubled, {
+      query: ({ count }) => Effect.succeed(count * 2).pipe(Effect.delay(Duration.millis(30))),
+      coalesce: 'trailing',
+    })
+    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* until(
+        () => store.get(),
+        (v) => v._tag === 'Success',
+      )
+
+      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 })
+
+      const settled = yield* until(
+        () => store.get(),
+        (v) => v._tag === 'Success' && v.refetching === false,
+      )
+      expect(settled).toMatchObject({ _tag: 'Success', value: 6 })
+    }).pipe(Effect.provide(TestLayer))
+  },
+)
 
 it.live('coalesce trailing: a disable while a request waits in the slot skips the run', () => {
   class Count extends State.make('count', S.Number) {}
@@ -314,12 +327,15 @@ it.live('coalesce trailing: a disable while a request waits in the slot skips th
     inputs: [StateGroup.select(Inputs, 'count')],
     output: S.Number,
   }) {}
+  const gate = makeFlightGate()
   const QLive = AsyncCalc.live(Q, {
     query: ({ count }) =>
-      Effect.sync(() => {
-        completed.push(count)
-        return count * 2
-      }).pipe(Effect.delay(Duration.millis(25))),
+      gate.through(
+        Effect.sync(() => {
+          completed.push(count)
+          return count * 2
+        }),
+      ),
     disabled: ({ count }) => count < 0,
     coalesce: 'trailing',
   })
@@ -328,19 +344,32 @@ it.live('coalesce trailing: a disable while a request waits in the slot skips th
   return Effect.gen(function* () {
     const source = yield* StateGroup.select(Inputs, 'count').store
     const store = yield* Q.store
-    yield* until(() => store.get(), (v) => v._tag === 'Success')
+    yield* until(
+      () => store.get(),
+      (v) => v._tag === 'Success',
+    )
 
+    // 3 queues behind the held `2` flight, then the disable overtakes it: the
+    // queued run must be dropped, not executed on release.
+    yield* gate.hold
     source.set(2)
-    yield* tick(5)
+    yield* gate.awaitEntry(2)
     source.set(3)
-    yield* tick(2)
+    yield* tick(5)
     source.set(-1)
+    yield* tick(5)
+    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])
 
     source.set(5)
-    const settled = yield* until(() => store.get(), (v) => v._tag === 'Success')
+    const settled = yield* until(
+      () => store.get(),
+      (v) => v._tag === 'Success',
+    )
     expect(settled).toMatchObject({ _tag: 'Success', value: 10 })
     expect(completed).toEqual([1, 2, 5])
   }).pipe(Effect.provide(TestLayer))
@@ -384,86 +413,92 @@ it.live('invalidateOn: dispatching a listed event re-fetches with refetching: tr
   }).pipe(Effect.provide(TestLayer))
 })
 
-it.live('invalidateOn: composes with invalidateBy — non-key churn stays inert, the event re-fetches', () => {
-  class Status extends State.make('status', S.String) {}
-  class Page extends State.make('page', S.Number) {}
-  class Inputs extends StateGroup.make(Status, Page) {}
-  class Poke extends Event.make('Poke', S.Struct({})) {}
-  const runs = { n: 0 }
-  class Q extends AsyncCalc.make('Q', {
-    inputs: [StateGroup.select(Inputs, 'status'), StateGroup.select(Inputs, 'page')],
-    output: S.Number,
-    alwaysOn: true,
-  }) {}
-  const QLive = AsyncCalc.live(Q, {
-    query: ({ page }) =>
-      Effect.sync(() => {
-        runs.n += 1
-        return page
-      }),
-    invalidateBy: ({ page }) => [page],
-    invalidateOn: [Poke],
-  })
-  const TestLayer = QLive.pipe(
-    Layer.provideMerge(StateGroup.live(Inputs, { status: 'a', page: 1 })),
-    Layer.provideMerge(Engine),
-  )
-
-  return Effect.gen(function* () {
-    const status = yield* StateGroup.select(Inputs, 'status').store
-    yield* tick()
-    expect(runs.n).toBe(1)
-
-    status.set('b')
-    yield* tick()
-    expect(runs.n).toBe(1)
-
-    yield* Event.dispatch(Poke, {})
-    yield* tick()
-    expect(runs.n).toBe(2)
-  }).pipe(Effect.provide(TestLayer))
-})
-
-it.live('invalidateOn: a listed event while disabled stays Idle, and enabling re-fetches once', () => {
-  class Count extends State.make('count', S.Number) {}
-  class Inputs extends StateGroup.make(Count) {}
-  class Poke extends Event.make('Poke', S.Struct({})) {}
-  const runs = { n: 0 }
-  class Q extends AsyncCalc.make('Q', {
-    inputs: [StateGroup.select(Inputs, 'count')],
-    output: S.Number,
-  }) {}
-  const QLive = AsyncCalc.live(Q, {
-    query: ({ count }) =>
-      Effect.sync(() => {
-        runs.n += 1
-        return count * 2
-      }),
-    disabled: ({ count }) => count < 0,
-    invalidateOn: [Poke],
-  })
-  const TestLayer = QLive.pipe(
-    Layer.provideMerge(StateGroup.live(Inputs, { count: -1 })),
-    Layer.provideMerge(Engine),
-  )
-
-  return Effect.gen(function* () {
-    const source = yield* StateGroup.select(Inputs, 'count').store
-    const store = yield* Q.store
-    yield* tick()
-    expect(store.get()._tag).toBe('Idle')
+it.live(
+  'invalidateOn: composes with invalidateBy — non-key churn stays inert, the event re-fetches',
+  () => {
+    class Status extends State.make('status', S.String) {}
+    class Page extends State.make('page', S.Number) {}
+    class Inputs extends StateGroup.make(Status, Page) {}
+    class Poke extends Event.make('Poke', S.Struct({})) {}
+    const runs = { n: 0 }
+    class Q extends AsyncCalc.make('Q', {
+      inputs: [StateGroup.select(Inputs, 'status'), StateGroup.select(Inputs, 'page')],
+      output: S.Number,
+      alwaysOn: true,
+    }) {}
+    const QLive = AsyncCalc.live(Q, {
+      query: ({ page }) =>
+        Effect.sync(() => {
+          runs.n += 1
+          return page
+        }),
+      invalidateBy: ({ page }) => [page],
+      invalidateOn: [Poke],
+    })
+    const TestLayer = QLive.pipe(
+      Layer.provideMerge(StateGroup.live(Inputs, { status: 'a', page: 1 })),
+      Layer.provideMerge(Engine),
+    )
 
-    yield* Event.dispatch(Poke, {})
-    yield* tick()
-    expect(store.get()._tag).toBe('Idle')
-    expect(runs.n).toBe(0)
+    return Effect.gen(function* () {
+      const status = yield* StateGroup.select(Inputs, 'status').store
+      yield* tick()
+      expect(runs.n).toBe(1)
+
+      status.set('b')
+      yield* tick()
+      expect(runs.n).toBe(1)
+
+      yield* Event.dispatch(Poke, {})
+      yield* tick()
+      expect(runs.n).toBe(2)
+    }).pipe(Effect.provide(TestLayer))
+  },
+)
+
+it.live(
+  'invalidateOn: a listed event while disabled stays Idle, and enabling re-fetches once',
+  () => {
+    class Count extends State.make('count', S.Number) {}
+    class Inputs extends StateGroup.make(Count) {}
+    class Poke extends Event.make('Poke', S.Struct({})) {}
+    const runs = { n: 0 }
+    class Q extends AsyncCalc.make('Q', {
+      inputs: [StateGroup.select(Inputs, 'count')],
+      output: S.Number,
+    }) {}
+    const QLive = AsyncCalc.live(Q, {
+      query: ({ count }) =>
+        Effect.sync(() => {
+          runs.n += 1
+          return count * 2
+        }),
+      disabled: ({ count }) => count < 0,
+      invalidateOn: [Poke],
+    })
+    const TestLayer = QLive.pipe(
+      Layer.provideMerge(StateGroup.live(Inputs, { count: -1 })),
+      Layer.provideMerge(Engine),
+    )
 
-    source.set(5)
-    yield* tick()
-    expect(store.get()).toMatchObject({ _tag: 'Success', value: 10 })
-    expect(runs.n).toBe(1)
-  }).pipe(Effect.provide(TestLayer))
-})
+    return Effect.gen(function* () {
+      const source = yield* StateGroup.select(Inputs, 'count').store
+      const store = yield* Q.store
+      yield* tick()
+      expect(store.get()._tag).toBe('Idle')
+
+      yield* Event.dispatch(Poke, {})
+      yield* tick()
+      expect(store.get()._tag).toBe('Idle')
+      expect(runs.n).toBe(0)
+
+      source.set(5)
+      yield* tick()
+      expect(store.get()).toMatchObject({ _tag: 'Success', value: 10 })
+      expect(runs.n).toBe(1)
+    }).pipe(Effect.provide(TestLayer))
+  },
+)
 
 it.live('invalidateOn: two async calcs keep independent hidden revisions', () => {
   class Count extends State.make('count', S.Number) {}
@@ -498,10 +533,7 @@ it.live('invalidateOn: two async calcs keep independent hidden revisions', () =>
         }),
       invalidateOn: [PokeB],
     }),
-  ).pipe(
-    Layer.provideMerge(StateGroup.live(Inputs, { count: 1 })),
-    Layer.provideMerge(Engine),
-  )
+  ).pipe(Layer.provideMerge(StateGroup.live(Inputs, { count: 1 })), Layer.provideMerge(Engine))
 
   return Effect.gen(function* () {
     yield* tick()