@reventlessdev/reventless-gwt 1.0.0-alpha.100

package/src/Hint.res.mjs

@@ -0,0 +1,124 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+
+function variantTag(j) {
+  if (j === null || Array.isArray(j)) {
+    return;
+  }
+  switch (typeof j) {
+    case "string" :
+      return j;
+    case "object" :
+      let match = j["TAG"];
+      if (typeof match === "string") {
+        return match;
+      } else {
+        return;
+      }
+    default:
+      return;
+  }
+}
+
+function forMismatch(sliceOpt, m) {
+  let slice = sliceOpt !== undefined ? sliceOpt : "<slice>";
+  switch (m.TAG) {
+    case "EventsMismatch" :
+      return {
+        locus: slice + `.decide`,
+        branch: undefined,
+        message: "decide() returned different events than expected. Check the event payload and count."
+      };
+    case "ErrorMismatch" :
+      let actual = m.actual;
+      if (actual === undefined) {
+        return {
+          locus: slice + `.decide`,
+          branch: undefined,
+          message: "decide() returned Ok([...]) but the test expected Error."
+        };
+      }
+      let match = variantTag(m.expected);
+      let match$1 = variantTag(actual);
+      let message = match !== undefined && match$1 !== undefined && match === match$1 ? `decide() returned Error(` + match + `) as expected, but with a different payload.` : "decide() returned a different Error variant than expected.";
+      return {
+        locus: slice + `.decide`,
+        branch: undefined,
+        message: message
+      };
+    case "StateMismatch" :
+      return {
+        locus: slice + `.evolve`,
+        branch: undefined,
+        message: "evolve() produced a different state than expected. Check the fold and missing event branches."
+      };
+    case "NoEventExpected" :
+      return {
+        locus: slice + `.decide`,
+        branch: undefined,
+        message: "decide() emitted events but the test expected none — possible idempotency miss."
+      };
+    case "TodoMismatch" :
+      return {
+        locus: slice + `.collect / ` + slice + `.resolve`,
+        branch: undefined,
+        message: "The automation slice's TODO projection diverged from the expected set."
+      };
+    case "AppendConditionMismatch" :
+      return {
+        locus: slice + `.commandSchema`,
+        branch: undefined,
+        message: "DCB optimistic-concurrency condition drift — likely a missing `@s.matches(DcbTag.string)` annotation on a command field, or the expected condition documented in the test disagrees with what the runtime would build."
+      };
+    case "TranslateError" :
+      return {
+        locus: slice + `.translate`,
+        branch: undefined,
+        message: "The translation slice returned a different result than expected."
+      };
+    case "QueryRowsMismatch" :
+      return {
+        locus: slice + `.config`,
+        branch: undefined,
+        message: "The read-model query returned wrong rows — likely a missing index, sub-id, or resolver."
+      };
+    case "PublishedActionsMismatch" :
+      return {
+        locus: slice + `.mapOutgoingEvent / ` + slice + `.mapIncomingEvent`,
+        branch: undefined,
+        message: "The ExtensionPoint mapping / Extension delegate published a different set of events or commands than expected. Check the variant match arms and the one-to-many fan-out."
+      };
+    case "Throw" :
+      return {
+        locus: slice,
+        branch: undefined,
+        message: `The slice threw an exception: ` + m.error
+      };
+  }
+}
+
+function toJson(h) {
+  let obj = {};
+  obj["locus"] = h.locus;
+  obj["branch"] = Stdlib_Option.mapOr(h.branch, null, prim => prim);
+  obj["message"] = h.message;
+  return obj;
+}
+
+function format(h) {
+  let b = h.branch;
+  if (b !== undefined) {
+    return `hint: ` + h.message + `\n      Look at ` + h.locus + `'s branch ` + b + `.`;
+  } else {
+    return `hint: ` + h.message + `\n      Look at ` + h.locus + `.`;
+  }
+}
+
+export {
+  variantTag,
+  forMismatch,
+  toJson,
+  format,
+}
+/* No side effect */

