@reventlessdev/reventless-gwt 1.0.0-alpha.74

package/tests/FormatterVsCodeMessageTest.res.mjs

@@ -0,0 +1,42 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as FormatterVsCode$ReventlessGwt from "../src/FormatterVsCode.res.mjs";
+
+function failingResult(mismatch) {
+  return {
+    id: "t1",
+    name: "rejects when category already exists",
+    describePath: [],
+    status: "Fail",
+    durationMs: 1.0,
+    location: undefined,
+    slice: undefined,
+    mismatch: mismatch,
+    skipReason: undefined
+  };
+}
+
+globalThis.describe("FormatterVsCode.messagePayload", () => {
+  globalThis.test("includes the mismatch kind for an EventsMismatch", async () => {
+    let m = FormatterVsCode$ReventlessGwt.messagePayload(failingResult({
+      TAG: "EventsMismatch",
+      expected: [],
+      actual: []
+    }));
+    globalThis.expect(m.kind).toEqual("EventsMismatch");
+  });
+  globalThis.test("includes the mismatch kind for an ErrorMismatch", async () => {
+    let m = FormatterVsCode$ReventlessGwt.messagePayload(failingResult({
+      TAG: "ErrorMismatch",
+      expected: "CategoryAlreadyExists",
+      actual: undefined,
+      actualEvents: []
+    }));
+    globalThis.expect(m.kind).toEqual("ErrorMismatch");
+  });
+});
+
+export {
+  failingResult,
+}
+/*  Not a pure module */

package/tests/InboundTranslationGwtTest.res

@@ -0,0 +1,34 @@
+// Worked example for InboundTranslationSlice_GWT — a payment webhook that
+// translates `status` into either a `ConfirmPayment` command or a
+// translation error for unknown statuses.
+
+@@reventless.gwt
+
+module PaymentWebhookSlice = {
+  let name = "PaymentWebhook"
+
+  @schema
+  type externalInput = {paymentId: string, orderId: string, status: string}
+
+  @schema
+  type command = ConfirmPayment({orderId: string, paymentId: string})
+
+  let translate = input =>
+    switch input.status {
+    | "completed" =>
+      Ok([(input.orderId, ConfirmPayment({orderId: input.orderId, paymentId: input.paymentId}))])
+    | _ => Error("Unknown payment status: " ++ input.status)
+    }
+}
+
+describe("PaymentWebhook InboundTranslationSlice", () => {
+  test("completed status emits ConfirmPayment", () =>
+    whenInput({paymentId: "p1", orderId: "o1", status: "completed"})
+    ->thenCommand("o1", ConfirmPayment({orderId: "o1", paymentId: "p1"}))
+  )
+
+  test("unknown status surfaces translate error", () =>
+    whenInput({paymentId: "p1", orderId: "o1", status: "garbage"})
+    ->thenTranslateError("Unknown payment status: garbage")
+  )
+})

package/tests/InboundTranslationGwtTest.res.mjs

