@reventlessdev/reventless-gwt 1.0.0-alpha.100

package/src/StateChange/WithManualOpen_Behavior.res

@@ -0,0 +1,17 @@
+// Implementation half — pairs with [WithManualOpen.res].
+
+open WithManualOpen
+
+type state = {exists: bool}
+let initialState: state = {exists: false}
+
+let evolve = (_state: state, event: consumedEvent): state =>
+  switch event {
+  | CategoryAdded => {exists: true}
+  }
+
+let decide = (state: state, command: command): result<array<event>, error> =>
+  switch command {
+  | AddCategory({categoryId, name}) =>
+    state.exists ? Error(CategoryAlreadyExists) : Ok([CategoryAdded({categoryId, name})])
+  }

package/src/StateChange/WithManualOpen_Behavior.res.mjs

@@ -0,0 +1,37 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+
+function evolve(_state, event) {
+  return {
+    exists: true
+  };
+}
+
+function decide(state, command) {
+  if (state.exists) {
+    return {
+      TAG: "Error",
+      _0: "CategoryAlreadyExists"
+    };
+  } else {
+    return {
+      TAG: "Ok",
+      _0: [{
+          TAG: "CategoryAdded",
+          categoryId: command.categoryId,
+          name: command.name
+        }]
+    };
+  }
+}
+
+let initialState = {
+  exists: false
+};
+
+export {
+  initialState,
+  evolve,
+  decide,
+}
+/* No side effect */

package/src/StubRuntime.res

@@ -0,0 +1,54 @@
+// Inert runtime arguments shared by the Delegate / Flow GWT DSLs.
+//
+// ExtensionPoint mappings and Extension delegates are pure translations, but
+// their user-level functions take infrastructure handles (a query engine, a
+// scheduler, message metadata, the plugin definition). The GWT runs them with
+// these no-op stubs so the translation logic is exercised without any real
+// infrastructure. See `docs/plans/done/gwt-flow-and-extension-test-kinds.md` Phase 0.
+
+// No-op QueryEngine — any DB lookup resolves to empty results. Kept identical
+// to the inline stub `Mapping_GWT` defines.
+let queryEngine: Reventless.QueryEngine.operations = {
+  scan: (~readModelName as _, ~filterConfigs as _, ~limit as _) => []->Promise.resolve,
+  query: (
+    ~readModelName as _: string,
+    ~key as _: option<string>=?,
+    ~id as _: Reventless.QueryEngine.value,
+    ~subIdConfig as _: option<Reventless.QueryEngine.SubId.config>=?,
+    ~filterConfigs as _: option<array<Reventless.QueryEngine.Filter.config>>=?,
+    ~ascending as _: option<bool>=?,
+    ~limit as _: option<int>=?,
+  ) => []->Promise.resolve,
+}
+
+// Scheduler stubs — `create` / `delete` are inert. EP/Extension `Call`
+// directives receive these as the side-effect handles they never act on.
+let createSchedule: Reventless.Schedule.create = _schedule => Promise.resolve()
+let deleteSchedule: Reventless.Schedule.delete = _name => Promise.resolve()
+
+// Default message metadata threaded into the user-level mapping functions.
+let meta: Reventless.Message.meta = {
+  service: "gwt",
+  time: "1970-01-01T00:00:00Z",
+  msgId: "gwt-msg",
+  correlationId: "gwt-corr",
+}
+
+// Minimal plugin definition — Extension delegates receive it as an inert arg.
+// Mirrors the `fakePluginDefinition` the platform admin uses for its internal
+// callback wiring.
+let pluginDefinition: Reventless.Plugin.pluginDefinition = {
+  id: "Gwt@TEST",
+  name: "Gwt",
+  version: "TEST",
+  extensionPoints: [],
+  extensions: [],
+  eventCollector: "NOT-SET",
+  extensionProtocols: [],
+  apiSchemaFragment: None,
+  apiTarget: None,
+  uiFragments: None,
+  structure: None,
+  dcbEventLog: None,
+  kind: Domain,
+}

package/src/StubRuntime.res.mjs