package/src/InboundTranslation_GWT.res

@@ -0,0 +1,83 @@
+open ReventlessCore
+
+// Minimal inline spec for InboundTranslationSlice. sury-ppx processes the
+// @schema attributes in the same compilation unit as the functor — matches
+// the pattern used by the other GWT DSLs.
+module type SliceSpec = {
+  let name: string
+
+  @schema
+  type externalInput
+
+  @schema
+  type command
+
+  let translate: externalInput => result<array<(string, command)>, string>
+}
+
+module type T = {
+  module Spec: SliceSpec
+
+  let describe: (string, unit => unit) => unit
+  let test: (string, unit => Outcome.outcome) => unit
+
+  type translateResult = result<array<(string, Spec.command)>, string>
+
+  let whenInput: Spec.externalInput => translateResult
+  let thenCommands: (translateResult, array<(string, Spec.command)>) => Outcome.outcome
+  let thenCommand: (translateResult, string, Spec.command) => Outcome.outcome
+  let thenNoCommand: translateResult => Outcome.outcome
+  let thenTranslateError: (translateResult, string) => Outcome.outcome
+}
+
+module Make = (Spec: SliceSpec): (T with module Spec = Spec) => {
+  module Spec = Spec
+
+  S.enableJson()
+
+  let describe = JestBind.describe
+  let test = (name, body) => JestBind.test(~slice=Spec.name, name, body)
+
+  type translateResult = result<array<(string, Spec.command)>, string>
+
+  let encCommand = (c: Spec.command) => c->Message.encode(Spec.commandSchema)
+  let encPairs = (pairs: array<(string, Spec.command)>) =>
+    pairs->Array.map(((id, cmd)) => {
+      let d = Dict.make()
+      d->Dict.set("id", JSON.Encode.string(id))
+      d->Dict.set("command", encCommand(cmd))
+      JSON.Encode.object(d)
+    })
+
+  let whenInput = input => Spec.translate(input)
+
+  let thenCommands = (result, expected) =>
+    switch result {
+    | Ok(actual) if actual == expected => Outcome.pass
+    | Ok(actual) =>
+      Outcome.fail(
+        EventsMismatch({expected: encPairs(expected), actual: encPairs(actual)}),
+      )
+    | Error(msg) =>
+      Outcome.fail(TranslateError({expected: "(commands)", actual: Some(msg)}))
+    }
+
+  let thenCommand = (result, expectedId, expectedCmd) =>
+    thenCommands(result, [(expectedId, expectedCmd)])
+
+  let thenNoCommand = result =>
+    switch result {
+    | Ok([]) => Outcome.pass
+    | Ok(actual) => Outcome.fail(NoEventExpected({actual: encPairs(actual)}))
+    | Error(msg) =>
+      Outcome.fail(TranslateError({expected: "(no commands)", actual: Some(msg)}))
+    }
+
+  let thenTranslateError = (result, expectedMsg) =>
+    switch result {
+    | Error(actual) if actual == expectedMsg => Outcome.pass
+    | Error(actual) =>
+      Outcome.fail(TranslateError({expected: expectedMsg, actual: Some(actual)}))
+    | Ok(_) => Outcome.fail(TranslateError({expected: expectedMsg, actual: None}))
+    }
+}

package/src/InboundTranslation_GWT.res.mjs

