@reventlessdev/reventless-gwt 1.0.0-alpha.100

package/src/PlatformScan.res.mjs

@@ -0,0 +1,132 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Nodefs from "node:fs";
+import * as Nodepath from "node:path";
+import * as Stdlib_JSON from "@rescript/runtime/lib/es6/Stdlib_JSON.js";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Promises from "node:fs/promises";
+
+let localPlatformDep = "@reventlessdev/reventless-local";
+
+let ignoreNames = [
+  "node_modules",
+  ".git",
+  "dist",
+  "lib",
+  ".history"
+];
+
+function matchPlatform(pkgJsonText, mainExists) {
+  if (!mainExists) {
+    return;
+  }
+  let json;
+  try {
+    json = JSON.parse(pkgJsonText);
+  } catch (exn) {
+    return;
+  }
+  let obj = Stdlib_JSON.Decode.object(json);
+  if (obj === undefined) {
+    return;
+  }
+  let match = obj["name"];
+  let name = typeof match === "string" ? match : "";
+  let depsHave = key => {
+    let deps = Stdlib_Option.flatMap(obj[key], Stdlib_JSON.Decode.object);
+    if (deps !== undefined) {
+      return Stdlib_Option.isSome(deps[localPlatformDep]);
+    } else {
+      return false;
+    }
+  };
+  let dependsOnLocal = depsHave("dependencies") || depsHave("devDependencies") || depsHave("optionalDependencies");
+  if (!dependsOnLocal) {
+    return;
+  }
+  let scripts = Stdlib_Option.flatMap(obj["scripts"], Stdlib_JSON.Decode.object);
+  let serveScript = scripts !== undefined ? (
+      Stdlib_Option.isSome(scripts["serve:memory"]) ? "serve:memory" : (
+          Stdlib_Option.isSome(scripts["serve"]) ? "serve" : undefined
+        )
+    ) : undefined;
+  return [
+    name,
+    serveScript
+  ];
+}
+
+function inspectDir(dir) {
+  let pkgJson = Nodepath.join(dir, "package.json");
+  let mainPath = Nodepath.join(Nodepath.join(dir, "src"), "Main.res.mjs");
+  if (!Nodefs.existsSync(pkgJson)) {
+    return;
+  }
+  let text;
+  try {
+    text = Nodefs.readFileSync(pkgJson, "utf8");
+  } catch (exn) {
+    text = "";
+  }
+  let match = matchPlatform(text, Nodefs.existsSync(mainPath));
+  if (match !== undefined) {
+    return {
+      name: match[0],
+      dir: dir,
+      mainPath: mainPath,
+      serveScript: match[1]
+    };
+  }
+}
+
+async function walk(dir, acc) {
+  let pkg = inspectDir(dir);
+  if (pkg !== undefined) {
+    acc.push(pkg);
+  } else {
+    let entries;
+    try {
+      entries = await Promises.readdir(dir, {
+        withFileTypes: true
+      });
+    } catch (exn) {
+      entries = [];
+    }
+    for (let i = 0, i_finish = entries.length; i < i_finish; ++i) {
+      let entry = entries[i];
+      if (entry.isDirectory() && !ignoreNames.includes(entry.name)) {
+        await walk(Nodepath.join(dir, entry.name), acc);
+      }
+    }
+  }
+  return acc;
+}
+
+async function scan(roots) {
+  let seen = {};
+  let out = [];
+  for (let i = 0, i_finish = roots.length; i < i_finish; ++i) {
+    let found = await walk(roots[i], []);
+    found.forEach(pkg => {
+      let match = seen[pkg.dir];
+      if (match !== undefined) {
+        return;
+      } else {
+        seen[pkg.dir] = true;
+        out.push(pkg);
+        return;
+      }
+    });
+  }
+  return out;
+}
+
+export {
+  localPlatformDep,
+  ignoreNames,
+  matchPlatform,
+  inspectDir,
+  walk,
+  scan,
+}
+/* node:fs Not a pure module */

package/src/ProcessManager.res