@@ -0,0 +1,55 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+
+function queryEngine_scan(param, param$1, param$2) {
+  return Promise.resolve([]);
+}
+
+function queryEngine_query(param, param$1, param$2, param$3, param$4, param$5, param$6) {
+  return Promise.resolve([]);
+}
+
+let queryEngine = {
+  scan: queryEngine_scan,
+  query: queryEngine_query
+};
+
+function createSchedule(_schedule) {
+  return Promise.resolve();
+}
+
+function deleteSchedule(_name) {
+  return Promise.resolve();
+}
+
+let pluginDefinition = {
+  id: "Gwt@TEST",
+  name: "Gwt",
+  version: "TEST",
+  extensionPoints: [],
+  extensions: [],
+  eventCollector: "NOT-SET",
+  extensionProtocols: [],
+  apiSchemaFragment: undefined,
+  apiTarget: undefined,
+  uiFragments: undefined,
+  structure: undefined,
+  dcbEventLog: undefined,
+  kind: "Domain"
+};
+
+let meta = {
+  service: "gwt",
+  time: "1970-01-01T00:00:00Z",
+  msgId: "gwt-msg",
+  correlationId: "gwt-corr"
+};
+
+export {
+  queryEngine,
+  createSchedule,
+  deleteSchedule,
+  meta,
+  pluginDefinition,
+}
+/* No side effect */

package/src/TestFixtures.res

@@ -0,0 +1,16 @@
+let id = "id"
+let meta = {
+  Reventless.Message.service: "service",
+  user: "ProjectionTest",
+  ip: "ip",
+  time: "time",
+  msgId: "msgId",
+  correlationId: "correlationId",
+}
+
+let context = {Reventless.Message.meta, id}
+
+let statusChange = {
+  Reventless.Message.at: context.meta.time,
+  by: context.meta.user->Option.getOr(""),
+}

package/src/TestFixtures.res.mjs

@@ -0,0 +1,34 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+
+let id = "id";
+
+let meta = {
+  service: "service",
+  time: "time",
+  ip: "ip",
+  user: "ProjectionTest",
+  msgId: "msgId",
+  correlationId: "correlationId"
+};
+
+let context = {
+  id: id,
+  meta: meta
+};
+
+let statusChange_by = Stdlib_Option.getOr("ProjectionTest", "");
+
+let statusChange = {
+  at: "time",
+  by: statusChange_by
+};
+
+export {
+  id,
+  meta,
+  context,
+  statusChange,
+}
+/* statusChange Not a pure module */

package/src/Watch.res

@@ -0,0 +1,108 @@
+// Wraps `chokidar` for the `reventless-gwt watch` and `reventless-gwt run
+// --watch` modes. Emits one callback per file change event (creates, edits,
+// deletes) after a small debounce window so rapid editor saves don't trigger
+// overlapping runs.
+
+type watcher
+type opts = {
+  ignoreInitial: bool,
+  ignored: array<string>,
+}
+
+// The kind of filesystem change, threaded through so the consumer can tell a
+// *structural* change (a source file appearing/disappearing — the move/delete
+// half of a relocation) from a plain edit. Phase 12 keys its clean-rebuild on
+// an `Unlink` of a `.res` source.
+type event = Add | Change | Unlink
+
+@module("chokidar") external watch: (array<string>, opts) => watcher = "watch"
+@send external on: (watcher, string, string => unit) => watcher = "on"
+@send external close: watcher => promise<unit> = "close"
+
+@val external setTimeout: (unit => unit, int) => float = "setTimeout"
+@val external clearTimeout: float => unit = "clearTimeout"
+
+// True when an event is the *structural* signal Phase 12 acts on: a source
+// `.res` file leaving a directory (the move/delete half of a relocation).
+// Generated `.res.mjs` outputs end in `.mjs`, so they never match — which is
+// also what keeps a `rescript clean` (it deletes those outputs) from
+// re-triggering the clean-rebuild it just ran.
+let isStructuralSource = (event: event, path: string): bool =>
+  event == Unlink && String.endsWith(path, ".res")
+
+// Coalesce a burst of chokidar events into a single debounce window, then emit.
+// A window may span *multiple* packages — a branch switch or a multi-package
+// refactor emits `.res` unlinks under several package roots at once. The old
+// shape kept only one "best" path, so it clean-rebuilt just one package and
+// left the others with stale `.res.mjs`. Instead accumulate the *set* of
+// distinct structural source paths and emit one `Unlink` callback per path
+// (the consumer maps each to its owning package). If the window held no
+// structural signal, emit a single representative event so the consumer does a
+// plain re-run.
+let debounce = (wait: int, fn: (event, string) => unit) => {
+  let pending: ref<option<float>> = ref(None)
+  let structural: ref<array<string>> = ref([])
+  let sawOther = ref(false)
+  let otherEvent = ref(Change)
+  let otherPath = ref("")
+  (event, path) => {
+    if isStructuralSource(event, path) {
+      if !(structural.contents->Array.includes(path)) {
+        structural := Array.concat(structural.contents, [path])
+      }
+    } else {
+      sawOther := true
+      otherEvent := event
+      otherPath := path
+    }
+    switch pending.contents {
+    | Some(t) => clearTimeout(t)
+    | None => ()
+    }
+    pending :=
+      Some(
+        setTimeout(() => {
+          pending := None
+          let paths = structural.contents
+          let other = sawOther.contents
+          let oe = otherEvent.contents
+          let op = otherPath.contents
+          structural := []
+          sawOther := false
+          otherEvent := Change
+          otherPath := ""
+          if paths->Array.length > 0 {
+            // One rebuild per distinct owning package; a plain edit alongside
+            // is covered by each structural rebuild's own re-run.
+            paths->Array.forEach(p => fn(Unlink, p))
+          } else if other {
+            fn(oe, op)
+          }
+        }, wait),
+      )
+  }
+}
+
+let start = (roots: array<string>, onChange: (event, string) => unit): watcher => {
+  let w = watch(
+    roots,
+    {
+      ignoreInitial: true,
+      // Keep in sync with Discovery's pruned dirs — writes under `dist/` or
+      // `.history/` are build/editor output, not source, and a `dist/` write
+      // could otherwise drive a re-run loop.
+      ignored: [
+        "**/node_modules/**",
+        "**/lib/**",
+        "**/.git/**",
+        "**/dist/**",
+        "**/.history/**",
+      ],
+    },
+  )
+  let debounced = debounce(120, onChange)
+  w
+  ->on("add", p => debounced(Add, p))
+  ->on("change", p => debounced(Change, p))
+  ->on("unlink", p => debounced(Unlink, p))
+}

