@reventlessdev/reventless-gwt 1.0.0-alpha.74

package/src/ComponentScan.res

@@ -0,0 +1,103 @@
+// Walks each owning package's src/ tree and enumerates its Reventless
+// components by folder convention — including components with no GWT tests.
+// This is the inventory the `components` NDJSON event carries: the basis for
+// the activity-bar Plugin→kind→component tree and "untested slice" coverage.
+// Computed fresh per discovery so it never drifts as components are added.
+
+type component = {
+  // Absolute directory of the owning package (matches the `dir` in `packages`).
+  dir: string,
+  kind: string,
+  name: string,
+  // Absolute paths of the component's `src/` files (spec + body files like
+  // `*_Behavior.res` / `*_Mappings.res`), in walk order. Lets the client list
+  // spec / implementation files under each component node.
+  files: array<string>,
+}
+
+type dirent = {
+  name: string,
+  @as("isDirectory") _isDirectory: unit => bool,
+  @as("isFile") _isFile: unit => bool,
+}
+type readdirOpts = {withFileTypes: bool}
+@module("node:fs/promises")
+external _readdir: (string, readdirOpts) => promise<array<dirent>> = "readdir"
+@module("node:fs") external _existsSync: string => bool = "existsSync"
+@module("node:path") external join: (string, string) => string = "join"
+
+let ignoreNames = ["node_modules", ".git", "dist", "lib", ".history"]
+let shouldIgnore = (name: string) => Array.includes(ignoreNames, name)
+
+// A directory carrying this sentinel file — and its whole subtree — is pruned
+// from the component scan, matching `Discovery`'s `.gwtignore` convention so
+// the domain tree and the test tree exclude the same generated/vendored trees.
+let gwtIgnoreFile = ".gwtignore"
+let isPruned = (entries: array<dirent>) => entries->Array.some(e => e.name == gwtIgnoreFile)
+
+// Source `.res` only — `.res.mjs` / `.res.js` end in `.mjs` / `.js`, and `.resi`
+// in `.resi`, so a plain `.res` suffix test excludes compiled output + interfaces.
+let isSrcResFile = (name: string) => String.endsWith(name, ".res")
+
+let rec walk = async (dir: string, acc: array<string>): array<string> => {
+  let entries = try {
+    await _readdir(dir, {withFileTypes: true})
+  } catch {
+  | _ => []
+  }
+  if isPruned(entries) {
+    acc
+  } else {
+  let found = ref(acc)
+  for i in 0 to entries->Array.length - 1 {
+    let entry = entries->Array.getUnsafe(i)
+    if !shouldIgnore(entry.name) {
+      let full = join(dir, entry.name)
+      if entry._isDirectory() {
+        let nested = await walk(full, [])
+        found := Array.concat(found.contents, nested)
+      } else if entry._isFile() && isSrcResFile(entry.name) {
+        found := Array.concat(found.contents, [full])
+      }
+    }
+  }
+  found.contents
+  }
+}
+
+// Enumerate components across the given package directories (deduplicated per
+// dir+kind+name, declaration order preserved). Each component accumulates the
+// source files that map to it (spec + body files).
+type orderEntry = {dir: string, kind: string, name: string, key: string}
+
+let scan = async (pkgDirs: array<string>): array<component> => {
+  let order = []
+  let filesByKey = Dict.make()
+  for i in 0 to pkgDirs->Array.length - 1 {
+    let dir = pkgDirs->Array.getUnsafe(i)
+    let srcDir = join(dir, "src")
+    if _existsSync(srcDir) {
+      let files = await walk(srcDir, [])
+      files->Array.forEach(file =>
+        switch ComponentMeta.componentOfSrcFile(file) {
+        | Some(c) =>
+          let key = dir ++ "::" ++ c.kind ++ "::" ++ c.name
+          switch filesByKey->Dict.get(key) {
+          | Some(existing) => filesByKey->Dict.set(key, Array.concat(existing, [file]))
+          | None => {
+              filesByKey->Dict.set(key, [file])
+              order->Array.push({dir, kind: c.kind, name: c.name, key})
+            }
+          }
+        | None => ()
+        }
+      )
+    }
+  }
+  order->Array.map(o => {
+    dir: o.dir,
+    kind: o.kind,
+    name: o.name,
+    files: filesByKey->Dict.get(o.key)->Option.getOr([]),
+  })
+}

package/src/ComponentScan.res.mjs