@@ -0,0 +1,98 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as S from "sury/src/S.res.mjs";
+import * as InboundTranslation_GWT$ReventlessGwt from "../src/InboundTranslation_GWT.res.mjs";
+
+let externalInputSchema = S.schema(s => ({
+  paymentId: s.m(S.string),
+  orderId: s.m(S.string),
+  status: s.m(S.string)
+}));
+
+let commandSchema = S.schema(s => ({
+  TAG: "ConfirmPayment",
+  orderId: s.m(S.string),
+  paymentId: s.m(S.string)
+}));
+
+function translate(input) {
+  let match = input.status;
+  if (match === "completed") {
+    return {
+      TAG: "Ok",
+      _0: [[
+          input.orderId,
+          {
+            TAG: "ConfirmPayment",
+            orderId: input.orderId,
+            paymentId: input.paymentId
+          }
+        ]]
+    };
+  } else {
+    return {
+      TAG: "Error",
+      _0: "Unknown payment status: " + input.status
+    };
+  }
+}
+
+function commandAuthorization(param) {
+  return "AllowAuthenticated";
+}
+
+let PaymentWebhookSlice = {
+  name: "PaymentWebhook",
+  externalInputSchema: externalInputSchema,
+  commandSchema: commandSchema,
+  translate: translate,
+  commandAuthorization: commandAuthorization
+};
+
+let include = InboundTranslation_GWT$ReventlessGwt.Make(PaymentWebhookSlice);
+
+let describe = include.describe;
+
+let test = include.test;
+
+let whenInput = include.whenInput;
+
+let thenCommand = include.thenCommand;
+
+let thenTranslateError = include.thenTranslateError;
+
+describe("PaymentWebhook InboundTranslationSlice", () => {
+  test("completed status emits ConfirmPayment", () => thenCommand(whenInput({
+    paymentId: "p1",
+    orderId: "o1",
+    status: "completed"
+  }), "o1", {
+    TAG: "ConfirmPayment",
+    orderId: "o1",
+    paymentId: "p1"
+  }));
+  test("unknown status surfaces translate error", () => thenTranslateError(whenInput({
+    paymentId: "p1",
+    orderId: "o1",
+    status: "garbage"
+  }), "Unknown payment status: garbage"));
+});
+
+let Spec = include.Spec;
+
+let thenCommands = include.thenCommands;
+
+let thenNoCommand = include.thenNoCommand;
+
+export {
+  PaymentWebhookSlice,
+  Spec,
+  describe,
+  test,
+  whenInput,
+  thenCommands,
+  thenCommand,
+  thenNoCommand,
+  thenTranslateError,
+}
+/* externalInputSchema Not a pure module */

package/tests/LocalHostIntegration.res

@@ -0,0 +1,70 @@
+// Integration test for LocalHost.loadGraph — the cold-load path that instantiates
+// reventless-local's Platform and builds the real example plugins against it.
+//
+// Runs under `node --test` (NOT Jest) on purpose: cold-loading the local platform
+// under Jest's experimental-vm-modules hits the graphql/yoga CJS-in-ESM interop
+// wall documented in tests/SplitApiFixtures.res. Plain node ESM is exactly the
+// runtime the CLI host uses, and where the Phase 4.5 spike proved cold-load works
+// (docs/analysis/reventless-vscode-domain-graph-design.md "Spike result"). It is
+// named without the `Test` suffix so the Jest `testMatch` glob
+// (`tests/**/*Test.res.mjs`) skips it — `pnpm run test:host` runs it via node. The
+// pure helpers (name derivation, discovery) are the Jest test in tests/LocalHostTest.res.
+//
+// Prerequisite: reventless-local + the online-shop-aggregates examples must be
+// compiled (`pnpm run build` at the repo root). Run: `pnpm run test:host`.
+
+@module("node:test") external test: (string, unit => promise<unit>) => unit = "test"
+@module("node:assert/strict") external equal: ('a, 'a) => unit = "equal"
+@module("node:assert/strict") external deepEqual: ('a, 'a) => unit = "deepEqual"
+@module("node:assert/strict") external ok: (bool, ~message: string=?) => unit = "ok"
+
+@module("node:url") external fileURLToPath: string => string = "fileURLToPath"
+@module("node:path") external dirname: string => string = "dirname"
+@module("node:path") @variadic external join: array<string> => string = "join"
+
+let here = dirname(fileURLToPath(%raw(`import.meta.url`)))
+let repoRoot = join([here, "..", "..", ".."]) // reventless-gwt/test → repo root
+let catalogDir = join([repoRoot, "examples", "online-shop-aggregates", "catalog"])
+let orderingDir = join([repoRoot, "examples", "online-shop-aggregates", "ordering"])
+let platformPath = join([repoRoot, "reventless", "reventless-local", "src", "Platform.res.mjs"])
+
+let structureFor = (g: LocalHost.graph, name) =>
+  g.structures->Array.find(((n, _)) => n == name)->Option.map(((_, s)) => s)
+
+test("loadGraph cold-loads structures from the real plugins", async () => {
+  let plugins = LocalHost.discover(~packageDirs=[catalogDir, orderingDir])
+  let g = await LocalHost.loadGraph(~platformModulePath=platformPath, ~plugins)
+
+  // structures: resolved plain records, plugin-namespaced event types.
+  deepEqual(g.structures->Array.map(((n, _)) => n), ["Catalog", "Ordering"])
+
+  let catalog = structureFor(g, "Catalog")->Option.getOrThrow
+  let category = catalog.aggregates->Array.find((a: Reventless.Plugin.writableDef) => a.name == "Category")->Option.getOrThrow
+  ok(category.producedEventTypes->Array.includes("Catalog.Added"))
+
+  let ordering = structureFor(g, "Ordering")->Option.getOrThrow
+  let order = ordering.aggregates->Array.find((a: Reventless.Plugin.writableDef) => a.name == "Order")->Option.getOrThrow
+  ok(order.producedEventTypes->Array.includes("Ordering.Placed"))
+
+  // extensionPoints (producer side): Catalog owns Catalog.Products, fed by the
+  // Product aggregate's internal events — so the EP's sourceEventTypes are a
+  // subset of the producer's producedEventTypes, the link the event graph draws.
+  let catalogEps = catalog.extensionPoints->Option.getOr([])
+  let productsEp =
+    catalogEps->Array.find((e: Reventless.Plugin.extensionPointDef) => e.name == "Catalog.Products")->Option.getOrThrow
+  ok(productsEp.delegateNames->Array.includes("Product"), ~message=productsEp.delegateNames->Array.join(","))
+  ok(
+    productsEp.sourceEventTypes->Array.includes("Catalog.Added"),
+    ~message=productsEp.sourceEventTypes->Array.join(","),
+  )
+  let product = catalog.aggregates->Array.find((a: Reventless.Plugin.writableDef) => a.name == "Product")->Option.getOrThrow
+  ok(productsEp.sourceEventTypes->Array.every(e => product.producedEventTypes->Array.includes(e)))
+})
+
+test("loadGraph is cold — a second call in the same process succeeds (cache-busting works)", async () => {
+  let plugins = LocalHost.discover(~packageDirs=[catalogDir])
+  let g1 = await LocalHost.loadGraph(~platformModulePath=platformPath, ~plugins)
+  let g2 = await LocalHost.loadGraph(~platformModulePath=platformPath, ~plugins)
+  equal(g1.structures->Array.length, 1)
+  equal(g2.structures->Array.length, 1)
+})