package/src/Watch.res.mjs

@@ -0,0 +1,85 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Chokidar from "chokidar";
+
+function isStructuralSource(event, path) {
+  if (event === "Unlink") {
+    return path.endsWith(".res");
+  } else {
+    return false;
+  }
+}
+
+function debounce(wait, fn) {
+  let pending = {
+    contents: undefined
+  };
+  let structural = {
+    contents: []
+  };
+  let sawOther = {
+    contents: false
+  };
+  let otherEvent = {
+    contents: "Change"
+  };
+  let otherPath = {
+    contents: ""
+  };
+  return (event, path) => {
+    if (isStructuralSource(event, path)) {
+      if (!structural.contents.includes(path)) {
+        structural.contents = structural.contents.concat([path]);
+      }
+    } else {
+      sawOther.contents = true;
+      otherEvent.contents = event;
+      otherPath.contents = path;
+    }
+    let t = pending.contents;
+    if (t !== undefined) {
+      clearTimeout(t);
+    }
+    pending.contents = setTimeout(() => {
+      pending.contents = undefined;
+      let paths = structural.contents;
+      let other = sawOther.contents;
+      let oe = otherEvent.contents;
+      let op = otherPath.contents;
+      structural.contents = [];
+      sawOther.contents = false;
+      otherEvent.contents = "Change";
+      otherPath.contents = "";
+      if (paths.length !== 0) {
+        paths.forEach(p => fn("Unlink", p));
+        return;
+      } else if (other) {
+        return fn(oe, op);
+      } else {
+        return;
+      }
+    }, wait);
+  };
+}
+
+function start(roots, onChange) {
+  let w = Chokidar.watch(roots, {
+    ignoreInitial: true,
+    ignored: [
+      "**/node_modules/**",
+      "**/lib/**",
+      "**/.git/**",
+      "**/dist/**",
+      "**/.history/**"
+    ]
+  });
+  let debounced = debounce(120, onChange);
+  return w.on("add", p => debounced("Add", p)).on("change", p => debounced("Change", p)).on("unlink", p => debounced("Unlink", p));
+}
+
+export {
+  isStructuralSource,
+  debounce,
+  start,
+}
+/* chokidar Not a pure module */

package/src/WatcherProbe.res