@@ -0,0 +1,94 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as S from "sury/src/S.res.mjs";
+import * as Primitive_object from "@rescript/runtime/lib/es6/Primitive_object.js";
+import * as Outcome$ReventlessGwt from "./Outcome.res.mjs";
+import * as JestBind$ReventlessGwt from "./JestBind.res.mjs";
+import * as Message$ReventlessCore from "@reventlessdev/reventless-core/src/Message.res.mjs";
+
+function Make(Spec) {
+  S.enableJson();
+  let test = (name, body) => JestBind$ReventlessGwt.test(Spec.name, name, body);
+  let encPairs = pairs => pairs.map(param => {
+    let d = {};
+    d["id"] = param[0];
+    d["command"] = Message$ReventlessCore.encode(param[1], Spec.commandSchema);
+    return d;
+  });
+  let whenInput = input => Spec.translate(input);
+  let thenCommands = (result, expected) => {
+    if (result.TAG !== "Ok") {
+      return Outcome$ReventlessGwt.fail({
+        TAG: "TranslateError",
+        expected: "(commands)",
+        actual: result._0
+      });
+    }
+    let actual = result._0;
+    if (Primitive_object.equal(actual, expected)) {
+      return Outcome$ReventlessGwt.pass;
+    } else {
+      return Outcome$ReventlessGwt.fail({
+        TAG: "EventsMismatch",
+        expected: encPairs(expected),
+        actual: encPairs(actual)
+      });
+    }
+  };
+  let thenCommand = (result, expectedId, expectedCmd) => thenCommands(result, [[
+      expectedId,
+      expectedCmd
+    ]]);
+  let thenNoCommand = result => {
+    if (result.TAG !== "Ok") {
+      return Outcome$ReventlessGwt.fail({
+        TAG: "TranslateError",
+        expected: "(no commands)",
+        actual: result._0
+      });
+    }
+    let actual = result._0;
+    if (actual.length !== 0) {
+      return Outcome$ReventlessGwt.fail({
+        TAG: "NoEventExpected",
+        actual: encPairs(actual)
+      });
+    } else {
+      return Outcome$ReventlessGwt.pass;
+    }
+  };
+  let thenTranslateError = (result, expectedMsg) => {
+    if (result.TAG === "Ok") {
+      return Outcome$ReventlessGwt.fail({
+        TAG: "TranslateError",
+        expected: expectedMsg,
+        actual: undefined
+      });
+    }
+    let actual = result._0;
+    if (actual === expectedMsg) {
+      return Outcome$ReventlessGwt.pass;
+    } else {
+      return Outcome$ReventlessGwt.fail({
+        TAG: "TranslateError",
+        expected: expectedMsg,
+        actual: actual
+      });
+    }
+  };
+  return {
+    Spec: Spec,
+    describe: JestBind$ReventlessGwt.describe,
+    test: test,
+    whenInput: whenInput,
+    thenCommands: thenCommands,
+    thenCommand: thenCommand,
+    thenNoCommand: thenNoCommand,
+    thenTranslateError: thenTranslateError
+  };
+}
+
+export {
+  Make,
+}
+/* S Not a pure module */

package/src/JestBind.res

@@ -0,0 +1,70 @@
+// Bridge between the runner-agnostic `Outcome.outcome` algebra and Jest.
+//
+// GWT DSLs emit `Outcome.outcome` from every `then*` combinator. Test files
+// registered via `JestBind.test` / `JestBind.testPromise` have their body's
+// outcome translated into a Jest pass/fail, unless the standalone CLI runner
+// has activated its in-process `Collector` — in which case the call pushes
+// straight into the collector and skips Jest. This lets the same test file
+// run under either `pnpm jest` or `reventless-gwt run` without modification.
+//
+// `~slice` is the slice/component name — each DSL threads `Spec.name` through
+// so failure hints read `Look at AddCategory.decide` rather than the generic
+// `<slice>.decide` fallback.
+//
+// The Jest arm binds directly to Jest's globals via @reventlessdev/rescript-jest
+// (module `JestGlobals`) with throwing semantics: a passing outcome is a no-op,
+// a failing one throws a JS Error whose message Jest reports. (Jest's built-in
+// `fail(msg)` was removed in Jest 27+ ESM mode — the mode these tests run under
+// — so throwing is the portable way to fail a test.)
+
+// Translate an outcome into Jest's throwing model: Ok is a no-op, Error throws
+// the formatted mismatch + hint so Jest reports it as the failure message.
+let assertOutcome = (~slice=?, outcome: Outcome.outcome): unit =>
+  switch outcome {
+  | Ok() => ()
+  | Error(m) => {
+      let hint = Hint.forMismatch(~slice?, m)
+      JsError.throwWithMessage(`${Outcome.format(m)}\n\n${Hint.format(hint)}`)
+    }
+  }
+
+let describe = (label: string, body: unit => unit) =>
+  if Collector.isActive() {
+    Collector.pushDescribe(label, body)
+  } else {
+    JestGlobals.describe(label, body)
+  }
+
+// Pending-spec placeholder emitted by the codegen for slices with no upstream
+// specification. Registers a non-running, non-failing entry under both runners.
+let todo = (label: string) =>
+  if Collector.isActive() {
+    Collector.pushTodo(label)
+  } else {
+    JestGlobals.todo(label)
+  }
+
+let test = (~slice=?, name: string, body: unit => Outcome.outcome) =>
+  if Collector.isActive() {
+    let location = Collector.captureLocation(1)
+    Collector.push(~slice?, ~location?, name, () => Promise.resolve(body()))
+  } else {
+    JestGlobals.testSync(name, () => assertOutcome(~slice?, body()))
+  }
+
+let testPromise = (
+  ~slice=?,
+  name: string,
+  ~timeout: option<int>=?,
+  body: unit => promise<Outcome.outcome>,
+) =>
+  if Collector.isActive() {
+    let location = Collector.captureLocation(1)
+    Collector.push(~slice?, ~location?, ~timeout?, name, body)
+  } else {
+    switch timeout {
+    | Some(t) =>
+      JestGlobals.testWithTimeout(name, async () => assertOutcome(~slice?, await body()), t)
+    | None => JestGlobals.testPromise(name, async () => assertOutcome(~slice?, await body()))
+    }
+  }