package/tests/LocalHostIntegration.res.mjs

@@ -0,0 +1,64 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Nodeurl from "node:url";
+import * as Nodepath from "node:path";
+import * as Nodetest from "node:test";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Strict from "node:assert/strict";
+import * as LocalHost$ReventlessGwt from "../src/LocalHost.res.mjs";
+
+let here = Nodepath.dirname(Nodeurl.fileURLToPath(import.meta.url));
+
+let repoRoot = Nodepath.join(here, "..", "..", "..");
+
+let catalogDir = Nodepath.join(repoRoot, "examples", "online-shop-aggregates", "catalog");
+
+let orderingDir = Nodepath.join(repoRoot, "examples", "online-shop-aggregates", "ordering");
+
+let platformPath = Nodepath.join(repoRoot, "reventless", "reventless-local", "src", "Platform.res.mjs");
+
+function structureFor(g, name) {
+  return Stdlib_Option.map(g.structures.find(param => param[0] === name), param => param[1]);
+}
+
+Nodetest.test("loadGraph cold-loads structures from the real plugins", async () => {
+  let plugins = LocalHost$ReventlessGwt.discover([
+    catalogDir,
+    orderingDir
+  ]);
+  let g = await LocalHost$ReventlessGwt.loadGraph(platformPath, plugins);
+  Strict.deepEqual(g.structures.map(param => param[0]), [
+    "Catalog",
+    "Ordering"
+  ]);
+  let catalog = Stdlib_Option.getOrThrow(structureFor(g, "Catalog"), undefined);
+  let category = Stdlib_Option.getOrThrow(catalog.aggregates.find(a => a.name === "Category"), undefined);
+  Strict.ok(category.producedEventTypes.includes("Catalog.Added"));
+  let ordering = Stdlib_Option.getOrThrow(structureFor(g, "Ordering"), undefined);
+  let order = Stdlib_Option.getOrThrow(ordering.aggregates.find(a => a.name === "Order"), undefined);
+  Strict.ok(order.producedEventTypes.includes("Ordering.Placed"));
+  let catalogEps = Stdlib_Option.getOr(catalog.extensionPoints, []);
+  let productsEp = Stdlib_Option.getOrThrow(catalogEps.find(e => e.name === "Catalog.Products"), undefined);
+  Strict.ok(productsEp.delegateNames.includes("Product"), productsEp.delegateNames.join(","));
+  Strict.ok(productsEp.sourceEventTypes.includes("Catalog.Added"), productsEp.sourceEventTypes.join(","));
+  let product = Stdlib_Option.getOrThrow(catalog.aggregates.find(a => a.name === "Product"), undefined);
+  Strict.ok(productsEp.sourceEventTypes.every(e => product.producedEventTypes.includes(e)));
+});
+
+Nodetest.test("loadGraph is cold — a second call in the same process succeeds (cache-busting works)", async () => {
+  let plugins = LocalHost$ReventlessGwt.discover([catalogDir]);
+  let g1 = await LocalHost$ReventlessGwt.loadGraph(platformPath, plugins);
+  let g2 = await LocalHost$ReventlessGwt.loadGraph(platformPath, plugins);
+  Strict.equal(g1.structures.length, 1);
+  Strict.equal(g2.structures.length, 1);
+});
+
+export {
+  here,
+  repoRoot,
+  catalogDir,
+  orderingDir,
+  platformPath,
+  structureFor,
+}
+/* here Not a pure module */