@@ -0,0 +1,56 @@
+// Detects whether a ReScript build watcher is already running for a package, so
+// the watch manager can defer to a developer's (or rescript-vscode's) own
+// watcher rather than spawn a duplicate. ReScript records the building process's
+// PID in a lock file and liveness-checks it (a dead-pid lock is taken over), so
+// the reliable signal is: lock present AND its pid is alive. A stale lock is
+// harmless — rescript self-heals it on the next build.
+//
+// Two lock files exist depending on which command form started the build:
+//   - `lib/watch.lock`    — canonical `rescript watch` (used by rescript-vscode
+//                           ≥ 1.73's "Start Build", and the non-deprecated form)
+//   - `lib/rescript.lock` — legacy `rescript build -w` (what `pnpm run start`
+//                           still maps to in the example packages)
+// Both must be checked: missing `watch.lock` is exactly how the rescript-vscode
+// watcher slipped past an earlier rescript.lock-only probe, causing a doomed
+// duplicate spawn.
+
+@module("node:fs") external _existsSync: string => bool = "existsSync"
+@module("node:fs") external _readFileSync: (string, string) => string = "readFileSync"
+@module("node:path") external join: (string, string) => string = "join"
+@val external _processKillSig: (int, int) => unit = "process.kill"
+
+// `process.kill(pid, 0)` performs no signal delivery — it only probes existence.
+// It throws `ESRCH` when the pid is gone (dead) and `EPERM` when the pid exists
+// but is owned by another user (alive, just not ours). A bare catch-all treated
+// EPERM as dead, which would spawn a duplicate watcher over a live foreign one;
+// treat EPERM as alive.
+let _errCode: JsExn.t => option<string> = %raw(`(e) => (e && typeof e.code === "string") ? e.code : undefined`)
+let isAlive = (pid: int): bool =>
+  try {
+    _processKillSig(pid, 0)
+    true
+  } catch {
+  | exn =>
+    switch JsExn.fromException(exn) {
+    | Some(e) => _errCode(e) == Some("EPERM")
+    | None => false
+    }
+  }
+
+let libLock = (dir: string, name: string): string => join(join(dir, "lib"), name)
+
+// True when the named lock file exists and holds a live pid.
+let lockHasLivePid = (lock: string): bool =>
+  if _existsSync(lock) {
+    switch Int.fromString(String.trim(_readFileSync(lock, "utf8"))) {
+    | Some(pid) => isAlive(pid)
+    | None => false
+    }
+  } else {
+    false
+  }
+
+// True when an external watcher (either command form) already owns this
+// package's build.
+let hasLiveWatcher = (dir: string): bool =>
+  lockHasLivePid(libLock(dir, "watch.lock")) || lockHasLivePid(libLock(dir, "rescript.lock"))

package/src/WatcherProbe.res.mjs

@@ -0,0 +1,59 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Nodefs from "node:fs";
+import * as Nodepath from "node:path";
+import * as Stdlib_Int from "@rescript/runtime/lib/es6/Stdlib_Int.js";
+import * as Stdlib_JsExn from "@rescript/runtime/lib/es6/Stdlib_JsExn.js";
+import * as Primitive_object from "@rescript/runtime/lib/es6/Primitive_object.js";
+import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
+import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
+
+let _errCode = ((e) => (e && typeof e.code === "string") ? e.code : undefined);
+
+function isAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (raw_exn) {
+    let exn = Primitive_exceptions.internalToException(raw_exn);
+    let e = Stdlib_JsExn.fromException(exn);
+    if (e !== undefined) {
+      return Primitive_object.equal(_errCode(Primitive_option.valFromOption(e)), "EPERM");
+    } else {
+      return false;
+    }
+  }
+}
+
+function libLock(dir, name) {
+  return Nodepath.join(Nodepath.join(dir, "lib"), name);
+}
+
+function lockHasLivePid(lock) {
+  if (!Nodefs.existsSync(lock)) {
+    return false;
+  }
+  let pid = Stdlib_Int.fromString(Nodefs.readFileSync(lock, "utf8").trim(), undefined);
+  if (pid !== undefined) {
+    return isAlive(pid);
+  } else {
+    return false;
+  }
+}
+
+function hasLiveWatcher(dir) {
+  if (lockHasLivePid(libLock(dir, "watch.lock"))) {
+    return true;
+  } else {
+    return lockHasLivePid(libLock(dir, "rescript.lock"));
+  }
+}
+
+export {
+  _errCode,
+  isAlive,
+  libLock,
+  lockHasLivePid,
+  hasLiveWatcher,
+}
+/* node:fs Not a pure module */