@@ -0,0 +1,135 @@
+// Owns the `rescript build -w` watchers a watch session spawns — one per
+// package that owns tests (PackageScan), at most one per directory,
+// reference-counted by `dir`. Registered with Cancellation so SIGINT/SIGTERM
+// tears down every spawned watcher; never orphans a compiler.
+
+type managed = {
+  dir: string,
+  proc: ChildProcess.t,
+}
+
+let running: Dict.t<managed> = Dict.make()
+
+// Per-dir count of unexpected watcher exits, so a build-watcher that crashes on
+// startup (bad config, missing binary) is respawned a bounded number of times
+// rather than either freezing the build status forever or spinning in a tight
+// respawn loop.
+let restarts: Dict.t<int> = Dict.make()
+let maxRestarts = 3
+
+let isManaging = (dir: string): bool =>
+  switch running->Dict.get(dir) {
+  | Some(_) => true
+  | None => false
+  }
+
+// Spawn `pnpm run start` (the package's `rescript build -w`) in `pkg.dir`,
+// unless one is already managed there. `onStdout` receives each output line so
+// the caller can classify compiler markers (Phase 5).
+let rec spawnWatcher = (pkg: PackageScan.pkg, ~onStdout: (string, string) => unit): unit =>
+  switch running->Dict.get(pkg.dir) {
+  | Some(_) => ()
+  | None => {
+      let proc = ChildProcess.spawn("pnpm", ["run", "start"], ~cwd=pkg.dir)
+      ChildProcess.onStdoutLine(proc, line => onStdout(pkg.dir, line))
+      // stderr carries compiler/pnpm crash output; without this a watcher that
+      // dies on stderr was invisible until the caller's 120s watchdog.
+      ChildProcess.onStderrLine(proc, line => onStdout(pkg.dir, line))
+      // A spawn failure ("error") never reaches "close"; surface it as output.
+      ChildProcess.onError(proc, msg => onStdout(pkg.dir, msg))
+      // Detect an unexpected exit. We compare the stored proc identity: an
+      // intentional `stop` deletes the entry synchronously before "close" fires,
+      // so if we still own this exact proc, the watcher crashed — respawn it up
+      // to `maxRestarts` times so build status doesn't freeze.
+      ChildProcess.onClose(proc, _code =>
+        switch running->Dict.get(pkg.dir) {
+        | Some(m) if m.proc === proc =>
+          running->Dict.delete(pkg.dir)
+          let n = restarts->Dict.get(pkg.dir)->Option.getOr(0)
+          if n < maxRestarts {
+            restarts->Dict.set(pkg.dir, n + 1)
+            spawnWatcher(pkg, ~onStdout)
+          }
+        | _ => ()
+        }
+      )
+      running->Dict.set(pkg.dir, {dir: pkg.dir, proc})
+    }
+  }
+
+// Stop just the watcher managed for `dir` (if any), tearing down its process
+// group. Returns true when one was running — i.e. the caller *owned* this
+// package's build (vs. an adopted external watcher, which we can't stop).
+let stop = (dir: string): bool =>
+  switch running->Dict.get(dir) {
+  | Some(m) => {
+      ChildProcess.killTree(m.proc, "SIGTERM")
+      running->Dict.delete(dir)
+      true
+    }
+  | None => false
+  }
+
+// Force a full re-emit of `pkg` after a structural change — a module relocation
+// that incremental compilation can't detect, since it keys invalidation on
+// source + dependency-interface hashes, never on a dependency's filesystem
+// location (see plan Phase 12). Drives a deterministic one-shot `rescript clean`
+// → `rescript build` to completion (the `clean` is what forces every dependent
+// `.res.mjs` to be re-emitted against the new layout; the `build` is essential
+// even on the adopted path — an external watcher won't rebuild after a clean
+// without a fresh source change, so a bare clean would strand the package with
+// no outputs). If we *owned* the package's watcher we stop it first (no lock
+// contention) and respawn it afterward to resume incremental watching; on the
+// adopted path the developer's own watcher keeps running untouched. `onStdout`
+// streams the clean/build output (compiler markers) to the caller; `onDone`
+// fires once the build completes, gating the test re-run.
+let cleanRebuild = (
+  pkg: PackageScan.pkg,
+  ~onStdout: (string, string) => unit,
+  ~onDone: bool => unit,
+): unit => {
+  let wasManaged = stop(pkg.dir)
+  // `next` receives the step's exit code so the chain can tell a failed clean or
+  // build (non-zero / crash) from success — the previous shape discarded exit
+  // codes and always reported the rebuild as OK, masking compile failures.
+  let step = (cmd: string, args: array<string>, next: option<int> => unit): unit => {
+    let proc = ChildProcess.spawn(cmd, args, ~cwd=pkg.dir)
+    // "error" (spawn failure) and "close" can both fire; ensure the chain
+    // advances exactly once.
+    let settled = ref(false)
+    let settle = (code: option<int>) =>
+      if !settled.contents {
+        settled := true
+        next(code)
+      }
+    ChildProcess.onStdoutLine(proc, line => onStdout(pkg.dir, line))
+    ChildProcess.onStderrLine(proc, line => onStdout(pkg.dir, line))
+    ChildProcess.onError(proc, msg => {
+      onStdout(pkg.dir, msg)
+      settle(None)
+    })
+    ChildProcess.onClose(proc, code => settle(code))
+  }
+  step("pnpm", ["exec", "rescript", "clean"], _cleanCode =>
+    step("pnpm", ["exec", "rescript", "build"], buildCode => {
+      if wasManaged {
+        spawnWatcher(pkg, ~onStdout)
+      }
+      onDone(buildCode == Some(0))
+    })
+  )
+}
+
+// SIGTERM, not SIGINT: a POSIX shell sets background children to ignore SIGINT,
+// so SIGINT can leak a watcher; SIGTERM tears down the whole group reliably
+// (verified across foreground and background process-tree shapes).
+let killAll = (): unit => {
+  running
+  ->Dict.valuesToArray
+  ->Array.forEach(m => ChildProcess.killTree(m.proc, "SIGTERM"))
+  running
+  ->Dict.keysToArray
+  ->Array.forEach(k => running->Dict.delete(k))
+}
+
+let managedCount = (): int => running->Dict.keysToArray->Array.length