package/tests/LocalHostTest.res

@@ -0,0 +1,71 @@
+// Unit tests for LocalHost's pure helpers — plugin-name derivation + discovery.
+// These touch only the filesystem (no reventless-local import), so they run under
+// the normal Jest suite. The cold-load integration (`loadGraph`, which instantiates
+// reventless-local's Platform) can't run under Jest's experimental-vm-modules — see
+// tests/SplitApiFixtures.res — and lives in test/LocalHostHostTest.res
+// (`pnpm run test:host`, run via `node --test`).
+//
+// Fixtures are a throwaway temp tree (same pattern as DiscoveryTest) so the test is
+// hermetic and doesn't depend on the example plugins being compiled.
+
+open JestGlobals
+
+@module("node:os") external tmpdir: unit => string = "tmpdir"
+@module("node:path") external join: (string, string) => string = "join"
+
+type mkdirOpts = {recursive: bool}
+@module("node:fs/promises")
+external mkdir: (string, mkdirOpts) => promise<Nullable.t<string>> = "mkdir"
+@module("node:fs/promises") external writeFile: (string, string) => promise<unit> = "writeFile"
+type rmOpts = {recursive: bool, force: bool}
+@module("node:fs/promises") external rm: (string, rmOpts) => promise<unit> = "rm"
+
+describe("LocalHost.packageNameToPluginName", () => {
+  testPromise("PascalCases scoped / dashed / underscored package names", async () => {
+    expect(LocalHost.packageNameToPluginName("@scope/my-catalog"))->toBe("MyCatalog")
+    expect(LocalHost.packageNameToPluginName("online-shop"))->toBe("OnlineShop")
+    expect(
+      LocalHost.packageNameToPluginName("online-shop-aggregates-catalog"),
+    )->toBe("OnlineShopAggregatesCatalog")
+  })
+})
+
+describe("LocalHost name derivation + discovery", () => {
+  testPromise(
+    "derivePluginName prefers plugin.json then PascalCase(package.json); discover skips non-plugins",
+    async () => {
+      let root = join(tmpdir(), "reventless-localhost-test")
+      let _ = await rm(root, {recursive: true, force: true})
+
+      // a: explicit plugin.json name + a compiled composition root.
+      let a = join(root, "a")
+      let aSrc = join(a, "src")
+      let _ = await mkdir(aSrc, {recursive: true})
+      let _ = await writeFile(join(a, "package.json"), `{"name":"@x/a-pkg"}`)
+      let _ = await writeFile(join(aSrc, "plugin.json"), `{"name":"Catalog"}`)
+      let _ = await writeFile(join(aSrc, "Plugin.res.mjs"), "")
+
+      // b: no plugin.json → name falls back to PascalCase(package.json name).
+      let b = join(root, "b")
+      let bSrc = join(b, "src")
+      let _ = await mkdir(bSrc, {recursive: true})
+      let _ = await writeFile(join(b, "package.json"), `{"name":"@scope/my-ordering"}`)
+      let _ = await writeFile(join(bSrc, "Plugin.res.mjs"), "")
+
+      // c: has src/ but no Plugin.res.mjs → discover must skip it.
+      let c = join(root, "c")
+      let _ = await mkdir(join(c, "src"), {recursive: true})
+
+      expect(LocalHost.derivePluginName(~pluginSrcDir=aSrc))->toBe("Catalog")
+      expect(LocalHost.derivePluginName(~pluginSrcDir=bSrc))->toBe("MyOrdering")
+
+      let refs = LocalHost.discover(~packageDirs=[a, b, c])
+      expect(refs->Array.map((r: LocalHost.pluginRef) => r.name))->toEqual(["Catalog", "MyOrdering"])
+      let first: LocalHost.pluginRef = refs->Array.getUnsafe(0)
+      expect(first.modulePath->String.endsWith("Plugin.res.mjs"))->toBe(true)
+      expect(first.packageDir)->toBe(a)
+
+      let _ = await rm(root, {recursive: true, force: true})
+    },
+  )
+})

