@reventlessdev/reventless-gwt 1.0.0-alpha.142 → 1.0.0-alpha.144

package/CHANGELOG.md

@@ -3,6 +3,21 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+# 1.0.0-alpha.144 (2026-08-01)
+
+### Bug Fixes
+
+* **gwt:** compare produced events by their encoded wire form ([f773062](https://github.com/ReventlessDev/reventless-core/commit/f773062bc8ea18bf12e5611fcbad81aa4f1bd1b2))
+
+
+# 1.0.0-alpha.143 (2026-07-31)
+
+**Note:** Version bump only for package @reventlessdev/reventless-gwt
+
+
+
+
+
 # 1.0.0-alpha.142 (2026-07-30)
 
 **Note:** Version bump only for package @reventlessdev/reventless-gwt

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reventlessdev/reventless-gwt",
-  "version": "1.0.0-alpha.142",
+  "version": "1.0.0-alpha.144",
   "description": "Given-When-Then DSLs and test harness for Reventless slice testing",
   "license": "Apache-2.0",
   "jest": {
@@ -14,11 +14,12 @@
   },
   "dependencies": {
     "sury": "11.0.0-alpha.4",
-    "@reventlessdev/reventless-core": "3.0.0-alpha.195",
-    "@reventlessdev/rescript-effect": "0.1.0-alpha.31",
-    "@reventlessdev/rescript-jest": "1.0.0-alpha.9",
-    "@reventlessdev/reventless-infra": "3.0.0-alpha.113",
-    "@reventlessdev/reventless-spec": "3.0.0-alpha.88"
+    "@reventlessdev/rescript-node": "2.0.0-alpha.0",
+    "@reventlessdev/reventless-core": "3.0.0-alpha.197",
+    "@reventlessdev/reventless-infra": "3.0.0-alpha.115",
+    "@reventlessdev/rescript-effect": "0.1.0-alpha.32",
+    "@reventlessdev/rescript-jest": "1.0.0-alpha.10",
+    "@reventlessdev/reventless-spec": "3.0.0-alpha.90"
   },
   "devDependencies": {
     "rescript": "12.3.0",

package/rescript.json

@@ -24,6 +24,7 @@
   ],
   "dependencies": [
     "sury",
+    "@reventlessdev/rescript-node",
     "@reventlessdev/rescript-jest",
     "@reventlessdev/rescript-effect",
     "@reventlessdev/reventless-infra",

package/src/Behavior_GWT.res

@@ -153,10 +153,22 @@ module AssertionCore = (Spec: CoreSpec) => {
     )
   }
 
+  // Events are compared by their **encoded (wire) form**, not by ReScript
+  // structural equality. For an event-sourced system the serialized event *is*
+  // its identity: two events that reverse-convert to the same JSON are the same
+  // event. Raw `==` is stricter than that — it distinguishes an optional field
+  // that is present-but-`undefined` (what a decider's `deliveryWindow: ?x`
+  // passthrough emits when `x` is `None`) from one whose key is absent (what a
+  // test literal that omits the field produces), even though sury drops a `None`
+  // optional either way and both hit the log identically. Comparing on `encEvents`
+  // unifies that spurious difference, so an optional event field can be omitted in
+  // the expectation instead of spelled out as `?None`. It is a strictly weaker
+  // equality: equal values still encode equally, so nothing that passed can start
+  // failing — it only stops the wire-invisible key asymmetry from failing a test.
   let compareEvents = (events, expectedEvents) =>
     if errors.contents->Array.length > 0 {
       unexpectedError(events)
-    } else if events == expectedEvents {
+    } else if events->encEvents == expectedEvents->encEvents {
       Outcome.pass
     } else {
       Outcome.fail(
@@ -211,7 +223,8 @@ module AssertionCore = (Spec: CoreSpec) => {
         }),
       )
     | Some(_) =>
-      if events == expectedEvents {
+      // Encoded comparison, for the same reason as `compareEvents` above.
+      if events->encEvents == expectedEvents->encEvents {
         Outcome.pass
       } else {
         Outcome.fail(

package/src/Behavior_GWT.res.mjs

@@ -66,7 +66,7 @@ function AssertionCore(Spec) {
   let compareEvents = (events, expectedEvents) => {
     if (errors.contents.length !== 0) {
       return unexpectedError(events);
-    } else if (Primitive_object.equal(events, expectedEvents)) {
+    } else if (Primitive_object.equal(events.map(encEvent), expectedEvents.map(encEvent))) {
       return Outcome$ReventlessGwt.pass;
     } else {
       return Outcome$ReventlessGwt.fail({
@@ -120,7 +120,7 @@ function AssertionCore(Spec) {
         actual: Message$ReventlessCore.encode(actual$1, Spec.errorSchema),
         actualEvents: events.map(encEvent)
       });
-    } else if (Primitive_object.equal(events, expectedEvents)) {
+    } else if (Primitive_object.equal(events.map(encEvent), expectedEvents.map(encEvent))) {
       return Outcome$ReventlessGwt.pass;
     } else {
       return Outcome$ReventlessGwt.fail({
@@ -180,7 +180,7 @@ function Make(Spec) {
           actual: Message$ReventlessCore.encode(actual$1, Spec.errorSchema),
           actualEvents: events.map(encEvent)
         });
-      } else if (Primitive_object.equal(events, expectedEvents)) {
+      } else if (Primitive_object.equal(events.map(encEvent), expectedEvents.map(encEvent))) {
         return Outcome$ReventlessGwt.pass;
       } else {
         return Outcome$ReventlessGwt.fail({
@@ -281,7 +281,7 @@ function Make(Spec) {
         return o;
       } else if (errors.contents.length !== 0) {
         return unexpectedError(events);
-      } else if (Primitive_object.equal(events, expectedEvents)) {
+      } else if (Primitive_object.equal(events.map(encEvent), expectedEvents.map(encEvent))) {
         return Outcome$ReventlessGwt.pass;
       } else {
         return Outcome$ReventlessGwt.fail({
@@ -413,7 +413,7 @@ function MakeFromAggregate(Spec) {
     let compareEvents = (events, expectedEvents) => {
       if (errors.contents.length !== 0) {
         return unexpectedError(events);
-      } else if (Primitive_object.equal(events, expectedEvents)) {
+      } else if (Primitive_object.equal(events.map(encEvent), expectedEvents.map(encEvent))) {
         return Outcome$ReventlessGwt.pass;
       } else {
         return Outcome$ReventlessGwt.fail({
@@ -467,7 +467,7 @@ function MakeFromAggregate(Spec) {
           actual: Message$ReventlessCore.encode(actual$1, Spec.errorSchema),
           actualEvents: events.map(encEvent)
         });
-      } else if (Primitive_object.equal(events, expectedEvents)) {
+      } else if (Primitive_object.equal(events.map(encEvent), expectedEvents.map(encEvent))) {
         return Outcome$ReventlessGwt.pass;
       } else {
         return Outcome$ReventlessGwt.fail({

package/src/LocalHost.res

@@ -13,16 +13,6 @@
 // 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
@@ -35,7 +25,7 @@ let dynamicImport: string => promise<'a> = %raw(`(u) => import(u)`)
 let counter = ref(0)
 let bustedUrl = (absolutePath: string): string => {
   counter := counter.contents + 1
-  pathToFileURL(absolutePath)["href"] ++ "?t=" ++ Int.toString(counter.contents)
+  NodeUrl.pathToFileURL(absolutePath)["href"] ++ "?t=" ++ Int.toString(counter.contents)
 }
 
 type pluginRef = {name: string, modulePath: string, packageDir: string}
@@ -65,7 +55,7 @@ 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 {
+  try Some(NodeFs.readFileSync(path)->JSON.parseOrThrow) catch {
   | _ => None
   }
 
@@ -73,11 +63,14 @@ let readJson = path =>
 // 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 pluginJson = NodePath.join([pluginSrcDir, "plugin.json"])
   let pluginJsonName =
-    existsSync(pluginJson) ? readJson(pluginJson)->Option.flatMap(j => strField(j, "name")) : None
+    NodeFs.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"))
+    readJson(NodePath.join([NodePath.dirname(pluginSrcDir), "package.json"]))
+    ->Option.flatMap(j => strField(j, "name"))
   Reventless.PluginName.resolve(~pluginJsonName, ~packageJsonName)
 }
 
@@ -85,9 +78,9 @@ let derivePluginName = (~pluginSrcDir: string): string => {
 // 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)
+    let srcDir = NodePath.join([dir, "src"])
+    let modulePath = NodePath.join([srcDir, "Plugin.res.mjs"])
+    NodeFs.existsSync(modulePath)
       ? Some({name: derivePluginName(~pluginSrcDir=srcDir), modulePath, packageDir: dir})
       : None
   })
@@ -99,7 +92,10 @@ let discover = (~packageDirs: array<string>): array<pluginRef> =>
 // 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 {
+  try Some(
+    NodeModule.createRequire(NodePath.join([fromPackageDir, "package.json"]))
+    ->NodeModule.requireResolve(localPlatformSpecifier),
+  ) catch {
   | _ => None
   }
 

package/tests/LocalHostIntegration.res

@@ -18,15 +18,11 @@
 @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 here = NodePath.dirname(NodeUrl.fileURLToPath(%raw(`import.meta.url`)))
+let repoRoot = NodePath.join([here, "..", "..", ".."]) // reventless-gwt/test → repo root
+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", "local", "src", "Platform.res.mjs"])
 
 let structureFor = (g: LocalHost.graph, name) =>
   g.structures->Array.find(((n, _)) => n == name)->Option.map(((_, s)) => s)

package/tests/LocalHostIntegration.res.mjs

@@ -15,7 +15,7 @@ let catalogDir = Nodepath.join(repoRoot, "examples", "online-shop-aggregates", "
 
 let orderingDir = Nodepath.join(repoRoot, "examples", "online-shop-aggregates", "ordering");
 
-let platformPath = Nodepath.join(repoRoot, "reventless", "reventless-local", "src", "Platform.res.mjs");
+let platformPath = Nodepath.join(repoRoot, "reventless", "local", "src", "Platform.res.mjs");
 
 function structureFor(g, name) {
   return Stdlib_Option.map(g.structures.find(param => param[0] === name), param => param[1]);

package/tests/LocalHostTest.res

@@ -10,16 +10,6 @@
 
 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")
@@ -34,27 +24,32 @@ 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})
+      let root = NodePath.join([NodeOs.tmpdir(), "reventless-localhost-test"])
+      let _ = await NodeFs.Promises.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"), "")
+      let a = NodePath.join([root, "a"])
+      let aSrc = NodePath.join([a, "src"])
+      let _ = await NodeFs.Promises.mkdir(aSrc, {recursive: true})
+      let _ =
+        await NodeFs.Promises.writeFile(NodePath.join([a, "package.json"]), `{"name":"@x/a-pkg"}`)
+      let _ =
+        await NodeFs.Promises.writeFile(NodePath.join([aSrc, "plugin.json"]), `{"name":"Catalog"}`)
+      let _ = await NodeFs.Promises.writeFile(NodePath.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"), "")
+      let b = NodePath.join([root, "b"])
+      let bSrc = NodePath.join([b, "src"])
+      let _ = await NodeFs.Promises.mkdir(bSrc, {recursive: true})
+      let _ = await NodeFs.Promises.writeFile(
+        NodePath.join([b, "package.json"]),
+        `{"name":"@scope/my-ordering"}`,
+      )
+      let _ = await NodeFs.Promises.writeFile(NodePath.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})
+      let c = NodePath.join([root, "c"])
+      let _ = await NodeFs.Promises.mkdir(NodePath.join([c, "src"]), {recursive: true})
 
       expect(LocalHost.derivePluginName(~pluginSrcDir=aSrc))->toBe("Catalog")
       expect(LocalHost.derivePluginName(~pluginSrcDir=bSrc))->toBe("MyOrdering")
@@ -65,7 +60,7 @@ describe("LocalHost name derivation + discovery", () => {
       expect(first.modulePath->String.endsWith("Plugin.res.mjs"))->toBe(true)
       expect(first.packageDir)->toBe(a)
 
-      let _ = await rm(root, {recursive: true, force: true})
+      let _ = await NodeFs.Promises.rm(root, {recursive: true, force: true})
     },
   )
 })