package/src/ProcessManager.res.mjs

@@ -0,0 +1,119 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stdlib_Dict from "@rescript/runtime/lib/es6/Stdlib_Dict.js";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Primitive_object from "@rescript/runtime/lib/es6/Primitive_object.js";
+import * as ChildProcess$ReventlessGwt from "./ChildProcess.res.mjs";
+
+let running = {};
+
+let restarts = {};
+
+function isManaging(dir) {
+  return running[dir] !== undefined;
+}
+
+function spawnWatcher(pkg, onStdout) {
+  let match = running[pkg.dir];
+  if (match !== undefined) {
+    return;
+  }
+  let proc = ChildProcess$ReventlessGwt.spawn("pnpm", [
+    "run",
+    "start"
+  ], pkg.dir, undefined);
+  ChildProcess$ReventlessGwt.onStdoutLine(proc, line => onStdout(pkg.dir, line));
+  ChildProcess$ReventlessGwt.onStderrLine(proc, line => onStdout(pkg.dir, line));
+  ChildProcess$ReventlessGwt.onError(proc, msg => onStdout(pkg.dir, msg));
+  ChildProcess$ReventlessGwt.onClose(proc, _code => {
+    let m = running[pkg.dir];
+    if (m === undefined) {
+      return;
+    }
+    if (m.proc !== proc) {
+      return;
+    }
+    Stdlib_Dict.$$delete(running, pkg.dir);
+    let n = Stdlib_Option.getOr(restarts[pkg.dir], 0);
+    if (n < 3) {
+      restarts[pkg.dir] = n + 1 | 0;
+      return spawnWatcher(pkg, onStdout);
+    }
+  });
+  running[pkg.dir] = {
+    dir: pkg.dir,
+    proc: proc
+  };
+}
+
+function stop(dir) {
+  let m = running[dir];
+  if (m !== undefined) {
+    ChildProcess$ReventlessGwt.killTree(m.proc, "SIGTERM");
+    Stdlib_Dict.$$delete(running, dir);
+    return true;
+  } else {
+    return false;
+  }
+}
+
+function cleanRebuild(pkg, onStdout, onDone) {
+  let wasManaged = stop(pkg.dir);
+  let step = (cmd, args, next) => {
+    let proc = ChildProcess$ReventlessGwt.spawn(cmd, args, pkg.dir, undefined);
+    let settled = {
+      contents: false
+    };
+    let settle = code => {
+      if (!settled.contents) {
+        settled.contents = true;
+        return next(code);
+      }
+    };
+    ChildProcess$ReventlessGwt.onStdoutLine(proc, line => onStdout(pkg.dir, line));
+    ChildProcess$ReventlessGwt.onStderrLine(proc, line => onStdout(pkg.dir, line));
+    ChildProcess$ReventlessGwt.onError(proc, msg => {
+      onStdout(pkg.dir, msg);
+      settle(undefined);
+    });
+    ChildProcess$ReventlessGwt.onClose(proc, settle);
+  };
+  step("pnpm", [
+    "exec",
+    "rescript",
+    "clean"
+  ], _cleanCode => step("pnpm", [
+    "exec",
+    "rescript",
+    "build"
+  ], buildCode => {
+    if (wasManaged) {
+      spawnWatcher(pkg, onStdout);
+    }
+    onDone(Primitive_object.equal(buildCode, 0));
+  }));
+}
+
+function killAll() {
+  Object.values(running).forEach(m => ChildProcess$ReventlessGwt.killTree(m.proc, "SIGTERM"));
+  Object.keys(running).forEach(k => Stdlib_Dict.$$delete(running, k));
+}
+
+function managedCount() {
+  return Object.keys(running).length;
+}
+
+let maxRestarts = 3;
+
+export {
+  running,
+  restarts,
+  maxRestarts,
+  isManaging,
+  spawnWatcher,
+  stop,
+  cleanRebuild,
+  killAll,
+  managedCount,
+}
+/* ChildProcess-ReventlessGwt Not a pure module */

