@reventlessdev/reventless-gwt 1.0.0-alpha.238 → 1.0.0-alpha.239

package/CHANGELOG.md

@@ -3,6 +3,16 @@
 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.239 (2026-10-10)
+
+### Bug Fixes
+
+* an inbound translation is gated alike on every door, and encodes its commands by schema ([6ec3ce6](https://github.com/ReventlessDev/reventless-core/commit/6ec3ce672e53e2c162c64a90d103be691391be5e))
+### Features
+
+* **gwt:** automation and translation tests take the slice as written, and the sidecars read them ([93a0919](https://github.com/ReventlessDev/reventless-core/commit/93a0919a0d66730cf9bf89144ad8fba3cb025332))
+
+
 # 1.0.0-alpha.238 (2026-10-08)
 
 **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.238",
+  "version": "1.0.0-alpha.239",
   "description": "Given-When-Then DSLs and test harness for Reventless slice testing",
   "license": "Apache-2.0",
   "jest": {
@@ -15,11 +15,11 @@
   "dependencies": {
     "sury": "11.0.0",
     "@reventlessdev/rescript-effect": "0.1.0-alpha.34",
+    "@reventlessdev/reventless-core": "3.0.0-alpha.292",
     "@reventlessdev/rescript-jest": "1.0.0-alpha.11",
-    "@reventlessdev/reventless-infra": "3.0.0-alpha.188",
-    "@reventlessdev/reventless-core": "3.0.0-alpha.291",
     "@reventlessdev/rescript-node": "2.0.0-alpha.22",
-    "@reventlessdev/reventless-spec": "3.0.0-alpha.160"
+    "@reventlessdev/reventless-infra": "3.0.0-alpha.189",
+    "@reventlessdev/reventless-spec": "3.0.0-alpha.161"
   },
   "devDependencies": {
     "rescript": "12.3.1",

package/src/Automation_GWT.res

@@ -56,6 +56,9 @@ module type T = {
   let thenScenarioTodos: (scenario, array<(string, Spec.todoItem)>) => Outcome.outcome
 }
 
+/** Deprecated: takes an adapter module that flattens one mapping. Use
+    `FromSlice`, which takes the slice as written; this goes one release after
+    the examples have moved. */
 module Make = (Spec: SliceSpec): (T with module Spec = Spec) => {
   module Spec = Spec
 
@@ -194,3 +197,130 @@ module Make = (Spec: SliceSpec): (T with module Spec = Spec) => {
 
   let thenScenarioTodos = (scenario, expected) => thenTodos(scenario.todos, expected)
 }
+
+// The slice as written: its `Spec` and its `_Automation` body, with every
+// mapping, `process` and `onExhausted`. Per-source verbs come from
+// `Mapping(M)`, because a mapping's event type is hidden inside `mappings`.
+module FromSlice = (
+  Spec: Reventless.AutomationSlice.Spec,
+  Automation: Reventless.AutomationSlice.Automation with module Spec := Spec,
+) => {
+  module Route = AutomationSlice_Route.Make(Spec, Automation)
+
+  let describe = JestBind.describe
+  let test = (name, body) => JestBind.test(~slice=Spec.name, name, body)
+
+  let testContext: Reventless.AutomationSlice.context = {
+    environment: "test",
+    platformName: "test",
+    pluginName: "test",
+    sliceName: Spec.name,
+  }
+
+  /** A source event as the runtime receives it: encoded, and addressed by its
+      source's name. Built with `Mapping(M).event`. */
+  type sourced = {sourceName: string, sourceId: string, payload: JSON.t}
+
+  type scenario = {
+    todos: array<(string, Spec.todoItem)>,
+    commands: array<(string, Spec.command)>,
+  }
+
+  let encTodos = (arr: array<(string, Spec.todoItem)>) =>
+    arr->Array.map(((id, t)) => (id, t->Message.encode(Spec.todoItemSchema)))
+  let encPair = ((id, cmd): (string, Spec.command)) => {
+    let d = Dict.make()
+    d->Dict.set("id", JSON.Encode.string(id))
+    d->Dict.set("command", cmd->Message.encode(Spec.commandSchema))
+    JSON.Encode.object(d)
+  }
+
+  let thenTodos = (actual, expected) =>
+    actual == expected
+      ? Outcome.pass
+      : Outcome.fail(TodoMismatch({expected: encTodos(expected), actual: encTodos(actual)}))
+
+  let thenResolved = (actual: option<string>, expected: option<string>) => {
+    let asPair = opt => opt->Option.mapOr([], id => [(id, JSON.Encode.null)])
+    actual == expected
+      ? Outcome.pass
+      : Outcome.fail(TodoMismatch({expected: asPair(expected), actual: asPair(actual)}))
+  }
+
+  module Mapping = (M: Automation.Mapping) => {
+    let event = (e: M.sourceEvent, ~sourceId="") => {
+      sourceName: M.sourceName,
+      sourceId,
+      payload: e->Message.encode(M.sourceEventSchema),
+    }
+    let givenEvent = (e: M.sourceEvent) => e
+    let whenCollect = (e, ~sourceId="", ~context=testContext) => M.collect(e, ~sourceId, context)
+    let whenResolve = M.resolve
+  }
+
+  // Unit: process and abandonment
+  let givenTodo = (id: string, item: Spec.todoItem) => (id, item)
+  let whenProcess = ((id, item)) => Automation.process(id, item)
+  let whenExhausted = ((id, item)) => Automation.onExhausted(id, item)
+  let thenCommand = (actual, expectedId, expectedCmd) =>
+    switch actual {
+    | Some((id, cmd)) if id == expectedId && cmd == expectedCmd => Outcome.pass
+    | actual =>
+      Outcome.fail(
+        EventsMismatch({
+          expected: [encPair((expectedId, expectedCmd))],
+          actual: actual->Option.mapOr([], p => [encPair(p)]),
+        }),
+      )
+    }
+  let thenNoCommand = actual =>
+    switch actual {
+    | None => Outcome.pass
+    | Some(p) => Outcome.fail(NoEventExpected({actual: [encPair(p)]}))
+    }
+
+  // Scenario: a sweep routes each event in turn, as phase 1 does, so to-dos keep
+  // the order the events produced them.
+  let givenEvents = (es: array<sourced>) => es
+  let routeAll = (events: array<sourced>, context) =>
+    events->Array.flatMap(e =>
+      Route.route(e.payload, ~sourceName=e.sourceName, ~sourceId=e.sourceId, context)
+    )
+  /** Applies routed events as the runtime's to-do list does: the first writer of
+      an id wins, and a resolve completes only a row that already exists. */
+  let sweep = (routed: array<AutomationSlice_Route.routed<Spec.todoItem>>) => {
+    let rows: array<(string, Spec.todoItem, ref<bool>)> = []
+    routed->Array.forEach(r => {
+      r.collected->Array.forEach(((id, item)) =>
+        if !(rows->Array.some(((seen, _, _)) => seen == id)) {
+          rows->Array.push((id, item, ref(false)))
+        }
+      )
+      r.resolved->Option.forEach(id =>
+        rows->Array.forEach(
+          ((seen, _, done)) =>
+            if seen == id {
+              done := true
+            },
+        )
+      )
+    })
+    let todos = rows->Array.filterMap(((id, item, done)) => done.contents ? None : Some((id, item)))
+    {todos, commands: todos->Array.filterMap(((id, item)) => Automation.process(id, item))}
+  }
+  let whenSweep = (events, ~context=testContext) => sweep(routeAll(events, context))
+  let thenCommands = (scenario, expected) =>
+    scenario.commands == expected
+      ? Outcome.pass
+      : Outcome.fail(
+          EventsMismatch({
+            expected: expected->Array.map(encPair),
+            actual: scenario.commands->Array.map(encPair),
+          }),
+        )
+  let andThenEvents = (scenario, events, ~context=testContext) => {
+    let resolved = routeAll(events, context)->Array.filterMap(r => r.resolved)
+    {...scenario, todos: scenario.todos->Array.filter(((id, _)) => !(resolved->Array.includes(id)))}
+  }
+  let thenScenarioTodos = (scenario, expected) => thenTodos(scenario.todos, expected)
+}

package/src/Automation_GWT.res.mjs

@@ -1,11 +1,13 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
 import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
 import * as Primitive_object from "@rescript/runtime/lib/es6/Primitive_object.js";
 import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.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";
+import * as AutomationSlice_Route$ReventlessCore from "@reventlessdev/reventless-core/src/components/AutomationSlice/AutomationSlice_Route.res.mjs";
 
 function Make(Spec) {
   let test = (name, body) => JestBind$ReventlessGwt.test(Spec.name, name, body);
@@ -152,7 +154,198 @@ function Make(Spec) {
   };
 }
 
+function FromSlice(Spec) {
+  return Automation => {
+    let Route = AutomationSlice_Route$ReventlessCore.Make(Spec)(Automation);
+    let test = (name, body) => JestBind$ReventlessGwt.test(Spec.name, name, body);
+    let testContext_sliceName = Spec.name;
+    let testContext = {
+      environment: "test",
+      platformName: "test",
+      pluginName: "test",
+      sliceName: testContext_sliceName
+    };
+    let encTodos = arr => arr.map(param => [
+      param[0],
+      Message$ReventlessCore.encode(param[1], Spec.todoItemSchema)
+    ]);
+    let encPair = param => {
+      let d = {};
+      d["id"] = param[0];
+      d["command"] = Message$ReventlessCore.encode(param[1], Spec.commandSchema);
+      return d;
+    };
+    let thenTodos = (actual, expected) => {
+      if (Primitive_object.equal(actual, expected)) {
+        return Outcome$ReventlessGwt.pass;
+      } else {
+        return Outcome$ReventlessGwt.fail({
+          TAG: "TodoMismatch",
+          expected: encTodos(expected),
+          actual: encTodos(actual)
+        });
+      }
+    };
+    let thenResolved = (actual, expected) => {
+      let asPair = opt => Stdlib_Option.mapOr(opt, [], id => [[
+          id,
+          null
+        ]]);
+      if (Primitive_object.equal(actual, expected)) {
+        return Outcome$ReventlessGwt.pass;
+      } else {
+        return Outcome$ReventlessGwt.fail({
+          TAG: "TodoMismatch",
+          expected: asPair(expected),
+          actual: asPair(actual)
+        });
+      }
+    };
+    let Mapping = M => {
+      let event = (e, sourceIdOpt) => {
+        let sourceId = sourceIdOpt !== undefined ? sourceIdOpt : "";
+        return {
+          sourceName: M.sourceName,
+          sourceId: sourceId,
+          payload: Message$ReventlessCore.encode(e, M.sourceEventSchema)
+        };
+      };
+      let givenEvent = e => e;
+      let whenCollect = (e, sourceIdOpt, contextOpt) => {
+        let sourceId = sourceIdOpt !== undefined ? sourceIdOpt : "";
+        let context = contextOpt !== undefined ? contextOpt : testContext;
+        return M.collect(e, sourceId, context);
+      };
+      return {
+        event: event,
+        givenEvent: givenEvent,
+        whenCollect: whenCollect,
+        whenResolve: M.resolve
+      };
+    };
+    let givenTodo = (id, item) => [
+      id,
+      item
+    ];
+    let whenProcess = param => Automation.process(param[0], param[1]);
+    let whenExhausted = param => Automation.onExhausted(param[0], param[1]);
+    let thenCommand = (actual, expectedId, expectedCmd) => {
+      if (actual !== undefined && actual[0] === expectedId && Primitive_object.equal(actual[1], expectedCmd)) {
+        return Outcome$ReventlessGwt.pass;
+      }
+      return Outcome$ReventlessGwt.fail({
+        TAG: "EventsMismatch",
+        expected: [encPair([
+            expectedId,
+            expectedCmd
+          ])],
+        actual: Stdlib_Option.mapOr(actual, [], p => [encPair(p)])
+      });
+    };
+    let thenNoCommand = actual => {
+      if (actual !== undefined) {
+        return Outcome$ReventlessGwt.fail({
+          TAG: "NoEventExpected",
+          actual: [encPair(actual)]
+        });
+      } else {
+        return Outcome$ReventlessGwt.pass;
+      }
+    };
+    let givenEvents = es => es;
+    let routeAll = (events, context) => events.flatMap(e => Route.route(e.payload, e.sourceName, e.sourceId, context));
+    let sweep = routed => {
+      let rows = [];
+      routed.forEach(r => {
+        r.collected.forEach(param => {
+          let id = param[0];
+          if (!rows.some(param => param[0] === id)) {
+            rows.push([
+              id,
+              param[1],
+              {
+                contents: false
+              }
+            ]);
+            return;
+          }
+        });
+        Stdlib_Option.forEach(r.resolved, id => {
+          rows.forEach(param => {
+            if (param[0] === id) {
+              param[2].contents = true;
+              return;
+            }
+          });
+        });
+      });
+      let todos = Stdlib_Array.filterMap(rows, param => {
+        if (param[2].contents) {
+          return;
+        } else {
+          return [
+            param[0],
+            param[1]
+          ];
+        }
+      });
+      return {
+        todos: todos,
+        commands: Stdlib_Array.filterMap(todos, param => Automation.process(param[0], param[1]))
+      };
+    };
+    let whenSweep = (events, contextOpt) => {
+      let context = contextOpt !== undefined ? contextOpt : testContext;
+      return sweep(routeAll(events, context));
+    };
+    let thenCommands = (scenario, expected) => {
+      if (Primitive_object.equal(scenario.commands, expected)) {
+        return Outcome$ReventlessGwt.pass;
+      } else {
+        return Outcome$ReventlessGwt.fail({
+          TAG: "EventsMismatch",
+          expected: expected.map(encPair),
+          actual: scenario.commands.map(encPair)
+        });
+      }
+    };
+    let andThenEvents = (scenario, events, contextOpt) => {
+      let context = contextOpt !== undefined ? contextOpt : testContext;
+      let resolved = Stdlib_Array.filterMap(routeAll(events, context), r => r.resolved);
+      return {
+        todos: scenario.todos.filter(param => !resolved.includes(param[0])),
+        commands: scenario.commands
+      };
+    };
+    let thenScenarioTodos = (scenario, expected) => thenTodos(scenario.todos, expected);
+    return {
+      Route: Route,
+      describe: JestBind$ReventlessGwt.describe,
+      test: test,
+      testContext: testContext,
+      encTodos: encTodos,
+      encPair: encPair,
+      thenTodos: thenTodos,
+      thenResolved: thenResolved,
+      Mapping: Mapping,
+      givenTodo: givenTodo,
+      whenProcess: whenProcess,
+      whenExhausted: whenExhausted,
+      thenCommand: thenCommand,
+      thenNoCommand: thenNoCommand,
+      givenEvents: givenEvents,
+      routeAll: routeAll,
+      sweep: sweep,
+      whenSweep: whenSweep,
+      thenCommands: thenCommands,
+      andThenEvents: andThenEvents,
+      thenScenarioTodos: thenScenarioTodos
+    };
+  };
+}
+
 export {
   Make,
+  FromSlice,
 }
 /* Message-ReventlessCore Not a pure module */

package/src/Capabilities_Fake.res

@@ -0,0 +1,157 @@
+// Recording fakes for `Reventless.Capabilities.t`: every call a `translate` makes
+// is kept, in order, and each answer can be scripted. What an outbound test
+// asserts with `thenSent`.
+
+module Capabilities = Reventless.Capabilities
+module Geocoding = Reventless.Geocoding
+module Messaging = Reventless.Messaging
+module IdentityProvider = Reventless.IdentityProvider
+module Secrets = Reventless.Secrets
+
+/** One call a slice made through its capabilities. */
+type call =
+  | Geocoded({text: string})
+  | Sent({recipient: Messaging.recipient, message: Messaging.message})
+  | PrincipalCreated({
+      contact: Messaging.recipient,
+      credential: IdentityProvider.credential,
+      groups: array<string>,
+    })
+  | AddedToGroup({principal: IdentityProvider.principal, group: string})
+  | RemovedFromGroup({principal: IdentityProvider.principal, group: string})
+  | PrincipalDeleted({principal: IdentityProvider.principal})
+  | TokenDrawn({length: int, alphabet: Secrets.alphabet})
+  | Hashed({input: string})
+
+type t = {
+  capabilities: Capabilities.t,
+  /** The calls made so far, oldest first. */
+  calls: unit => array<call>,
+}
+
+/**
+Fakes whose answers are given per capability. An answer left out is a plain
+success: a geocoder with no candidates, a send with a numbered receipt, a
+principal with a numbered id, `token` (or `t` repeated to length), and a hash
+that prefixes `"hash:"`. `~secrets` replaces the secret source whole, e.g. with
+`Secrets.unavailable`; its calls are still recorded.
+*/
+let make = (
+  ~geocode: option<Geocoding.search>=?,
+  ~send: option<Messaging.send>=?,
+  ~channels: array<Messaging.channel>=[Email, Sms],
+  ~pushServices: array<Messaging.pushService>=[],
+  ~createPrincipal: option<
+    (
+      ~contact: Messaging.recipient,
+      ~credential: IdentityProvider.credential,
+      ~groups: array<string>,
+    ) => promise<result<IdentityProvider.principal, IdentityProvider.failure>>,
+  >=?,
+  ~token: option<string>=?,
+  ~hash: option<string => string>=?,
+  ~secrets: option<Secrets.t>=?,
+  (),
+): t => {
+  let log: array<call> = []
+  let record = c => log->Array.push(c)
+  let geocode = async (~text) => {
+    record(Geocoded({text: text}))
+    switch geocode {
+    | Some(f) => await f(~text)
+    | None => Ok([])
+    }
+  }
+  let send = async (~recipient, ~message) => {
+    record(Sent({recipient, message}))
+    switch send {
+    | Some(f) => await f(~recipient, ~message)
+    | None => Ok({Messaging.ref: `receipt-${Int.toString(log->Array.length)}`})
+    }
+  }
+  let createPrincipal = async (~contact, ~credential, ~groups) => {
+    record(PrincipalCreated({contact, credential, groups}))
+    switch createPrincipal {
+    | Some(f) => await f(~contact, ~credential, ~groups)
+    | None => Ok({IdentityProvider.providerId: `principal-${Int.toString(log->Array.length)}`})
+    }
+  }
+  let capabilities: Capabilities.t = {
+    geocode,
+    messaging: Messaging.makeProvider(~emailAndSms=channels, ~pushServices, ~send),
+    identityProvider: IdentityProvider.make(
+      ~createPrincipal,
+      ~addToGroup=async (~principal, ~group) => {
+        record(AddedToGroup({principal, group}))
+        Ok()
+      },
+      ~removeFromGroup=async (~principal, ~group) => {
+        record(RemovedFromGroup({principal, group}))
+        Ok()
+      },
+      ~deletePrincipal=async (~principal) => {
+        record(PrincipalDeleted({principal: principal}))
+        Ok()
+      },
+      ~operations=[CreatePrincipal, AddToGroup, RemoveFromGroup, DeletePrincipal],
+    ),
+    secrets: {
+      randomToken: (~length, ~alphabet) => {
+        record(TokenDrawn({length, alphabet}))
+        switch secrets {
+        | Some(s) => s.randomToken(~length, ~alphabet)
+        | None => Ok(token->Option.getOr("t"->String.repeat(length)))
+        }
+      },
+      hash: input => {
+        record(Hashed({input: input}))
+        switch secrets {
+        | Some(s) => s.hash(input)
+        | None => Ok(hash->Option.mapOr(`hash:${input}`, f => f(input)))
+        }
+      },
+    },
+  }
+  {capabilities, calls: () => log->Array.copy}
+}
+
+/** A readable rendering of a call, for a mismatch. */
+let toJson = (c: call): JSON.t => {
+  let recipientText = (r: Messaging.recipient) =>
+    switch r {
+    | ToEmail(email) => `email:${email}`
+    | ToSms(phone) => `sms:${phone}`
+    | ToPush(address) => `push:${address->Messaging.serviceOf->Messaging.pushServiceToString}`
+    }
+  let obj = (tag, fields) =>
+    JSON.Encode.object(Dict.fromArray([("TAG", JSON.Encode.string(tag)), ...fields]))
+  let str = JSON.Encode.string
+  switch c {
+  | Geocoded({text}) => obj("Geocoded", [("text", str(text))])
+  | Sent({recipient, message}) =>
+    obj(
+      "Sent",
+      [
+        ("recipient", str(recipientText(recipient))),
+        ("subject", message.subject->Option.mapOr(JSON.Encode.null, str)),
+        ("body", str(message.body)),
+      ],
+    )
+  | PrincipalCreated({contact, groups, _}) =>
+    obj(
+      "PrincipalCreated",
+      [
+        ("contact", str(recipientText(contact))),
+        ("groups", groups->Array.map(str)->JSON.Encode.array),
+      ],
+    )
+  | AddedToGroup({principal, group}) =>
+    obj("AddedToGroup", [("principal", str(principal.providerId)), ("group", str(group))])
+  | RemovedFromGroup({principal, group}) =>
+    obj("RemovedFromGroup", [("principal", str(principal.providerId)), ("group", str(group))])
+  | PrincipalDeleted({principal}) =>
+    obj("PrincipalDeleted", [("principal", str(principal.providerId))])
+  | TokenDrawn({length, _}) => obj("TokenDrawn", [("length", JSON.Encode.int(length))])
+  | Hashed({input}) => obj("Hashed", [("input", str(input))])
+  }
+}