@reventlessdev/reventless-gwt 1.0.0-alpha.74

package/src/Discovery.res.mjs

@@ -0,0 +1,103 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Nodepath from "node:path";
+import * as Promises from "node:fs/promises";
+
+let ignoreNames = [
+  "node_modules",
+  ".git",
+  "dist",
+  "lib",
+  ".history"
+];
+
+function shouldIgnore(name) {
+  return ignoreNames.includes(name);
+}
+
+let gwtIgnoreFile = ".gwtignore";
+
+function isPruned(entries) {
+  return entries.some(e => e.name === gwtIgnoreFile);
+}
+
+function isGwtTestFile(name) {
+  if (name.endsWith("_GWT.res.mjs") || name.endsWith("GwtTest.res.mjs")) {
+    return true;
+  } else {
+    return name.endsWith("Gwt.res.mjs");
+  }
+}
+
+async function walk(dir, acc) {
+  let entries;
+  try {
+    entries = await Promises.readdir(dir, {
+      withFileTypes: true
+    });
+  } catch (exn) {
+    entries = [];
+  }
+  if (isPruned(entries)) {
+    return acc;
+  }
+  let found = acc;
+  for (let i = 0, i_finish = entries.length; i < i_finish; ++i) {
+    let entry = entries[i];
+    if (!ignoreNames.includes(entry.name)) {
+      let full = Nodepath.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        let nested = await walk(full, []);
+        found = found.concat(nested);
+      } else if (entry.isFile() && isGwtTestFile(entry.name)) {
+        found = found.concat([full]);
+      }
+    }
+  }
+  return found;
+}
+
+async function discover(roots) {
+  let found = [];
+  for (let i = 0, i_finish = roots.length; i < i_finish; ++i) {
+    let root = roots[i];
+    let absolute = Nodepath.isAbsolute(root) ? root : Nodepath.resolve(root);
+    let isDir;
+    try {
+      let s = await Promises.stat(absolute);
+      isDir = s.isDirectory();
+    } catch (exn) {
+      isDir = false;
+    }
+    if (isDir) {
+      let collected = await walk(absolute, []);
+      found = found.concat(collected);
+    } else if (isGwtTestFile(absolute)) {
+      found = found.concat([absolute]);
+    }
+  }
+  let seen = {};
+  let unique = [];
+  found.forEach(path => {
+    let match = seen[path];
+    if (match !== undefined) {
+      return;
+    } else {
+      seen[path] = true;
+      unique.push(path);
+      return;
+    }
+  });
+  return unique;
+}
+
+export {
+  ignoreNames,
+  shouldIgnore,
+  gwtIgnoreFile,
+  isPruned,
+  isGwtTestFile,
+  walk,
+  discover,
+}
+/* node:path Not a pure module */

package/src/DomainDeadCode.res

@@ -0,0 +1,93 @@
+// Domain-level dead-code analysis (Phase 5). Pure reflection over the loaded
+// pluginStructures (LocalHost.loadGraph): finds produced event
+// types that no component consumes — the event-sourcing counterpart to reactive
+// dead code, the domain layer the language LSP cannot see.
+//
+// An event is reachable when ANY of these hold:
+//   1. Some component lists it in `consumedEventTypes` — the DCB-style link used by
+//      state-view slices, automation slices, outbound translations, and aggregate /
+//      state-change-slice consistency reads. Scanned across ALL plugins, so a
+//      cross-plugin consumer clears it.
+//   2. The producing write-side has a non-empty `linkedViews`. Classic aggregate →
+//      read-model projections express the link on the PRODUCER side (the read model's
+//      `consumedEventTypes` is empty; it projects the aggregate's whole stream). This
+//      is event-opaque, so a write-side with at least one linked view is treated as
+//      fully consumed — see the precision caveat below.
+// A produced event matched by neither of these is reported as an orphan, anchored on
+// the producing write-side declaration.
+//
+// Precision caveat: because classic read models carry no per-event consumption, rule
+// (2) is conservative — a write-side with a linked view is never flagged, even if a
+// specific event it produces is projected by nothing. This avoids false positives at
+// the cost of missing per-event orphans inside an otherwise-projected aggregate. DCB
+// consumers (rule 1) keep full per-event precision.
+//
+// Scope (v1): orphan produced events only. "Extension points with zero extensions"
+// and "read models nothing resolves against" need data `pluginStructure` does not
+// carry (the EP declaration list / the id-resolver table) — deferred.
+
+type finding = {
+  kind: string, // "OrphanEvent"
+  pluginName: string, // plugin owning the producer
+  componentName: string, // the producing aggregate / state-change slice
+  detail: string, // the orphaned event type
+}
+
+let analyze = (
+  ~structures: array<(string, Reventless.Plugin.pluginStructure)>,
+): array<finding> => {
+  // Every event type consumed anywhere becomes a key in `consumed`.
+  let consumed = Dict.make()
+  let mark = (evt: string) => consumed->Dict.set(evt, true)
+  structures->Array.forEach(((_, s)) => {
+    s.readModels->Array.forEach((q: Reventless.Plugin.queryableDef) =>
+      q.consumedEventTypes->Array.forEach(mark)
+    )
+    s.stateViewSlices->Array.forEach((q: Reventless.Plugin.queryableDef) =>
+      q.consumedEventTypes->Array.forEach(mark)
+    )
+    s.aggregates->Array.forEach((w: Reventless.Plugin.writableDef) =>
+      w.consumedEventTypes->Array.forEach(mark)
+    )
+    s.stateChangeSlices->Array.forEach((w: Reventless.Plugin.writableDef) =>
+      w.consumedEventTypes->Array.forEach(mark)
+    )
+    s.automationSlices->Array.forEach((a: Reventless.Plugin.automationSliceDef) =>
+      a.consumedEventTypes->Array.forEach(mark)
+    )
+    s.outboundTranslationSlices->Array.forEach((o: Reventless.Plugin.outboundTranslationSliceDef) =>
+      o.consumedEventTypes->Array.forEach(mark)
+    )
+    s.extensions->Array.forEach((e: Reventless.Plugin.extensionDef) =>
+      e.eventTypes->Array.forEach(mark)
+    )
+  })
+
+  // Produced events with no consumer, reported per producing write-side. A write-side
+  // with a linked view is treated as fully consumed (rule 2 above).
+  let findings = []
+  let scanProducers = (pluginName, writables: array<Reventless.Plugin.writableDef>) =>
+    writables->Array.forEach(w =>
+      if w.linkedViews->Array.length > 0 {
+        ()
+      } else {
+        w.producedEventTypes->Array.forEach(evt =>
+          switch consumed->Dict.get(evt) {
+          | Some(_) => ()
+          | None =>
+            findings->Array.push({
+              kind: "OrphanEvent",
+              pluginName,
+              componentName: w.name,
+              detail: evt,
+            })
+          }
+        )
+      }
+    )
+  structures->Array.forEach(((pluginName, s)) => {
+    scanProducers(pluginName, s.aggregates)
+    scanProducers(pluginName, s.stateChangeSlices)
+  })
+  findings
+}