package/src/JestBind.res.mjs

@@ -0,0 +1,63 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
+import * as Hint$ReventlessGwt from "./Hint.res.mjs";
+import * as Outcome$ReventlessGwt from "./Outcome.res.mjs";
+import * as Collector$ReventlessGwt from "./Collector.res.mjs";
+
+function assertOutcome(slice, outcome) {
+  if (outcome.TAG === "Ok") {
+    return;
+  }
+  let m = outcome._0;
+  let hint = Hint$ReventlessGwt.forMismatch(slice, m);
+  Stdlib_JsError.throwWithMessage(Outcome$ReventlessGwt.format(m) + `\n\n` + Hint$ReventlessGwt.format(hint));
+}
+
+function describe(label, body) {
+  if (Collector$ReventlessGwt.isActive()) {
+    return Collector$ReventlessGwt.pushDescribe(label, body);
+  } else {
+    globalThis.describe(label, body);
+    return;
+  }
+}
+
+function todo(label) {
+  if (Collector$ReventlessGwt.isActive()) {
+    return Collector$ReventlessGwt.pushTodo(label);
+  } else {
+    globalThis.test.todo(label);
+    return;
+  }
+}
+
+function test(slice, name, body) {
+  if (Collector$ReventlessGwt.isActive()) {
+    let location = Collector$ReventlessGwt.captureLocation(1);
+    return Collector$ReventlessGwt.push(slice, location, undefined, name, () => Promise.resolve(body()));
+  }
+  globalThis.test(name, () => assertOutcome(slice, body()));
+}
+
+function testPromise(slice, name, timeout, body) {
+  if (!Collector$ReventlessGwt.isActive()) {
+    if (timeout !== undefined) {
+      globalThis.test(name, async () => assertOutcome(slice, await body()), timeout);
+    } else {
+      globalThis.test(name, async () => assertOutcome(slice, await body()));
+    }
+    return;
+  }
+  let location = Collector$ReventlessGwt.captureLocation(1);
+  Collector$ReventlessGwt.push(slice, location, timeout, name, body);
+}
+
+export {
+  assertOutcome,
+  describe,
+  todo,
+  test,
+  testPromise,
+}
+/* No side effect */

package/src/Loader.res

