@playfast/reform-proof 0.1.0 → 1.1.1

package/src/execution.ts

@@ -0,0 +1,100 @@
+import { Cause, Effect, Option, Ref } from 'effect'
+import { yieldWrapGet } from 'effect/Utils'
+import {
+  Bus,
+  type CompositionService,
+  publish,
+  type Scene,
+  sceneInstrumentation,
+} from '@playfast/reform'
+import type { DriveResult, Proof, ProofResult, StepFrame } from './index'
+import { makeFacadeEffect } from './facade'
+import { makeSink, messageOf, proofLayer, type RuntimeServices, type Sink } from './sink'
+import type { PumpStep } from './treeBindings'
+
+const missingCoverage = (proof: Proof, dispatched: Set<string>): ReadonlyArray<string> =>
+  Option.match(proof.requirement.manifest.events, {
+    onNone: () => [],
+    onSome: (declared) => declared.map(String).filter((event) => !dispatched.has(event)),
+  })
+
+const bootScene = (scene: Scene): Effect.Effect<void, never, Bus> =>
+  Effect.forEach(
+    Option.getOrElse(Option.fromNullable(scene.boot), () => []),
+    (event) => publish('High', event),
+  ).pipe(Effect.asVoid)
+
+const executeProofEffect = Effect.fn('executeProofEffect')(function* (
+  proof: Proof,
+  sink: Sink,
+): Effect.fn.Return<ProofResult, never, RuntimeServices> {
+  const dispatched = new Set<string>()
+  const statement = proof.requirement.manifest.statement
+  return yield* Effect.gen(function* () {
+    const { facade, settle } = yield* makeFacadeEffect(proof.scene.composition, sink, dispatched)
+    yield* bootScene(proof.scene)
+    yield* settle
+    yield* Effect.gen(() => proof.body(facade))
+    const missing = missingCoverage(proof, dispatched)
+    const coverageError = `requirement declares events never dispatched: ${missing.join(', ')}`
+    return missing.length > 0
+      ? { requirement: statement, ok: false, error: coverageError }
+      : { requirement: statement, ok: true }
+  }).pipe(
+    Effect.catchAllCause((cause) =>
+      Effect.succeed({ requirement: statement, ok: false, error: messageOf(Cause.squash(cause)) }),
+    ),
+  )
+})
+
+export const executeProof = async (proof: Proof): Promise<ProofResult> => {
+  const sink = makeSink(sceneInstrumentation(proof.scene))
+  return Effect.runPromise(executeProofEffect(proof, sink).pipe(Effect.provide(proofLayer(proof.scene, sink))))
+}
+
+const driveProofEffect = Effect.fn('driveProofEffect')(function* (
+  proof: Proof,
+  sink: Sink,
+): Effect.fn.Return<DriveResult, never, RuntimeServices> {
+  const frames = yield* Ref.make<ReadonlyArray<StepFrame>>([])
+  const statement = proof.requirement.manifest.statement
+  const dispatched = new Set<string>()
+  const record = (index: number): Effect.Effect<void> =>
+    Ref.update(frames, (current) => [...current, { index, captures: [...sink.captures] }])
+  const pump = Effect.fn('pump')(function* (
+    generator: ReturnType<Proof['body']>,
+    step: PumpStep,
+  ): Effect.fn.Return<void, unknown, CompositionService> {
+    const next = generator.next(step.input)
+    if (next.done === true) {
+      return
+    }
+    const output = yield* yieldWrapGet(next.value)
+    yield* record(step.index)
+    yield* pump(generator, { input: output, index: step.index + 1 })
+  })
+  return yield* Effect.gen(function* () {
+    const { facade, settle } = yield* makeFacadeEffect(proof.scene.composition, sink, dispatched)
+    yield* bootScene(proof.scene)
+    yield* settle
+    yield* record(0)
+    yield* pump(proof.body(facade), { input: undefined, index: 1 })
+    return { requirement: statement, frames: yield* Ref.get(frames), ok: true }
+  }).pipe(
+    Effect.catchAllCause((cause) =>
+      Ref.get(frames).pipe(
+        Effect.map((collected) => ({
+          requirement: statement,
+          frames: collected,
+          ok: false,
+          error: messageOf(Cause.squash(cause)),
+        })),
+      ),
+    ),
+  )
+})
+
+export const driveProof = async (proof: Proof): Promise<DriveResult> => {
+  const sink = makeSink(sceneInstrumentation(proof.scene))
+  return Effect.runPromise(driveProofEffect(proof, sink).pipe(Effect.provide(proofLayer(proof.scene, sink))))
+}

package/src/facade.ts