package/src/DomainDeadCode.res.mjs

@@ -0,0 +1,69 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+
+function analyze(structures) {
+  let consumed = {};
+  let mark = evt => {
+    consumed[evt] = true;
+  };
+  structures.forEach(param => {
+    let s = param[1];
+    s.readModels.forEach(q => {
+      q.consumedEventTypes.forEach(mark);
+    });
+    s.stateViewSlices.forEach(q => {
+      q.consumedEventTypes.forEach(mark);
+    });
+    s.aggregates.forEach(w => {
+      w.consumedEventTypes.forEach(mark);
+    });
+    s.stateChangeSlices.forEach(w => {
+      w.consumedEventTypes.forEach(mark);
+    });
+    s.automationSlices.forEach(a => {
+      a.consumedEventTypes.forEach(mark);
+    });
+    s.outboundTranslationSlices.forEach(o => {
+      o.consumedEventTypes.forEach(mark);
+    });
+    s.extensions.forEach(e => {
+      e.eventTypes.forEach(mark);
+    });
+  });
+  let findings = [];
+  let scanProducers = (pluginName, writables) => {
+    writables.forEach(w => {
+      if (w.linkedViews.length !== 0) {
+        return;
+      } else {
+        w.producedEventTypes.forEach(evt => {
+          let match = consumed[evt];
+          if (match !== undefined) {
+            return;
+          } else {
+            findings.push({
+              kind: "OrphanEvent",
+              pluginName: pluginName,
+              componentName: w.name,
+              detail: evt
+            });
+            return;
+          }
+        });
+        return;
+      }
+    });
+  };
+  structures.forEach(param => {
+    let s = param[1];
+    let pluginName = param[0];
+    scanProducers(pluginName, s.aggregates);
+    scanProducers(pluginName, s.stateChangeSlices);
+  });
+  return findings;
+}
+
+export {
+  analyze,
+}
+/* No side effect */

package/src/EventMapping_GWT.res

@@ -0,0 +1,29 @@
+open ReventlessCore
+
+// Stage 5 — `EventMapping_GWT` is now a thin alias over `Mapping_GWT`
+// specialised for the Aggregate → Aggregate case. New tests should use
+// `Mapping_GWT.Make` directly with `Mapping_GWT.FromBehavior` adapters; this
+// wrapper is retained for migration backward-compat with consumers that were
+// already calling `EventMapping_GWT.Make(Source, SourceBehavior, Target,
+// TargetBehavior, EventMapping)` before Stage 5 landed.
+
+module Make = (
+  Source: Reventless.Aggregate.Spec,
+  SourceBehavior: Behavior.T with module Spec = Source,
+  Target: Reventless.Aggregate.Spec,
+  TargetBehavior: Behavior.T with module Spec = Target,
+  EventMapping: Reventless.EventMapping.T
+    with module Source = Source
+    and module Target = Target,
+) => {
+  module AdaptedSource = Mapping_GWT.FromBehavior(Source, SourceBehavior)
+  module AdaptedTarget = Mapping_GWT.FromBehavior(Target, TargetBehavior)
+
+  module BoundMapping = {
+    module Source = AdaptedSource
+    module Target = AdaptedTarget
+    let map = EventMapping.map
+  }
+
+  include Mapping_GWT.Make(BoundMapping)
+}

