@reventlessdev/reventless-gwt 1.0.0-alpha.74

package/src/StubRuntime.res

@@ -0,0 +1,53 @@
+// 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,
+}

package/src/StubRuntime.res.mjs

@@ -0,0 +1,54 @@
+// 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
+};
+
+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,92 @@
+// 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"
+
+// Rank events so a coalesced burst reports the *strongest structural* signal
+// with a representative path. A single directory `mv` emits an interleaved
+// burst — `unlink` of the `.res` AND the generated `.res.mjs`, then `add`s at
+// the new path — inside one debounce window. The representative path must be a
+// `.res` *source* unlink (the relocation signal), never a `.res.mjs` or a
+// trailing add, or the consumer misclassifies it as an ordinary change. So an
+// unlink of a `.res` source outranks everything; any other unlink/add outranks
+// a plain edit.
+let rank = (event: event, path: string): int =>
+  switch event {
+  | Unlink => String.endsWith(path, ".res") ? 2 : 1
+  | Add => 1
+  | Change => 0
+  }
+
+// 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")
+
+let debounce = (wait: int, fn: (event, string) => unit) => {
+  let pending: ref<option<float>> = ref(None)
+  let bestRank = ref(-1)
+  let bestEvent = ref(Change)
+  let bestPath = ref("")
+  (event, path) => {
+    let r = rank(event, path)
+    if r >= bestRank.contents {
+      bestRank := r
+      bestEvent := event
+      bestPath := path
+    }
+    switch pending.contents {
+    | Some(t) => clearTimeout(t)
+    | None => ()
+    }
+    pending :=
+      Some(
+        setTimeout(() => {
+          pending := None
+          let e = bestEvent.contents
+          let p = bestPath.contents
+          bestRank := -1
+          bestEvent := Change
+          bestPath := ""
+          fn(e, p)
+        }, wait),
+      )
+  }
+}
+
+let start = (roots: array<string>, onChange: (event, string) => unit): watcher => {
+  let w = watch(
+    roots,
+    {
+      ignoreInitial: true,
+      ignored: ["**/node_modules/**", "**/lib/**", "**/.git/**"],
+    },
+  )
+  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,83 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Chokidar from "chokidar";
+
+function rank(event, path) {
+  switch (event) {
+    case "Add" :
+      return 1;
+    case "Change" :
+      return 0;
+    case "Unlink" :
+      if (path.endsWith(".res")) {
+        return 2;
+      } else {
+        return 1;
+      }
+  }
+}
+
+function isStructuralSource(event, path) {
+  if (event === "Unlink") {
+    return path.endsWith(".res");
+  } else {
+    return false;
+  }
+}
+
+function debounce(wait, fn) {
+  let pending = {
+    contents: undefined
+  };
+  let bestRank = {
+    contents: -1
+  };
+  let bestEvent = {
+    contents: "Change"
+  };
+  let bestPath = {
+    contents: ""
+  };
+  return (event, path) => {
+    let r = rank(event, path);
+    if (r >= bestRank.contents) {
+      bestRank.contents = r;
+      bestEvent.contents = event;
+      bestPath.contents = path;
+    }
+    let t = pending.contents;
+    if (t !== undefined) {
+      clearTimeout(t);
+    }
+    pending.contents = setTimeout(() => {
+      pending.contents = undefined;
+      let e = bestEvent.contents;
+      let p = bestPath.contents;
+      bestRank.contents = -1;
+      bestEvent.contents = "Change";
+      bestPath.contents = "";
+      fn(e, p);
+    }, wait);
+  };
+}
+
+function start(roots, onChange) {
+  let w = Chokidar.watch(roots, {
+    ignoreInitial: true,
+    ignored: [
+      "**/node_modules/**",
+      "**/lib/**",
+      "**/.git/**"
+    ]
+  });
+  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 {
+  rank,
+  isStructuralSource,
+  debounce,
+  start,
+}
+/* chokidar Not a pure module */

package/src/WatcherProbe.res

@@ -0,0 +1,48 @@
+// 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
+// (throws ESRCH when the pid is gone), which is exactly the liveness check.
+let isAlive = (pid: int): bool =>
+  try {
+    _processKillSig(pid, 0)
+    true
+  } catch {
+  | _ => 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,46 @@
+// 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";
+
+function isAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (exn) {
+    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 {
+  isAlive,
+  libLock,
+  lockHasLivePid,
+  hasLiveWatcher,
+}
+/* node:fs 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
+    }
+  })
+})

package/tests/AutomationGwtTest.res.mjs

@@ -0,0 +1,189 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as S from "sury/src/S.res.mjs";
+import * as Outcome$ReventlessGwt from "../src/Outcome.res.mjs";
+import * as Automation_GWT$ReventlessGwt from "../src/Automation_GWT.res.mjs";
+
+let consumedEventSchema = S.union([
+  S.schema(s => ({
+    TAG: "OrderPlaced",
+    orderId: s.m(S.string),
+    shippingAddress: s.m(S.string)
+  })),
+  S.schema(s => ({
+    TAG: "ShipmentCreated",
+    orderId: s.m(S.string)
+  }))
+]);
+
+let todoItemSchema = S.schema(s => ({
+  orderId: s.m(S.string),
+  shippingAddress: s.m(S.string)
+}));
+
+let commandSchema = S.schema(s => ({
+  TAG: "CreateShipment",
+  orderId: s.m(S.string),
+  address: s.m(S.string)
+}));
+
+function collect(event) {
+  if (event.TAG !== "OrderPlaced") {
+    return [];
+  }
+  let orderId = event.orderId;
+  return [[
+      orderId,
+      {
+        orderId: orderId,
+        shippingAddress: event.shippingAddress
+      }
+    ]];
+}
+
+function resolve(event) {
+  if (event.TAG === "OrderPlaced") {
+    return;
+  } else {
+    return event.orderId;
+  }
+}
+
+function process(_id, item) {
+  return [
+    item.orderId,
+    {
+      TAG: "CreateShipment",
+      orderId: item.orderId,
+      address: item.shippingAddress
+    }
+  ];
+}
+
+function commandAuthorization(param) {
+  return "AllowAuthenticated";
+}
+
+let ShipOrderSlice = {
+  name: "ShipOrder",
+  consumedEventSchema: consumedEventSchema,
+  todoItemSchema: todoItemSchema,
+  commandSchema: commandSchema,
+  collect: collect,
+  resolve: resolve,
+  process: process,
+  commandAuthorization: commandAuthorization
+};
+
+let include = Automation_GWT$ReventlessGwt.Make(ShipOrderSlice);
+
+let describe = include.describe;
+
+let test = include.test;
+
+let givenEvent = include.givenEvent;
+
+let whenCollect = include.whenCollect;
+
+let thenTodos = include.thenTodos;
+
+let whenResolve = include.whenResolve;
+
+let thenResolved = include.thenResolved;
+
+let givenTodo = include.givenTodo;
+
+let whenProcess = include.whenProcess;
+
+let thenCommand = include.thenCommand;
+
+let givenEvents = include.givenEvents;
+
+let whenSweep = include.whenSweep;
+
+let thenCommands = include.thenCommands;
+
+let andThenEvents = include.andThenEvents;
+
+let thenScenarioTodos = include.thenScenarioTodos;
+
+describe("ShipOrder AutomationSlice", () => {
+  test("collect: OrderPlaced creates a pending TODO", () => thenTodos(whenCollect(givenEvent({
+    TAG: "OrderPlaced",
+    orderId: "o1",
+    shippingAddress: "1 Main St"
+  })), [[
+      "o1",
+      {
+        orderId: "o1",
+        shippingAddress: "1 Main St"
+      }
+    ]]));
+  test("resolve: ShipmentCreated marks the TODO done", () => thenResolved(whenResolve(givenEvent({
+    TAG: "ShipmentCreated",
+    orderId: "o1"
+  })), "o1"));
+  test("process: pending TODO emits CreateShipment", () => thenCommand(whenProcess(givenTodo("o1", {
+    orderId: "o1",
+    shippingAddress: "1 Main St"
+  })), "o1", {
+    TAG: "CreateShipment",
+    orderId: "o1",
+    address: "1 Main St"
+  }));
+  test("sweep: events → commands, andThenEvents drains todos", () => {
+    let s = whenSweep(givenEvents([{
+        TAG: "OrderPlaced",
+        orderId: "o1",
+        shippingAddress: "1 Main St"
+      }]));
+    let commandsOk = thenCommands(s, [[
+        "o1",
+        {
+          TAG: "CreateShipment",
+          orderId: "o1",
+          address: "1 Main St"
+        }
+      ]]);
+    let drained = andThenEvents(s, [{
+        TAG: "ShipmentCreated",
+        orderId: "o1"
+      }]);
+    let todosOk = thenScenarioTodos(drained, []);
+    if (commandsOk.TAG === "Ok") {
+      if (todosOk.TAG === "Ok") {
+        return Outcome$ReventlessGwt.pass;
+      } else {
+        return todosOk;
+      }
+    } else {
+      return commandsOk;
+    }
+  });
+});
+
+let Spec = include.Spec;
+
+let thenNoCommand = include.thenNoCommand;
+
+export {
+  ShipOrderSlice,
+  Spec,
+  describe,
+  test,
+  givenEvent,
+  whenCollect,
+  thenTodos,
+  whenResolve,
+  thenResolved,
+  givenTodo,
+  whenProcess,
+  thenCommand,
+  thenNoCommand,
+  givenEvents,
+  whenSweep,
+  thenCommands,
+  andThenEvents,
+  thenScenarioTodos,
+}
+/* consumedEventSchema Not a pure module */