@@ -0,0 +1,258 @@
+import { Array as Arr, Effect, ManagedRuntime, Option, Schema as S } from 'effect'
+import {
+  Composition,
+  type CompositionClass,
+  type CompositionService,
+  isStructure,
+  type RenderEnv,
+  type SlotChild,
+  type SlotClass,
+  type Trigger,
+  type UiCapture,
+  type UiContract,
+} from '@playfast/reform'
+import { AssertionFailed, UnknownAction, UnknownSlot } from './errors'
+import { matchProps } from './assertions'
+import type { Action, Facade, SlotFacade } from './index'
+import {
+  keyed,
+  SETTLE_MAX_RENDERS,
+  SETTLE_STEP,
+  settleDrain,
+  type RuntimeServices,
+  type Sink,
+  uiNameOf,
+} from './sink'
+import {
+  collectBindings,
+  driveStructure,
+  type Mounted,
+  type NodeRef,
+  type SettleProgress,
+  slotsOf,
+} from './treeBindings'
+
+type AnyFacade = Facade<UiContract>
+type AnySlotFacade = SlotFacade<UiContract>
+const encodeUnknown = S.encodeSync(S.parseJson(S.Unknown))
+
+const renderMounted = Effect.fn('renderMounted')(function* (
+  mounted: Mounted,
+  bindings: ReadonlyMap<SlotClass, CompositionClass<unknown>>,
+  sink: Sink,
+): Effect.fn.Return<ReadonlyArray<Mounted>, never, CompositionService> {
+  const service = yield* mounted.comp.tag
+  const env: RenderEnv = { props: mounted.props, tracker: { add: () => {} } }
+  const endRenderSpan = sink.instrumentation.uiRendered(uiNameOf(mounted.comp))
+  const frame = yield* Composition.render(service, env)
+  endRenderSpan()
+  if (!isStructure(frame)) {
+    return yield* Effect.dieMessage(
+      `reform-proof: composition ${uiNameOf(mounted.comp)} did not return a Structure`,
+    )
+  }
+  return driveStructure(mounted.comp, frame, mounted.key, sink, bindings)
+})
+
+const renderLevel: (
+  frontier: ReadonlyArray<Mounted>,
+  bindings: ReadonlyMap<SlotClass, CompositionClass<unknown>>,
+  sink: Sink,
+) => Effect.Effect<void, never, CompositionService> = Effect.fn('renderLevel')(function* (
+  frontier: ReadonlyArray<Mounted>,
+  bindings: ReadonlyMap<SlotClass, CompositionClass<unknown>>,
+  sink: Sink,
+): Effect.fn.Return<void, never, CompositionService> {
+  if (frontier.length === 0) {
+    return
+  }
+  const levels = yield* Effect.forEach(frontier, (mounted) =>
+    renderMounted(mounted, bindings, sink),
+  )
+  yield* renderLevel(levels.flat(), bindings, sink)
+})
+
+const renderTree = Effect.fn('renderTree')(function* (
+  root: CompositionClass<unknown>,
+  bindings: ReadonlyMap<SlotClass, CompositionClass<unknown>>,
+  sink: Sink,
+): Effect.fn.Return<void, never, CompositionService> {
+  sink.reset()
+  yield* renderLevel([{ comp: root, props: {}, key: Option.none() }], bindings, sink)
+})
+
+export const capturesFor = (sink: Sink, name: string): ReadonlyArray<UiCapture> =>
+  sink.captures.filter((capture) => capture.name === name)
+
+export const fingerprint = (sink: Sink): string =>
+  encodeUnknown(sink.captures.map((capture) => [capture.name, capture.props]))
+
+const settleTree = Effect.fn('settleTree')(function* (
+  root: CompositionClass<unknown>,
+  bindings: ReadonlyMap<SlotClass, CompositionClass<unknown>>,
+  sink: Sink,
+): Effect.fn.Return<void, never, CompositionService> {
+  yield* settleDrain
+  yield* renderTree(root, bindings, sink)
+  yield* Effect.iterate(
+    {
+      previous: fingerprint(sink),
+      remaining: SETTLE_MAX_RENDERS,
+      stable: false,
+    },
+    {
+      while: (progress: SettleProgress) => !progress.stable && progress.remaining > 0,
+      body: (progress) =>
+        Effect.gen(function* () {
+          yield* settleDrain
+          yield* Effect.sleep(SETTLE_STEP)
+          yield* renderTree(root, bindings, sink)
+          const current = fingerprint(sink)
+          return {
+            previous: current,
+            remaining: progress.remaining - 1,
+            stable: current === progress.previous,
+          }
+        }),
+    },
+  )
+})
+
+export const makeFacadeEffect: (
+  root: CompositionClass<unknown>,
+  sink: Sink,
+  dispatched: Set<string>,
+) => Effect.Effect<
+  {
+    readonly facade: AnyFacade
+    readonly settle: Effect.Effect<void, never, CompositionService>
+  },
+  never,
+  SlotChild
+> = Effect.fn('makeFacadeEffect')(function* (
+  root: CompositionClass<unknown>,
+  sink: Sink,
+  dispatched: Set<string>,
+): Effect.fn.Return<
+  {
+    readonly facade: AnyFacade
+    readonly settle: Effect.Effect<void, never, CompositionService>
+  },
+  never,
+  SlotChild
+> {
+  const bindings = yield* collectBindings(root)
+  const settle = settleTree(root, bindings, sink)
+  const rerender = renderTree(root, bindings, sink)
+
+  const triggerOf = (ref: NodeRef, event: string): Effect.Effect<Trigger<unknown>> =>
+    Option.match(Option.fromNullable(capturesFor(sink, ref.name)[ref.index]?.events[event]), {
+      onNone: () =>
+        Effect.dieMessage(
+          new UnknownAction({
+            composition: ref.name,
+            action: event,
+            rendered: capturesFor(sink, ref.name).length,
+          }).message,
+        ),
+      onSome: Effect.succeed,
+    })
+
+  const propsFor = (ref: NodeRef): Effect.Effect<unknown, never, CompositionService> =>
+    Effect.map(rerender, () => capturesFor(sink, ref.name)[ref.index]?.props)
+
+  const nodeFacade = (ref: NodeRef, comp: CompositionClass<unknown>): AnyFacade => ({
+    props: propsFor(ref),
+    expectProps: (partial) =>
+      propsFor(ref).pipe(
+        Effect.flatMap((props) => {
+          const mismatch = matchProps({ actual: props, expected: partial })
+          return mismatch === undefined
+            ? Effect.void
+            : Effect.dieMessage(new AssertionFailed({ detail: mismatch }).message)
+        }),
+      ),
+    actions: keyed(
+      (event): Action =>
+        (payload) =>
+          rerender.pipe(
+            Effect.flatMap(() => triggerOf(ref, event)),
+            Effect.flatMap((trigger) =>
+              Effect.sync(() => {
+                dispatched.add(event)
+                trigger(payload)
+              }),
+            ),
+            Effect.flatMap(() => settle),
+            Effect.flatMap(() => propsFor(ref)),
+          ),
+    ),
+    slots: keyed((slotName) => slotFacade(comp, slotName)),
+    frame: settle,
+  })
+
+  const slotFacade = (parent: CompositionClass<unknown>, slotName: string): AnySlotFacade => {
+    const slotClass = slotsOf(parent)[slotName]
+    const child = slotClass && bindings.get(slotClass)
+    if (child === undefined) {
+      return Effect.runSync(
+        Effect.dieMessage(new UnknownSlot({ parent: uiNameOf(parent), slot: slotName }).message),
+      )
+    }
+    const childName = uiNameOf(child)
+    const atIndex = (index: number): Effect.Effect<AnyFacade, never, CompositionService> =>
+      Effect.as(rerender, nodeFacade({ name: childName, index }, child))
+    const first = nodeFacade({ name: childName, index: 0 }, child)
+    const indexOfKey = (key: string): Option.Option<number> =>
+      Arr.findFirstIndex(capturesFor(sink, childName), (capture) => capture.key === key)
+    return {
+      first: atIndex(0),
+      at: atIndex,
+      all: Effect.map(rerender, () =>
+        capturesFor(sink, childName).map((_capture, index) =>
+          nodeFacade({ name: childName, index }, child),
+        ),
+      ),
+      byKey: (key) =>
+        Effect.flatMap(rerender, () =>
+          Option.match(indexOfKey(key), {
+            onNone: () =>
+              Effect.dieMessage(
+                new UnknownSlot({
+                  parent: uiNameOf(parent),
+                  slot: `${slotName}[key=${key}]`,
+                }).message,
+              ),
+            onSome: (index) => Effect.succeed(nodeFacade({ name: childName, index }, child)),
+          }),
+        ),
+      where: (predicate) =>
+        Effect.map(rerender, () =>
+          capturesFor(sink, childName).flatMap((capture, index) =>
+            predicate(capture.props) ? [nodeFacade({ name: childName, index }, child)] : [],
+          ),
+        ),
+      count: Effect.map(rerender, () => capturesFor(sink, childName).length),
+      props: first.props,
+      expectProps: first.expectProps,
+      actions: first.actions,
+      slots: first.slots,
+      frame: first.frame,
+    }
+  }
+
+  return {
+    facade: nodeFacade({ name: uiNameOf(root), index: 0 }, root),
+    settle,
+  }
+})
+
+export const makeFacade = (
+  runtime: ManagedRuntime.ManagedRuntime<RuntimeServices, never>,
+  root: CompositionClass<unknown>,
+  sink: Sink,
+  dispatched: Set<string>,
+): {
+  readonly facade: AnyFacade
+  readonly settle: Effect.Effect<void, never, CompositionService>
+} => runtime.runSync(makeFacadeEffect(root, sink, dispatched))