@@ -0,0 +1,105 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Nodefs from "node:fs";
+import * as Nodepath from "node:path";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Promises from "node:fs/promises";
+import * as ComponentMeta$ReventlessGwt from "./ComponentMeta.res.mjs";
+
+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 isSrcResFile(name) {
+  return name.endsWith(".res");
+}
+
+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() && entry.name.endsWith(".res")) {
+        found = found.concat([full]);
+      }
+    }
+  }
+  return found;
+}
+
+async function scan(pkgDirs) {
+  let order = [];
+  let filesByKey = {};
+  for (let i = 0, i_finish = pkgDirs.length; i < i_finish; ++i) {
+    let dir = pkgDirs[i];
+    let srcDir = Nodepath.join(dir, "src");
+    if (Nodefs.existsSync(srcDir)) {
+      let files = await walk(srcDir, []);
+      files.forEach(file => {
+        let c = ComponentMeta$ReventlessGwt.componentOfSrcFile(file);
+        if (c === undefined) {
+          return;
+        }
+        let key = dir + "::" + c.kind + "::" + c.name;
+        let existing = filesByKey[key];
+        if (existing !== undefined) {
+          filesByKey[key] = existing.concat([file]);
+        } else {
+          filesByKey[key] = [file];
+          order.push({
+            dir: dir,
+            kind: c.kind,
+            name: c.name,
+            key: key
+          });
+        }
+      });
+    }
+  }
+  return order.map(o => ({
+    dir: o.dir,
+    kind: o.kind,
+    name: o.name,
+    files: Stdlib_Option.getOr(filesByKey[o.key], [])
+  }));
+}
+
+export {
+  ignoreNames,
+  shouldIgnore,
+  gwtIgnoreFile,
+  isPruned,
+  isSrcResFile,
+  walk,
+  scan,
+}
+/* node:fs Not a pure module */

package/src/Delegate_GWT.res