@@ -0,0 +1,24 @@
+// Dynamic-import wrapper. Each GWT test file registers describe/test at
+// import time, so the caller must `Collector.activate()` before invoking
+// `loadFile` and drain after. The loader converts the absolute path into
+// a `file://` URL so Node's ESM loader accepts it.
+//
+// A monotonic cache-busting query (`?t=N`) is appended so every load
+// re-executes the module's top-level registration. Node's ESM cache is keyed
+// by URL (not mtime), so without this a second load in the same process — the
+// `discover`-then-run within `watch`, and every re-run after a recompile —
+// would hit the cache, skip registration, and drain zero tests. The `?t=`
+// query is stripped from captured stack frames in `Collector.parseFrame`.
+
+@module("node:url") external pathToFileURL: string => {"href": string} = "pathToFileURL"
+
+let dynamicImport: string => promise<'a> = %raw(`(u) => import(u)`)
+
+let counter = ref(0)
+
+let loadFile = async (absolutePath: string): unit => {
+  counter := counter.contents + 1
+  let url = pathToFileURL(absolutePath)
+  let busted = url["href"] ++ "?t=" ++ Int.toString(counter.contents)
+  let _: 'a = await dynamicImport(busted)
+}

package/src/Loader.res.mjs

@@ -0,0 +1,23 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Nodeurl from "node:url";
+
+let dynamicImport = ((u) => import(u));
+
+let counter = {
+  contents: 0
+};
+
+async function loadFile(absolutePath) {
+  counter.contents = counter.contents + 1 | 0;
+  let url = Nodeurl.pathToFileURL(absolutePath);
+  let busted = url.href + "?t=" + counter.contents.toString();
+  await dynamicImport(busted);
+}
+
+export {
+  dynamicImport,
+  counter,
+  loadFile,
+}
+/* node:url Not a pure module */

package/src/LocalHost.res