package/src/EventMapping_GWT.res.mjs

@@ -0,0 +1,44 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Mapping_GWT$ReventlessGwt from "./Mapping_GWT.res.mjs";
+
+function Make(Source) {
+  return SourceBehavior => (Target => (TargetBehavior => (EventMapping => {
+    let AdaptedSource = Mapping_GWT$ReventlessGwt.FromBehavior(Source)(SourceBehavior);
+    let AdaptedTarget = Mapping_GWT$ReventlessGwt.FromBehavior(Target)(TargetBehavior);
+    let map = EventMapping.map;
+    let BoundMapping = {
+      Source: undefined,
+      Target: undefined,
+      map: map
+    };
+    let include = Mapping_GWT$ReventlessGwt.Make({
+      Source: AdaptedSource,
+      Target: AdaptedTarget,
+      map: map
+    });
+    return {
+      AdaptedSource: AdaptedSource,
+      AdaptedTarget: AdaptedTarget,
+      BoundMapping: BoundMapping,
+      Source: include.Source,
+      Target: include.Target,
+      describe: include.describe,
+      test: include.test,
+      givenSourceEvents: include.givenSourceEvents,
+      andTargetEvents: include.andTargetEvents,
+      whenSourceCmd: include.whenSourceCmd,
+      thenTargetEvents: include.thenTargetEvents,
+      thenTargetEvent: include.thenTargetEvent,
+      thenNoTargetEvent: include.thenNoTargetEvent,
+      thenSourceError: include.thenSourceError,
+      thenTargetError: include.thenTargetError,
+      thenTargetEventsWithError: include.thenTargetEventsWithError
+    };
+  })));
+}
+
+export {
+  Make,
+}
+/* Mapping_GWT-ReventlessGwt Not a pure module */

package/src/Filter.res

@@ -0,0 +1,36 @@
+// Source-level test filters: `only`, `skip`, `xtest`, `xdescribe`.
+//
+// Jest ships `describe.only` / `test.only` / `xtest` as properties/aliases
+// on the globals; reventless-gwt exposes them as explicit helpers. When the
+// CLI runner is active, they mutate `Collector` state; when Jest is driving,
+// they forward to the Jest globals.
+
+@val external jestXTest: (string, unit => unit) => unit = "xtest"
+@val external jestXDescribe: (string, unit => unit) => unit = "xdescribe"
+
+// Mark the next registered `test` / `testPromise` as skipped.
+let skip = () => Collector.markSkipNext()
+
+// Mark the next registered `test` / `testPromise` as the focus of the run.
+// If at least one entry is flagged `Only`, only those entries execute.
+let only = () => Collector.markOnlyNext()
+
+// xtest: register a test but mark it as skipped.
+let xtest = (~slice as _: option<string>=?, name: string, _body: unit => Outcome.outcome) =>
+  if Collector.isActive() {
+    Collector.markSkipNext()
+    Collector.push(name, () => Promise.resolve(Outcome.pass))
+  } else {
+    jestXTest(name, () => ())
+  }
+
+// xdescribe: register a describe block with every nested test pre-marked
+// skipped.
+let xdescribe = (label: string, body: unit => unit) =>
+  if Collector.isActive() {
+    Collector.skipDepth := Collector.skipDepth.contents + 1
+    Collector.pushDescribe(label, body)
+    Collector.skipDepth := Collector.skipDepth.contents - 1
+  } else {
+    jestXDescribe(label, body)
+  }

package/src/Filter.res.mjs

@@ -0,0 +1,40 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Outcome$ReventlessGwt from "./Outcome.res.mjs";
+import * as Collector$ReventlessGwt from "./Collector.res.mjs";
+
+function skip() {
+  Collector$ReventlessGwt.markSkipNext();
+}
+
+function only() {
+  Collector$ReventlessGwt.markOnlyNext();
+}
+
+function xtest(param, name, _body) {
+  if (Collector$ReventlessGwt.isActive()) {
+    Collector$ReventlessGwt.markSkipNext();
+    return Collector$ReventlessGwt.push(undefined, undefined, name, () => Promise.resolve(Outcome$ReventlessGwt.pass));
+  } else {
+    globalThis.xtest(name, () => {});
+    return;
+  }
+}
+
+function xdescribe(label, body) {
+  if (Collector$ReventlessGwt.isActive()) {
+    Collector$ReventlessGwt.skipDepth.contents = Collector$ReventlessGwt.skipDepth.contents + 1 | 0;
+    Collector$ReventlessGwt.pushDescribe(label, body);
+    Collector$ReventlessGwt.skipDepth.contents = Collector$ReventlessGwt.skipDepth.contents - 1 | 0;
+  } else {
+    globalThis.xdescribe(label, body);
+  }
+}
+
+export {
+  skip,
+  only,
+  xtest,
+  xdescribe,
+}
+/* No side effect */