@@ -0,0 +1,303 @@
+open ReventlessCore
+
+// Delegate_GWT — GWT for ExtensionPoint mappings and Extension delegates.
+//
+// Both are pure input → published-actions translations and form the one
+// cross-plugin behavioural seam (per `.claude/rules/app-developer.md`). Each
+// mapping has TWO directions, and each adapter drives both:
+//
+//   * an ExtensionPoint mapping turns an internal `Delegate` event into public
+//     extension-point EVENTS (`mapOutgoingEvent`), and an incoming protocol
+//     COMMAND into a wrapped-aggregate command (`mapIncomingCommand`);
+//   * an Extension delegate turns an incoming extension-point EVENT into delegate
+//     COMMANDS (`mapIncomingEvent`), and an internal `Delegate` event into an
+//     outgoing protocol COMMAND (`mapOutgoingEvent`).
+//
+// The stimulus you inject names what arrives at the mapping, NOT what it emits:
+//   * `whenDelegateEvent`  — an internal delegate event occurs (both adapters'
+//     `mapOutgoingEvent`);
+//   * `whenIncomingEvent`  — a protocol event arrives (Extension `mapIncomingEvent`);
+//   * `whenIncomingCommand`— a protocol command arrives (EP `mapIncomingCommand`).
+//
+// This DSL drives the user-level mapping function with the inert `StubRuntime`
+// handles and asserts the SET of published actions — including one-to-many
+// fan-out (e.g. `OrderPlaced{productIds:[…]}` → N × `ItemOrdered`).
+//
+// `FromExtensionPoint(M)` / `FromExtension(M)` mirror the From* adapter pattern
+// of `Mapping_GWT` / `Query_GWT`: one comparison core per direction.
+//
+// See `docs/plans/done/gwt-flow-and-extension-test-kinds.md` Phase 1.
+
+module EPMapping = ReventlessInfra.ExtensionPointMapping
+module ExtMapping = ReventlessInfra.ExtensionMapping
+
+// A published action normalised for comparison: a routing target plus the
+// encoded payload. EP events are keyed by entity id; delegate commands by the
+// component (slice/aggregate) or extension-point they route to.
+let encPublished = (~target: string, payload: JSON.t): JSON.t => {
+  let d = Dict.make()
+  d->Dict.set("target", JSON.Encode.string(target))
+  d->Dict.set("payload", payload)
+  JSON.Encode.object(d)
+}
+
+// -- Comparison core ---------------------------------------------------------
+
+module type Delegate = {
+  let name: string
+  type inbound
+  // Drive the underlying mapping with StubRuntime, returning the published
+  // actions already normalised to JSON.
+  let run: inbound => promise<array<JSON.t>>
+}
+
+module type T = {
+  type inbound
+
+  let describe: (string, unit => unit) => unit
+  let test: (string, ~timeout: int=?, unit => promise<Outcome.outcome>) => unit
+
+  // Feed the stimulus into the mapping; returns the normalised published actions.
+  // The adapters re-export this under direction-specific names (whenDelegateEvent
+  // / whenIncomingEvent / whenIncomingCommand).
+  let whenInput: inbound => promise<array<JSON.t>>
+  let thenPublishedJson: (promise<array<JSON.t>>, array<JSON.t>) => promise<Outcome.outcome>
+  let thenPublishesNothing: promise<array<JSON.t>> => promise<Outcome.outcome>
+  // Assert the SET of HANDLED DIRECTIVES (HandleDirective actions, encoded by the
+  // EP/Extension directive schema). Disjoint from thenPublishedJson — published
+  // events/commands and handled directives are separate channels.
+  let thenHandlesDirectivesJson: (promise<array<JSON.t>>, array<JSON.t>) => promise<Outcome.outcome>
+}
+
+module Make = (D: Delegate): (T with type inbound = D.inbound) => {
+  type inbound = D.inbound
+
+  S.enableJson()
+
+  let describe = JestBind.describe
+  let test = (name, ~timeout=?, body) =>
+    JestBind.testPromise(~slice=D.name, name, ~timeout?, body)
+
+  let whenInput = ev => D.run(ev)
+
+  // Published actions form a SET — fan-out order is non-deterministic, so the
+  // comparison sorts by stringified JSON before comparing.
+  let sortJson = (arr: array<JSON.t>) =>
+    arr->Array.toSorted((a, b) => String.compare(JSON.stringify(a), JSON.stringify(b)))
+
+  // Handled directives ride the same normalised array tagged `target:"directive"`
+  // so a single mapping run carries both channels; the publish/directive verbs
+  // each project to their own. (Published actions never use that target — EP/Ext
+  // events and commands route to an id, a component name, or `<ep>:<id>`.)
+  let targetOf = (j: JSON.t): string =>
+    j
+    ->JSON.Decode.object
+    ->Option.flatMap(d => d->Dict.get("target"))
+    ->Option.flatMap(JSON.Decode.string)
+    ->Option.getOr("")
+  let dropDirectives = arr => arr->Array.filter(j => targetOf(j) != "directive")
+  let onlyDirectives = arr => arr->Array.filter(j => targetOf(j) == "directive")
+
+  let thenPublishedJson = async (actionsP, expected) => {
+    let actual = (await actionsP)->dropDirectives
+    if sortJson(actual) == sortJson(expected) {
+      Outcome.pass
+    } else {
+      Outcome.fail(PublishedActionsMismatch({expected, actual}))
+    }
+  }
+
+  let thenPublishesNothing = actionsP => thenPublishedJson(actionsP, [])
+
+  let thenHandlesDirectivesJson = async (actionsP, expected) => {
+    let actual = (await actionsP)->onlyDirectives
+    if sortJson(actual) == sortJson(expected) {
+      Outcome.pass
+    } else {
+      Outcome.fail(PublishedActionsMismatch({expected, actual}))
+    }
+  }
+}
+
+// -- FromExtensionPoint: an EP mapping (both directions) ---------------------
+
+module FromExtensionPoint = (M: EPMapping.Mapping) => {
+  let encEvent = (e: M.ExtensionPoint.event) => e->Message.encode(M.ExtensionPoint.eventSchema)
+  let encCommand = (c: M.Delegate.command) => c->Message.encode(M.Delegate.commandSchema)
+  let encDirective = (d: M.ExtensionPoint.directive) =>
+    encPublished(~target="directive", d->Message.encode(M.ExtensionPoint.directiveSchema))
+
+  // Internal delegate event → outgoing extension-point events (`mapOutgoingEvent`).
+  module EvCore = Make({
+    let name = M.ExtensionPoint.name
+    type inbound = M.Delegate.event
+    let run = async (event: M.Delegate.event) =>
+      switch M.mapOutgoingEvent {
+      | None => []
+      | Some(f) =>
+        let nested =
+          await f("gwt-id", event, StubRuntime.meta, StubRuntime.queryEngine)
+          ->Array.map(async action =>
+            switch action {
+            | EPMapping.PublishEvent(id, ev) => [encPublished(~target=id, encEvent(ev))]
+            | EPMapping.PublishEventAsync(p) =>
+              let (id, ev) = await p
+              [encPublished(~target=id, encEvent(ev))]
+            | EPMapping.HandleDirective(_, dir) => [encDirective(dir)]
+            }
+          )
+          ->Promise.all
+        nested->Array.flat
+      }
+  })
+
+  // Incoming extension-point command → wrapped-aggregate commands (`mapIncomingCommand`).
+  module CmdCore = Make({
+    let name = M.ExtensionPoint.name
+    type inbound = M.ExtensionPoint.command
+    let run = async (command: M.ExtensionPoint.command) =>
+      M.mapIncomingCommand("gwt-id", command, StubRuntime.meta)->Array.filterMap(action =>
+        switch action {
+        | EPMapping.PublishCommand(id, cmd) => Some(encPublished(~target=id, encCommand(cmd)))
+        | EPMapping.HandleDirective(_, dir) => Some(encDirective(dir))
+        }
+      )
+  })
+
+  type inbound = M.Delegate.event
+  let describe = EvCore.describe
+  let test = EvCore.test
+  // `thenPublishesNothing` is direction-agnostic (compares to []), usable after
+  // either `whenDelegateEvent` or `whenIncomingCommand`.
+  let thenPublishesNothing = EvCore.thenPublishesNothing
+
+  // Delegate event → outgoing protocol events.
+  let whenDelegateEvent = EvCore.whenInput
+  let thenPublishesEvent = (actionsP, id, event: M.ExtensionPoint.event) =>
+    EvCore.thenPublishedJson(actionsP, [encPublished(~target=id, encEvent(event))])
+  let thenPublishesEvents = (actionsP, pairs: array<(string, M.ExtensionPoint.event)>) =>
+    EvCore.thenPublishedJson(
+      actionsP,
+      pairs->Array.map(((id, ev)) => encPublished(~target=id, encEvent(ev))),
+    )
+
+  // Incoming protocol command → wrapped-aggregate commands.
+  let whenIncomingCommand = CmdCore.whenInput
+  let thenPublishesCommand = (actionsP, id, cmd: M.Delegate.command) =>
+    CmdCore.thenPublishedJson(actionsP, [encPublished(~target=id, encCommand(cmd))])
+  let thenPublishesCommands = (actionsP, pairs: array<(string, M.Delegate.command)>) =>
+    CmdCore.thenPublishedJson(
+      actionsP,
+      pairs->Array.map(((id, cmd)) => encPublished(~target=id, encCommand(cmd))),
+    )
+
+  // Handled directives — usable after either `when`; both cores tag directives on
+  // the same channel, so this projects them out regardless of direction.
+  let thenHandlesDirective = (actionsP, directive: M.ExtensionPoint.directive) =>
+    EvCore.thenHandlesDirectivesJson(actionsP, [encDirective(directive)])
+  let thenHandlesDirectives = (actionsP, directives: array<M.ExtensionPoint.directive>) =>
+    EvCore.thenHandlesDirectivesJson(actionsP, directives->Array.map(encDirective))
+  let thenHandlesNoDirective = actionsP => EvCore.thenHandlesDirectivesJson(actionsP, [])
+}
+
+// -- FromExtension: an Extension delegate (both directions) ------------------
+
+module FromExtension = (M: ExtMapping.Mapping) => {
+  let encCmd = (c: M.Delegate.command) => c->Message.encode(M.Delegate.commandSchema)
+  let encEpCmd = (c: M.ExtensionPoint.command) => c->Message.encode(M.ExtensionPoint.commandSchema)
+  let encDirective = (d: M.ExtensionPoint.directive) =>
+    encPublished(~target="directive", d->Message.encode(M.ExtensionPoint.directiveSchema))
+
+  // Incoming extension-point event → delegate commands (`mapIncomingEvent`).
+  module EvCore = Make({
+    let name = M.Delegate.name
+    type inbound = M.ExtensionPoint.event
+    let run = async (event: M.ExtensionPoint.event) => {
+      let nested =
+        await M.mapIncomingEvent(
+          "gwt-id",
+          event,
+          StubRuntime.meta,
+          StubRuntime.pluginDefinition,
+          StubRuntime.queryEngine,
+        )
+        ->Array.map(async action =>
+          switch action {
+          | ExtMapping.PublishStateChangeSliceCommand(cmd) => [
+              encPublished(~target=M.Delegate.name, encCmd(cmd)),
+            ]
+          | ExtMapping.PublishStateChangeSliceCommandAsync(p) =>
+            let cmd = await p
+            [encPublished(~target=M.Delegate.name, encCmd(cmd))]
+          | ExtMapping.PublishStateChangeSliceCommandsAsync(p) =>
+            (await p)->Array.map(cmd => encPublished(~target=M.Delegate.name, encCmd(cmd)))
+          | ExtMapping.PublishAggregateCommand(id, cmd) => [encPublished(~target=id, encCmd(cmd))]
+          | ExtMapping.PublishAggregateCommandAsync(p) =>
+            let (id, cmd) = await p
+            [encPublished(~target=id, encCmd(cmd))]
+          | ExtMapping.PublishAggregateCommandsAsync(p) =>
+            (await p)->Array.map(((id, cmd)) => encPublished(~target=id, encCmd(cmd)))
+          | ExtMapping.PublishExtensionPointCommand(id, cmd) => [
+              encPublished(~target=id, encEpCmd(cmd)),
+            ]
+          | ExtMapping.ForwardCommand({extensionPointName, id, commandJson}) => [
+              encPublished(~target=`${extensionPointName}:${id}`, commandJson),
+            ]
+          | ExtMapping.HandleDirective(_, dir) => [encDirective(dir)]
+          }
+        )
+        ->Promise.all
+      nested->Array.flat
+    }
+  })
+
+  // Internal delegate event → outgoing protocol commands (`mapOutgoingEvent`, optional).
+  module OutCore = Make({
+    let name = M.Delegate.name
+    type inbound = M.Delegate.event
+    let run = async (event: M.Delegate.event) =>
+      switch M.mapOutgoingEvent {
+      | None => []
+      | Some(f) =>
+        f("gwt-id", event, StubRuntime.meta, StubRuntime.pluginDefinition)->Array.filterMap(action =>
+          switch action {
+          | ExtMapping.PublishExtensionPointCommand(id, cmd) =>
+            Some(encPublished(~target=id, encEpCmd(cmd)))
+          | ExtMapping.ForwardCommand({extensionPointName, id, commandJson}) =>
+            Some(encPublished(~target=`${extensionPointName}:${id}`, commandJson))
+          | ExtMapping.HandleDirective(_, dir) => Some(encDirective(dir))
+          }
+        )
+      }
+  })
+
+  type inbound = M.ExtensionPoint.event
+  let describe = EvCore.describe
+  let test = EvCore.test
+  let thenPublishesNothing = EvCore.thenPublishesNothing
+
+  // Incoming protocol event → delegate commands.
+  let whenIncomingEvent = EvCore.whenInput
+  let thenPublishesCommand = (actionsP, cmd: M.Delegate.command) =>
+    EvCore.thenPublishedJson(actionsP, [encPublished(~target=M.Delegate.name, encCmd(cmd))])
+  let thenPublishesCommands = (actionsP, cmds: array<M.Delegate.command>) =>
+    EvCore.thenPublishedJson(
+      actionsP,
+      cmds->Array.map(cmd => encPublished(~target=M.Delegate.name, encCmd(cmd))),
+    )
+  let thenPublishesAggregateCommand = (actionsP, id, cmd: M.Delegate.command) =>
+    EvCore.thenPublishedJson(actionsP, [encPublished(~target=id, encCmd(cmd))])
+
+  // Internal delegate event → outgoing protocol commands.
+  let whenDelegateEvent = OutCore.whenInput
+  let thenPublishesExtensionPointCommand = (actionsP, id, cmd: M.ExtensionPoint.command) =>
+    OutCore.thenPublishedJson(actionsP, [encPublished(~target=id, encEpCmd(cmd))])
+
+  // Handled directives — usable after either `when` (both cores tag directives on
+  // the same channel).
+  let thenHandlesDirective = (actionsP, directive: M.ExtensionPoint.directive) =>
+    EvCore.thenHandlesDirectivesJson(actionsP, [encDirective(directive)])
+  let thenHandlesDirectives = (actionsP, directives: array<M.ExtensionPoint.directive>) =>
+    EvCore.thenHandlesDirectivesJson(actionsP, directives->Array.map(encDirective))
+  let thenHandlesNoDirective = actionsP => EvCore.thenHandlesDirectivesJson(actionsP, [])
+}