@@ -0,0 +1,119 @@
+// LocalHost — Phase 4.5 cold local-host foundation (shared by Phases 5, 6, and
+// the Phase 9 runner). Reflects the framework's own domain graph WITHOUT parsing
+// .res: instantiate reventless-local's `Platform.Make()` once, build each compiled
+// `Plugin.res.mjs` against it, read the resolved `pluginStructure` (a plain record
+// — no Pulumi Output), and collect the per-plugin structures.
+//
+// Proven cold (docs/analysis/reventless-vscode-domain-graph-design.md "Spike
+// result"): `Make()` and `Plugin.Make(plat)` open no ports and start no timers —
+// reading `pluginStructure` never touches the bus/scheduler/server wiring that the
+// live `deployPlugin` / `startServers` path adds (that path is the runner's, not
+// this). reventless-local is deliberately NOT a static dependency of reventless-gwt
+// (gwt is upstream of it); the platform module is reached at runtime by absolute
+// path via dynamic import, so a missing local platform is a caller concern, not a
+// compile-time coupling.
+
+@module("node:url") external pathToFileURL: string => {"href": string} = "pathToFileURL"
+@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"
+@module("node:path") external dirname: string => string = "dirname"
+
+type nodeRequire
+@module("node:module") external createRequire: string => nodeRequire = "createRequire"
+@send external requireResolve: (nodeRequire, string) => string = "resolve"
+
+let dynamicImport: string => promise<'a> = %raw(`(u) => import(u)`)
+
+// Monotonic cache-buster so repeated loads in one process (a watch session
+// re-reading the graph after a recompile) re-execute the composition root rather
+// than hit Node's URL-keyed ESM cache — same rationale as Loader.res. NOTE: only
+// the directly-imported modules are busted; transitively-cached component modules
+// stay warm, so a recompiled *component spec* is not picked up until the next load
+// of the composition root re-imports it. Full transitive invalidation is deferred
+// to the live-update work (Phase 6).
+let counter = ref(0)
+let bustedUrl = (absolutePath: string): string => {
+  counter := counter.contents + 1
+  pathToFileURL(absolutePath)["href"] ++ "?t=" ++ Int.toString(counter.contents)
+}
+
+type pluginRef = {name: string, modulePath: string, packageDir: string}
+
+type graph = {
+  structures: array<(string, Reventless.Plugin.pluginStructure)>,
+}
+
+// Dynamic-import shapes. Untyped at the boundary; reventless-local's Platform and
+// every generated Plugin emit these exact exports.
+type platform
+type localPlatformExports = {"Make": unit => platform}
+type builtPlugin = {"pluginStructure": Reventless.Plugin.pluginStructure}
+type pluginExports = {"Make": platform => builtPlugin}
+
+// ── Plugin name derivation — mirrors generator/Config.read exactly so the graph's
+//    plugin keys match the names the framework itself bakes into Plugin.res. ──
+
+// "@scope/my-catalog" → "MyCatalog", "online-shop" → "OnlineShop".
+// Single-sourced with the plugin generator (spec's `Config`) via
+// `Reventless.PluginName` so the two can't drift — a drift silently breaks
+// graph plugin keys (see the module for the full rationale). Re-exported here
+// under the historical name the tests already pin.
+let packageNameToPluginName = Reventless.PluginName.fromPackageName
+
+let strField = (json, key) =>
+  json->JSON.Decode.object->Option.flatMap(d => d->Dict.get(key))->Option.flatMap(JSON.Decode.string)
+
+let readJson = path =>
+  try Some(readFileSync(path, "utf8")->JSON.parseOrThrow) catch {
+  | _ => None
+  }
+
+// plugin.json `name` → else PascalCase(package.json `name`) → else "Plugin".
+// The precedence itself lives in `Reventless.PluginName.resolve`; this only
+// reads the two raw fields with the local node bindings.
+let derivePluginName = (~pluginSrcDir: string): string => {
+  let pluginJson = join(pluginSrcDir, "plugin.json")
+  let pluginJsonName =
+    existsSync(pluginJson) ? readJson(pluginJson)->Option.flatMap(j => strField(j, "name")) : None
+  let packageJsonName =
+    readJson(join(dirname(pluginSrcDir), "package.json"))->Option.flatMap(j => strField(j, "name"))
+  Reventless.PluginName.resolve(~pluginJsonName, ~packageJsonName)
+}
+
+// Given workspace package dirs (e.g. from PackageScan), keep those that carry a
+// compiled composition root and pair each with its framework plugin name.
+let discover = (~packageDirs: array<string>): array<pluginRef> =>
+  packageDirs->Array.filterMap(dir => {
+    let srcDir = join(dir, "src")
+    let modulePath = join(srcDir, "Plugin.res.mjs")
+    existsSync(modulePath)
+      ? Some({name: derivePluginName(~pluginSrcDir=srcDir), modulePath, packageDir: dir})
+      : None
+  })
+
+// Resolve reventless-local's compiled Platform module from a plugin package's
+// node_modules. reventless-gwt is upstream of reventless-local (no static dep), but
+// every plugin depends on it (`@reventlessdev/reventless-local`), so we resolve the
+// specifier relative to the plugin's package.json. `None` when it isn't installed
+// there — callers then skip platform-dependent features (dead-code / graph).
+let localPlatformSpecifier = "@reventlessdev/reventless-local/src/Platform.res.mjs"
+let resolveLocalPlatform = (~fromPackageDir: string): option<string> =>
+  try Some(createRequire(join(fromPackageDir, "package.json"))->requireResolve(localPlatformSpecifier)) catch {
+  | _ => None
+  }
+
+// Cold-load: instantiate the local platform once, build each plugin against it,
+// and read its (already-resolved) pluginStructure.
+let loadGraph = async (~platformModulePath: string, ~plugins: array<pluginRef>): graph => {
+  let platMod: localPlatformExports = await dynamicImport(bustedUrl(platformModulePath))
+  let plat = platMod["Make"]()
+  let structures = []
+  for i in 0 to plugins->Array.length - 1 {
+    let plugin = plugins->Array.getUnsafe(i)
+    let pluginMod: pluginExports = await dynamicImport(bustedUrl(plugin.modulePath))
+    let built = pluginMod["Make"](plat)
+    structures->Array.push((plugin.name, built["pluginStructure"]))
+  }
+  {structures: structures}
+}