package/src/Projection_GWT.res

@@ -0,0 +1,312 @@
+open ReventlessCore
+
+// Plan 02 — single-source projection GWT for StateViewSlice (and any future
+// single-source projection target). Promoted from the legacy
+// `StateViewSlice_GWT` so the DSL name now matches the implementation kind
+// emitted by the PPX (`Projection_GWT.Make(Spec, X_Projection)`).
+//
+// Multi-source ReadModel projections (the `FooProjections.res + Mapping.Make`
+// pattern) live in `MultiSourceProjection_GWT` — same DSL surface, different
+// source description.
+
+// Minimal inline Spec — mirrors `Reventless.StateViewSlice.Spec` minus the
+// fields the GWT DSL doesn't read (`config`). Declared inline so sury-ppx
+// processes `@schema` in this compilation unit.
+module type Spec = {
+  let name: string
+
+  @schema
+  type state
+
+  let stateSchema: S.t<state>
+
+  @schema
+  type consumedEvent
+
+  let subIdConfig: option<Reventless.ReadModel.subIdConfig<state>>
+}
+
+// Implementation half — one binding (`project`).
+module type Projection = {
+  module Spec: Spec
+
+  let project: Spec.consumedEvent => array<Reventless.Projection.action<string, Spec.state>>
+}
+
+module type T = {
+  module Spec: Spec
+
+  let describe: (string, unit => unit) => unit
+  let describeWithId: (string, string, unit => unit) => unit
+  let todo: string => unit
+  let test: (string, ~timeout: int=?, unit => promise<Outcome.outcome>) => unit
+
+  type store = dict<array<Spec.state>>
+  type storeThunk = unit => promise<store>
+
+  let givenEvents: array<Spec.consumedEvent> => promise<store>
+  let whenEvent: (promise<store>, Spec.consumedEvent) => storeThunk
+  let whenEvents: (promise<store>, array<Spec.consumedEvent>) => storeThunk
+  let thenStates: (storeThunk, array<Spec.state>) => promise<Outcome.outcome>
+  let thenStatesWithId: (storeThunk, string, array<Spec.state>) => promise<Outcome.outcome>
+  let thenAllStates: (storeThunk, store) => promise<Outcome.outcome>
+  let thenState: (storeThunk, Spec.state) => promise<Outcome.outcome>
+  let thenStateWithId: (storeThunk, string, Spec.state) => promise<Outcome.outcome>
+  let thenNoState: storeThunk => promise<Outcome.outcome>
+  let thenThrow: storeThunk => promise<Outcome.outcome>
+  let thenFail: storeThunk => promise<Outcome.outcome>
+}
+
+let handleActions = Projection.handleActions // local alias to avoid shadowing
+
+module Make = (
+  Spec: Spec,
+  Projection: Projection with module Spec := Spec,
+): (T with module Spec = Spec) => {
+  module Spec = Spec
+
+  S.enableJson()
+
+  let testId = ref(TestFixtures.id)
+
+  let describe = JestBind.describe
+  let todo = JestBind.todo
+  let describeWithId = (description, id, fn) => {
+    testId := id
+    JestBind.describe(description, fn)
+  }
+  let test = (name, ~timeout=?, body) =>
+    JestBind.testPromise(~slice=Spec.name, name, ~timeout?, body)
+
+  type store = dict<array<Spec.state>>
+  type storeThunk = unit => promise<store>
+
+  let getSubId = state => Spec.subIdConfig->Option.map(({getSubId}) => state->getSubId)
+  let hasSubId = (state, subId) => state->getSubId->Option.getOrThrow == subId
+  let states = (store, id) => store->Dict.get(id)->Option.getOr([])
+  let setStates = (store, id, states) => store->Dict.set(id, states)
+  let updateState = (store, id, subId, newState) =>
+    store->states(id)->Array.map(state => state->hasSubId(subId) ? newState : state)
+  let addState = (store, id, newState) => {
+    let (updatedStates, newStates) = switch newState->getSubId {
+    | Some(subId) =>
+      store->states(id)->Array.some(state => state->hasSubId(subId))
+        ? (store->updateState(id, subId, newState), [])
+        : (store->states(id), [newState])
+    | None => (store->states(id), [newState])
+    }
+    store->Dict.set(id, Array.concat(updatedStates, newStates))
+  }
+  let deleteStates = (store, id) => store->Dict.set(id, [])
+  let deleteSubState = (store, id, subId, getSubId) =>
+    store->Dict.set(
+      id,
+      store
+      ->Dict.get(id)
+      ->Option.map(states => states->Array.filter(state => state->getSubId != subId))
+      ->Option.getOr([]),
+    )
+
+  let load = (store, id) => store->states(id)->Ok->Promise.resolve
+  let save = (store, id, state, saveMode: QueryDb.saveMode, _ttl) =>
+    switch (store->states(id), saveMode, Spec.subIdConfig) {
+    | (_, Any, Some(_))
+    | (_, Init, Some(_)) =>
+      store->addState(id, state)
+      Ok()->Promise.resolve
+    | (_, Any, None)
+    | ([], Init, _)
+    | ([_], Overwrite, _) =>
+      store->setStates(id, [state])
+      Ok()->Promise.resolve
+    | _ => Error(ReventlessInfra.QueryDb.StaleState)->Promise.resolve
+    }
+  let saveBatch = (store, batch) => {
+    batch->Array.forEach(((id, state, _ttl)) => store->addState(id, state))
+    Ok()->Promise.resolve
+  }
+  let delete = (store, id, subId) =>
+    switch (subId, Spec.subIdConfig) {
+    | (None, _) =>
+      store->deleteStates(id)
+      Ok()->Promise.resolve
+    | (Some((_, subId)), Some({Reventless.ReadModel.getSubId: getSubId})) =>
+      store->deleteSubState(id, subId, getSubId)
+      Ok()->Promise.resolve
+    | _ => Ok()->Promise.resolve
+    }
+  let deleteBatch = (store, ids) => {
+    ids->Array.forEach(((id, subId)) =>
+      switch (subId, Spec.subIdConfig) {
+      | (None, _) => store->deleteStates(id)
+      | (Some((_, subId)), Some({Reventless.ReadModel.getSubId: getSubId})) =>
+        store->deleteSubState(id, subId, getSubId)
+      | _ => ()
+      }
+    )
+    Ok()->Promise.resolve
+  }
+
+  let runActions = (actions, operations) =>
+    actions->handleActions(operations, Spec.subIdConfig)
+
+  let sortStore = store =>
+    switch Spec.subIdConfig {
+    | None => store
+    | Some(_) =>
+      Dict.mapValues(store, states =>
+        states->Array.toSorted((s1, s2) =>
+          String.compare(s1->getSubId->Option.getUnsafe, s2->getSubId->Option.getUnsafe)
+        )
+      )
+    }
+
+  let update = async (store, events) => {
+    // Projection.project produces an array of actions per event — flatten and
+    // feed them through handleActions against the dict store.
+    let actions =
+      events
+      ->Array.map(ev => ev->Projection.project)
+      ->Array.flat
+    await actions->runActions({
+      load: load(store, ...),
+      loadStream: id => store->states(id)->Stream.fromIterable,
+      save: save(store, ...),
+      saveBatch: saveBatch(store, ...),
+      count: async (_, _, _) => Ok(0),
+      delete: delete(store, ...),
+      deleteBatch: deleteBatch(store, ...),
+    })
+
+    store->sortStore
+  }
+
+  let givenEvents = events => Dict.make()->update(events)
+
+  let whenEvent = (store, event): storeThunk =>
+    () => (async () => await (await store)->update([event]))()
+  let whenEvents = (store, events): storeThunk =>
+    () => (async () => await (await store)->update(events))()
+
+  let encState = (s: Spec.state) => s->Message.encode(Spec.stateSchema)
+  let encStates = (arr: array<Spec.state>) => arr->Array.map(encState)
+
+  let stateEq = (a: Spec.state, b: Spec.state) =>
+    JSON.stringify(encState(a)) == JSON.stringify(encState(b))
+  let statesEq = (a, b) =>
+    Array.length(a) == Array.length(b) &&
+      Array.zip(a, b)->Array.every(((x, y)) => stateEq(x, y))
+  let storeEq = (a: store, b: store) => {
+    let ka = a->Dict.keysToArray->Array.toSorted(String.compare)
+    let kb = b->Dict.keysToArray->Array.toSorted(String.compare)
+    ka == kb &&
+      ka->Array.every(key =>
+        statesEq(a->Dict.get(key)->Option.getOr([]), b->Dict.get(key)->Option.getOr([]))
+      )
+  }
+
+  let encStore = (s: store) => {
+    let obj = Dict.make()
+    s
+    ->Dict.toArray
+    ->Array.forEach(((k, v)) => obj->Dict.set(k, JSON.Encode.array(v->encStates)))
+    JSON.Encode.object(obj)
+  }
+
+  let thenStates = async (thunk, expectedStates) => {
+    let store = await thunk()
+    let keys = store->Dict.keysToArray
+    let actualId = keys->Array.get(0)
+    let actualStates = store->Dict.valuesToArray->Array.get(0)->Option.getOr([])
+    if (
+      keys->Array.length == 1 &&
+        actualId == Some(testId.contents) &&
+        statesEq(actualStates, expectedStates)
+    ) {
+      Outcome.pass
+    } else {
+      Outcome.fail(
+        StateMismatch({
+          key: testId.contents,
+          expected: Some(JSON.Encode.array(expectedStates->encStates)),
+          actual: Some(encStore(store)),
+        }),
+      )
+    }
+  }
+
+  let thenStatesWithId = async (thunk, id, expectedStates) => {
+    let store = await thunk()
+    let keys = store->Dict.keysToArray
+    let actualId = keys->Array.get(0)
+    let actualStates = store->Dict.valuesToArray->Array.get(0)->Option.getOr([])
+    if keys->Array.length == 1 && actualId == Some(id) && statesEq(actualStates, expectedStates) {
+      Outcome.pass
+    } else {
+      Outcome.fail(
+        StateMismatch({
+          key: id,
+          expected: Some(JSON.Encode.array(expectedStates->encStates)),
+          actual: Some(encStore(store)),
+        }),
+      )
+    }
+  }
+
+  let thenAllStates = async (thunk, expectedStore: store) => {
+    let store = await thunk()
+    if storeEq(store, expectedStore) {
+      Outcome.pass
+    } else {
+      Outcome.fail(
+        StateMismatch({
+          key: "<all>",
+          expected: Some(encStore(expectedStore)),
+          actual: Some(encStore(store)),
+        }),
+      )
+    }
+  }
+
+  let thenState = (thunk, expectedState) => thenStates(thunk, [expectedState])
+  let thenStateWithId = (thunk, id, expectedState) =>
+    thenStatesWithId(thunk, id, [expectedState])
+
+  let thenNoState = async thunk => {
+    let store = await thunk()
+    let total =
+      store->Dict.valuesToArray->Array.reduce(0, (acc, states) => acc + states->Array.length)
+    if total == 0 {
+      Outcome.pass
+    } else {
+      Outcome.fail(
+        StateMismatch({
+          key: "<any>",
+          expected: None,
+          actual: Some(encStore(store)),
+        }),
+      )
+    }
+  }
+
+  let thenThrow = async thunk =>
+    switch await thunk() {
+    | _ =>
+      Outcome.fail(
+        Throw({
+          error: "Expected thunk to throw but it returned normally",
+          stack: "",
+        }),
+      )
+    | exception _ => Outcome.pass
+    }
+
+  let thenFail = async thunk =>
+    switch await thunk() {
+    | _ =>
+      Outcome.fail(
+        Throw({error: "Expected failure but thunk returned normally", stack: ""}),
+      )
+    | exception _ => Outcome.pass
+    }
+}