package/tests/LocalHostTest.res.mjs

@@ -0,0 +1,63 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Nodeos from "node:os";
+import * as Nodepath from "node:path";
+import * as Promises from "node:fs/promises";
+import * as LocalHost$ReventlessGwt from "../src/LocalHost.res.mjs";
+
+globalThis.describe("LocalHost.packageNameToPluginName", () => {
+  globalThis.test("PascalCases scoped / dashed / underscored package names", async () => {
+    globalThis.expect(LocalHost$ReventlessGwt.packageNameToPluginName("@scope/my-catalog")).toBe("MyCatalog");
+    globalThis.expect(LocalHost$ReventlessGwt.packageNameToPluginName("online-shop")).toBe("OnlineShop");
+    globalThis.expect(LocalHost$ReventlessGwt.packageNameToPluginName("online-shop-aggregates-catalog")).toBe("OnlineShopAggregatesCatalog");
+  });
+});
+
+globalThis.describe("LocalHost name derivation + discovery", () => {
+  globalThis.test("derivePluginName prefers plugin.json then PascalCase(package.json); discover skips non-plugins", async () => {
+    let root = Nodepath.join(Nodeos.tmpdir(), "reventless-localhost-test");
+    await Promises.rm(root, {
+      recursive: true,
+      force: true
+    });
+    let a = Nodepath.join(root, "a");
+    let aSrc = Nodepath.join(a, "src");
+    await Promises.mkdir(aSrc, {
+      recursive: true
+    });
+    await Promises.writeFile(Nodepath.join(a, "package.json"), `{"name":"@x/a-pkg"}`);
+    await Promises.writeFile(Nodepath.join(aSrc, "plugin.json"), `{"name":"Catalog"}`);
+    await Promises.writeFile(Nodepath.join(aSrc, "Plugin.res.mjs"), "");
+    let b = Nodepath.join(root, "b");
+    let bSrc = Nodepath.join(b, "src");
+    await Promises.mkdir(bSrc, {
+      recursive: true
+    });
+    await Promises.writeFile(Nodepath.join(b, "package.json"), `{"name":"@scope/my-ordering"}`);
+    await Promises.writeFile(Nodepath.join(bSrc, "Plugin.res.mjs"), "");
+    let c = Nodepath.join(root, "c");
+    await Promises.mkdir(Nodepath.join(c, "src"), {
+      recursive: true
+    });
+    globalThis.expect(LocalHost$ReventlessGwt.derivePluginName(aSrc)).toBe("Catalog");
+    globalThis.expect(LocalHost$ReventlessGwt.derivePluginName(bSrc)).toBe("MyOrdering");
+    let refs = LocalHost$ReventlessGwt.discover([
+      a,
+      b,
+      c
+    ]);
+    globalThis.expect(refs.map(r => r.name)).toEqual([
+      "Catalog",
+      "MyOrdering"
+    ]);
+    let first = refs[0];
+    globalThis.expect(first.modulePath.endsWith("Plugin.res.mjs")).toBe(true);
+    globalThis.expect(first.packageDir).toBe(a);
+    await Promises.rm(root, {
+      recursive: true,
+      force: true
+    });
+  });
+});
+
+/*  Not a pure module */