package/src/Worker.res

@@ -0,0 +1,24 @@
+// Minimal `node:worker_threads` binding for gwt watch re-runs.
+//
+// Node's ESM module registry is keyed by URL and never evicts, so re-importing a
+// recompiled test file in the same process replays tests that close over the
+// *old* instances of their statically-imported implementation modules (the
+// Loader can only cache-bust the test file's own URL, not its transitive
+// imports). Running each watch re-run in a short-lived Worker gives it a fresh
+// registry — the recompiled modules are re-imported — and reclaims the whole
+// imported graph on worker exit (fixing the monotonic-buster memory leak).
+
+type t
+type workerOptions<'a> = {workerData: 'a}
+type url
+
+@new @module("node:worker_threads")
+external make: (url, workerOptions<'a>) => t = "Worker"
+
+// A worker's stdout is piped to the parent's process.stdout by default, so the
+// NDJSON the formatters write inside the worker reaches the client unchanged.
+@send external on: (t, string, 'cb) => unit = "on"
+@send external terminate: t => promise<int> = "terminate"
+
+// The compiled worker entry lives next to this module in the in-source build.
+let runWorkerUrl: url = %raw(`new URL("./RunWorker.res.mjs", import.meta.url)`)

package/src/Worker.res.mjs

@@ -0,0 +1,9 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+
+let runWorkerUrl = (new URL("./RunWorker.res.mjs", import.meta.url));
+
+export {
+  runWorkerUrl,
+}
+/* runWorkerUrl Not a pure module */

package/tests/AutomationGwtTest.res

@@ -0,0 +1,71 @@
+// Worked example for AutomationSlice_GWT — a "ship order" automation:
+// OrderPlaced ⇒ TODO, ShipmentCreated resolves the TODO, process emits
+// CreateShipment. Covers the unit combinators (collect / resolve / process)
+// and the scenario combinators (sweep / andThenEvents).
+
+@@reventless.gwt
+
+module ShipOrderSlice = {
+  let name = "ShipOrder"
+
+  @schema
+  type consumedEvent =
+    | OrderPlaced({orderId: string, shippingAddress: string})
+    | ShipmentCreated({orderId: string})
+
+  @schema
+  type todoItem = {orderId: string, shippingAddress: string}
+
+  @schema
+  type command = CreateShipment({orderId: string, address: string})
+
+  let collect = event =>
+    switch event {
+    | OrderPlaced({orderId, shippingAddress}) => [(orderId, {orderId, shippingAddress})]
+    | _ => []
+    }
+
+  let resolve = event =>
+    switch event {
+    | ShipmentCreated({orderId}) => Some(orderId)
+    | _ => None
+    }
+
+  let process = (_id, item) =>
+    Some((item.orderId, CreateShipment({orderId: item.orderId, address: item.shippingAddress})))
+}
+
+describe("ShipOrder AutomationSlice", () => {
+  test("collect: OrderPlaced creates a pending TODO", () =>
+    givenEvent(OrderPlaced({orderId: "o1", shippingAddress: "1 Main St"}))
+    ->whenCollect
+    ->thenTodos([("o1", {orderId: "o1", shippingAddress: "1 Main St"})])
+  )
+
+  test("resolve: ShipmentCreated marks the TODO done", () =>
+    givenEvent(ShipmentCreated({orderId: "o1"}))
+    ->whenResolve
+    ->thenResolved(Some("o1"))
+  )
+
+  test("process: pending TODO emits CreateShipment", () =>
+    givenTodo("o1", {orderId: "o1", shippingAddress: "1 Main St"})
+    ->whenProcess
+    ->thenCommand("o1", CreateShipment({orderId: "o1", address: "1 Main St"}))
+  )
+
+  test("sweep: events → commands, andThenEvents drains todos", () => {
+    let s =
+      givenEvents([OrderPlaced({orderId: "o1", shippingAddress: "1 Main St"})])
+      ->whenSweep
+    let commandsOk =
+      thenCommands(s, [("o1", CreateShipment({orderId: "o1", address: "1 Main St"}))])
+    let drained = andThenEvents(s, [ShipmentCreated({orderId: "o1"})])
+    let todosOk = thenScenarioTodos(drained, [])
+    switch (commandsOk, todosOk) {
+    | (Ok(), Ok()) => Outcome.pass
+    | (Error(_) as e, _) => e
+    | (_, Error(_) as e) => e
+    }
+  })
+})