@reventlessdev/reventless-gwt 1.0.0-alpha.243 → 1.0.0-alpha.245

package/CHANGELOG.md

@@ -3,6 +3,28 @@
 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.245 (2026-10-16)
+
+**Note:** Version bump only for package @reventlessdev/reventless-gwt
+
+
+
+
+
+# 1.0.0-alpha.244 (2026-10-16)
+
+* feat!(automation): schedules set by events ([53bc436](https://github.com/ReventlessDev/reventless-core/commit/53bc4363dffce81ef36475728bf0dae704716021))
+* feat!(automation): declared schedules tick an automation ([420acd2](https://github.com/ReventlessDev/reventless-core/commit/420acd2233aadf700141a31d9d3e0fdc8074bef7))
+
+### BREAKING CHANGES
+
+* a hand-written AutomationSlice.Mapping.Make the PPX does
+not see must define `let reschedule = _ => []`.
+* a hand-written AutomationSlice spec the PPX does not see must
+declare `let schedule = None`.
+
+
+
 # 1.0.0-alpha.243 (2026-10-15)
 
 * feat!: an automation's process takes ~now, and collect the event's recorded time ([8c8f3f5](https://github.com/ReventlessDev/reventless-core/commit/8c8f3f570474b1658b605b726077debc7d6a1dc7))

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reventlessdev/reventless-gwt",
-  "version": "1.0.0-alpha.243",
+  "version": "1.0.0-alpha.245",
   "description": "Given-When-Then DSLs and test harness for Reventless slice testing",
   "license": "Apache-2.0",
   "jest": {
@@ -15,16 +15,16 @@
   "dependencies": {
     "sury": "11.0.0",
     "@reventlessdev/rescript-effect": "1.0.0-alpha.0",
-    "@reventlessdev/reventless-core": "3.0.0-alpha.295",
     "@reventlessdev/rescript-jest": "1.0.0-alpha.12",
     "@reventlessdev/rescript-node": "2.0.0-alpha.22",
-    "@reventlessdev/reventless-infra": "3.0.0-alpha.192",
-    "@reventlessdev/reventless-spec": "3.0.0-alpha.164"
+    "@reventlessdev/reventless-core": "3.0.0-alpha.297",
+    "@reventlessdev/reventless-infra": "3.0.0-alpha.194",
+    "@reventlessdev/reventless-spec": "3.0.0-alpha.166"
   },
   "devDependencies": {
     "rescript": "12.3.1",
     "sury-ppx": "11.0.0",
-    "@reventlessdev/reventless-ppx": "1.0.0-alpha.100"
+    "@reventlessdev/reventless-ppx": "1.0.0-alpha.102"
   },
   "peerDependencies": {
     "rescript": "^12.3.1"

package/src/Automation_GWT.res

@@ -237,6 +237,8 @@ module FromSlice = (
   type scenario = {
     todos: array<(string, Spec.todoItem)>,
     commands: array<(string, Spec.command)>,
+    /** The slice's schedule rows after the events, by key. */
+    schedules: dict<AutomationSlice_Schedules.row>,
   }
 
   let encTodos = (arr: array<(string, Spec.todoItem)>) =>
@@ -309,18 +311,54 @@ module FromSlice = (
       | (l, None) => l
       }
     )
-  let routeAll = (events: array<sourced>, context) =>
-    events->Array.flatMap(e =>
+  let routeEach = (events: array<sourced>, context) =>
+    events->Array.map(e => (
+      e,
       Route.route(
         e.payload,
         ~sourceName=e.sourceName,
         ~sourceId=e.sourceId,
         context->withRecordedAt(e.recordedAt),
+      ),
+    ))
+  let routeAll = (events: array<sourced>, context) =>
+    routeEach(events, context)->Array.flatMap(((_, routed)) => routed)
+
+  /** Folds the events' `reschedule` into the rows as the runtime does; a tick
+      removes the once-only schedule it fired. A time that cannot fire changes
+      nothing, as at run time. */
+  let foldSchedules = (
+    rows,
+    routedEvents: array<(sourced, array<AutomationSlice_Route.routed<Spec.todoItem>>)>,
+    ~now,
+  ) =>
+    routedEvents->Array.forEach(((e, routed)) => {
+      let recordedAt = e.recordedAt->Option.getOr(now)
+      routed->Array.forEach(r =>
+        r.rescheduled->Array.forEach(
+          change => {
+            let _ = rows->AutomationSlice_Schedules.apply(change, ~setBy="scenario", ~recordedAt)
+          },
+        )
       )
-    )
+      if e.sourceName == Reventless.Clock.name {
+        rows->AutomationSlice_Schedules.fired(~key=e.sourceId)
+      }
+    })
+
+  // The declared time is in the rows before any event, as a deploy put it there.
+  let declaredRows = (~now) => {
+    let rows = Dict.make()
+    rows->AutomationSlice_Schedules.declare(Spec.schedule, ~now)
+    rows
+  }
   /** 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>>, ~now) => {
+  let sweep = (
+    routed: array<AutomationSlice_Route.routed<Spec.todoItem>>,
+    ~now,
+    ~schedules=declaredRows(~now),
+  ) => {
     let rows: array<(string, Spec.todoItem, ref<bool>)> = []
     routed->Array.forEach(r => {
       r.collected->Array.forEach(((id, item)) =>
@@ -338,16 +376,34 @@ module FromSlice = (
       )
     })
     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, ~now))}
+    {
+      todos,
+      commands: todos->Array.filterMap(((id, item)) => Automation.process(id, item, ~now)),
+      schedules,
+    }
   }
-  let whenSweep = (events, ~context=testContext, ~now=?) =>
-    sweep(
-      routeAll(events, context),
-      ~now=switch (now, latestRecorded(events)) {
-      | (Some(now), _) | (None, Some(now)) => now
-      | (None, None) => clockNow()
-      },
-    )
+  let whenSweep = (events, ~context=testContext, ~now=?) => {
+    let now = switch (now, latestRecorded(events)) {
+    | (Some(now), _) | (None, Some(now)) => now
+    | (None, None) => clockNow()
+    }
+    let routedEvents = routeEach(events, context)
+    let schedules = declaredRows(~now)
+    schedules->foldSchedules(routedEvents, ~now)
+    sweep(routedEvents->Array.flatMap(((_, routed)) => routed), ~now, ~schedules)
+  }
+  /** A tick from one of the slice's schedules, as the `Clock` source delivers it:
+      `key` defaults to the declared schedule's. */
+  let tick = (~key=Reventless.Clock.defaultKey, at) => {
+    sourceName: Reventless.Clock.name,
+    sourceId: key,
+    payload: Reventless.Clock.Tick({key, at})->Message.encode(Reventless.Clock.eventSchema),
+    recordedAt: Some(at),
+  }
+  /** The given events, then a tick at `at`, swept at `at`: what the slice does when its
+      schedule comes due. A tick delivered twice makes one item. */
+  let whenTick = (events, ~key=?, ~at, ~context=testContext) =>
+    whenSweep(events->Array.concat([tick(~key?, at)]), ~context, ~now=at)
   let thenCommands = (scenario, expected) =>
     scenario.commands == expected
       ? Outcome.pass
@@ -358,8 +414,37 @@ module FromSlice = (
           }),
         )
   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 routedEvents = routeEach(events, context)
+    let resolved =
+      routedEvents->Array.flatMap(((_, routed)) => routed)->Array.filterMap(r => r.resolved)
+    let schedules = scenario.schedules->Dict.copy
+    schedules->foldSchedules(routedEvents, ~now=latestRecorded(events)->Option.getOr(clockNow()))
+    {
+      ...scenario,
+      todos: scenario.todos->Array.filter(((id, _)) => !(resolved->Array.includes(id))),
+      schedules,
+    }
+  }
+  /** The slice's schedules after the scenario, by key: the declared time unless an
+      event replaced or cleared it, and every time an event set. An `After` an event
+      set is counted from when the event was recorded. */
+  let thenSchedules = (scenario, expected: array<(string, Reventless.Schedule.time)>) => {
+    let enc = ((key, time)) =>
+      JSON.Encode.object(
+        Dict.fromArray([
+          ("key", key->JSON.Encode.string),
+          ("time", time->Message.encode(Reventless.Schedule.timeSchema)),
+        ]),
+      )
+    let byKey = rows => rows->Array.toSorted(((a, _), (b, _)) => String.compare(a, b))
+    let actual =
+      scenario.schedules
+      ->Dict.valuesToArray
+      ->Array.filterMap(row => row->AutomationSlice_Schedules.timeOf->Option.map(t => (row.key, t)))
+      ->byKey
+      ->Array.map(enc)
+    let expected = expected->byKey->Array.map(enc)
+    actual == expected ? Outcome.pass : Outcome.fail(QueryRowsMismatch({expected, actual}))
   }
   let thenScenarioTodos = (scenario, expected) => thenTodos(scenario.todos, expected)
 }

package/src/Automation_GWT.res.mjs

@@ -4,12 +4,16 @@ import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
 import * as Clock from "effect/Clock";
 import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
 import * as Effect from "effect/Effect";
+import * as Clock$Reventless from "@reventlessdev/reventless-spec/src/components/Clock.res.mjs";
 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 Primitive_string from "@rescript/runtime/lib/es6/Primitive_string.js";
+import * as Schedule$Reventless from "@reventlessdev/reventless-spec/src/types/Schedule.res.mjs";
 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";
+import * as AutomationSlice_Schedules$ReventlessCore from "@reventlessdev/reventless-core/src/components/AutomationSlice/AutomationSlice_Schedules.res.mjs";
 
 function clockNow() {
   return Effect.runSync(Clock.currentTimeMillis);
@@ -298,8 +302,32 @@ function FromSlice(Spec) {
         return match;
       }
     });
-    let routeAll = (events, context) => events.flatMap(e => Route.route(e.payload, e.sourceName, e.sourceId, withRecordedAt(context, e.recordedAt)));
-    let sweep = (routed, now) => {
+    let routeEach = (events, context) => events.map(e => [
+      e,
+      Route.route(e.payload, e.sourceName, e.sourceId, withRecordedAt(context, e.recordedAt))
+    ]);
+    let routeAll = (events, context) => routeEach(events, context).flatMap(param => param[1]);
+    let foldSchedules = (rows, routedEvents, now) => {
+      routedEvents.forEach(param => {
+        let e = param[0];
+        let recordedAt = Stdlib_Option.getOr(e.recordedAt, now);
+        param[1].forEach(r => {
+          r.rescheduled.forEach(change => {
+            AutomationSlice_Schedules$ReventlessCore.apply(rows, change, "scenario", recordedAt);
+          });
+        });
+        if (e.sourceName === Clock$Reventless.name) {
+          return AutomationSlice_Schedules$ReventlessCore.fired(rows, e.sourceId);
+        }
+      });
+    };
+    let declaredRows = now => {
+      let rows = {};
+      AutomationSlice_Schedules$ReventlessCore.declare(rows, Spec.schedule, now);
+      return rows;
+    };
+    let sweep = (routed, now, schedulesOpt) => {
+      let schedules = schedulesOpt !== undefined ? schedulesOpt : declaredRows(now);
       let rows = [];
       routed.forEach(r => {
         r.collected.forEach(param => {
@@ -336,15 +364,37 @@ function FromSlice(Spec) {
       });
       return {
         todos: todos,
-        commands: Stdlib_Array.filterMap(todos, param => Automation.process(param[0], param[1], now))
+        commands: Stdlib_Array.filterMap(todos, param => Automation.process(param[0], param[1], now)),
+        schedules: schedules
       };
     };
     let whenSweep = (events, contextOpt, now) => {
       let context = contextOpt !== undefined ? contextOpt : testContext;
       let match = latestRecorded(events);
-      return sweep(routeAll(events, context), now !== undefined ? now : (
+      let now$1 = now !== undefined ? now : (
           match !== undefined ? match : Effect.runSync(Clock.currentTimeMillis)
-        ));
+        );
+      let routedEvents = routeEach(events, context);
+      let schedules = declaredRows(now$1);
+      foldSchedules(schedules, routedEvents, now$1);
+      return sweep(routedEvents.flatMap(param => param[1]), now$1, schedules);
+    };
+    let tick = (keyOpt, at) => {
+      let key = keyOpt !== undefined ? keyOpt : Clock$Reventless.defaultKey;
+      return {
+        sourceName: Clock$Reventless.name,
+        sourceId: key,
+        payload: Message$ReventlessCore.encode({
+          TAG: "Tick",
+          key: key,
+          at: at
+        }, Clock$Reventless.eventSchema),
+        recordedAt: at
+      };
+    };
+    let whenTick = (events, key, at, contextOpt) => {
+      let context = contextOpt !== undefined ? contextOpt : testContext;
+      return whenSweep(events.concat([tick(key, at)]), context, at);
     };
     let thenCommands = (scenario, expected) => {
       if (Primitive_object.equal(scenario.commands, expected)) {
@@ -359,12 +409,43 @@ function FromSlice(Spec) {
     };
     let andThenEvents = (scenario, events, contextOpt) => {
       let context = contextOpt !== undefined ? contextOpt : testContext;
-      let resolved = Stdlib_Array.filterMap(routeAll(events, context), r => r.resolved);
+      let routedEvents = routeEach(events, context);
+      let resolved = Stdlib_Array.filterMap(routedEvents.flatMap(param => param[1]), r => r.resolved);
+      let schedules = Object.assign({}, scenario.schedules);
+      foldSchedules(schedules, routedEvents, Stdlib_Option.getOr(latestRecorded(events), Effect.runSync(Clock.currentTimeMillis)));
       return {
         todos: scenario.todos.filter(param => !resolved.includes(param[0])),
-        commands: scenario.commands
+        commands: scenario.commands,
+        schedules: schedules
       };
     };
+    let thenSchedules = (scenario, expected) => {
+      let enc = param => Object.fromEntries([
+        [
+          "key",
+          param[0]
+        ],
+        [
+          "time",
+          Message$ReventlessCore.encode(param[1], Schedule$Reventless.timeSchema)
+        ]
+      ]);
+      let byKey = rows => rows.toSorted((param, param$1) => Primitive_string.compare(param[0], param$1[0]));
+      let actual = byKey(Stdlib_Array.filterMap(Object.values(scenario.schedules), row => Stdlib_Option.map(AutomationSlice_Schedules$ReventlessCore.timeOf(row), t => [
+        row.key,
+        t
+      ]))).map(enc);
+      let expected$1 = byKey(expected).map(enc);
+      if (Primitive_object.equal(actual, expected$1)) {
+        return Outcome$ReventlessGwt.pass;
+      } else {
+        return Outcome$ReventlessGwt.fail({
+          TAG: "QueryRowsMismatch",
+          expected: expected$1,
+          actual: actual
+        });
+      }
+    };
     let thenScenarioTodos = (scenario, expected) => thenTodos(scenario.todos, expected);
     return {
       Route: Route,
@@ -385,11 +466,17 @@ function FromSlice(Spec) {
       givenEvents: givenEvents,
       atTime: atTime,
       latestRecorded: latestRecorded,
+      routeEach: routeEach,
       routeAll: routeAll,
+      foldSchedules: foldSchedules,
+      declaredRows: declaredRows,
       sweep: sweep,
       whenSweep: whenSweep,
+      tick: tick,
+      whenTick: whenTick,
       thenCommands: thenCommands,
       andThenEvents: andThenEvents,
+      thenSchedules: thenSchedules,
       thenScenarioTodos: thenScenarioTodos
     };
   };

package/src/Flow_GWT.res.mjs

@@ -525,7 +525,7 @@ function AutomationSlice(Spec) {
     let whenReacts = async flowP => {
       let s = await flowP;
       let routed = s.log.flatMap(entry => Stdlib_Array.filterMap(A.Route.dispatches, d => d.handle(entry.json, Stdlib_Option.getOr(entry.aggregateId, ""), A.testContext)));
-      let match = A.sweep(routed, Automation_GWT$ReventlessGwt.clockNow());
+      let match = A.sweep(routed, Automation_GWT$ReventlessGwt.clockNow(), undefined);
       return {
         log: s.log,
         outcome: s.outcome,

package/tests/AutomationDeadlineGwtTest.res

@@ -16,6 +16,7 @@ module CancelUnshipped = {
   let maxRetries = 3
   let heartbeatInterval = 60
   let targetName = "Order"
+  let schedule = None
 }
 
 let day = 24. *. 60. *. 60. *. 1000.
@@ -51,6 +52,7 @@ module CancelUnshipped_Automation = {
         | Orders.OrderShipped({orderId}) => Some(orderId)
         | OrderPlaced(_) => None
         }
+      let reschedule = _ => []
     },
   )
 

package/tests/AutomationDeadlineGwtTest.res.mjs

@@ -33,6 +33,7 @@ let CancelUnshipped = {
   maxRetries: 3,
   heartbeatInterval: 60,
   targetName: "Order",
+  schedule: undefined,
   authorizationOf: authorizationOf,
   commandTransition: commandTransition,
   traits: traits
@@ -91,13 +92,18 @@ function resolve(event) {
   }
 }
 
+function reschedule(param) {
+  return [];
+}
+
 let FromOrders = AutomationSlice$Reventless.Mapping.Make({
   Id: Id$Reventless.$$String,
   name: name,
   eventSchema: eventSchema
 })(CancelUnshipped)({
   collect: collect,
-  resolve: resolve
+  resolve: resolve,
+  reschedule: reschedule
 });
 
 let mappings = [FromOrders];
@@ -225,12 +231,24 @@ let thenNoCommand = include.thenNoCommand;
 
 let latestRecorded = include.latestRecorded;
 
+let routeEach = include.routeEach;
+
 let routeAll = include.routeAll;
 
+let foldSchedules = include.foldSchedules;
+
+let declaredRows = include.declaredRows;
+
 let sweep = include.sweep;
 
+let tick = include.tick;
+
+let whenTick = include.whenTick;
+
 let andThenEvents = include.andThenEvents;
 
+let thenSchedules = include.thenSchedules;
+
 let thenScenarioTodos = include.thenScenarioTodos;
 
 export {
@@ -256,11 +274,17 @@ export {
   givenEvents,
   atTime,
   latestRecorded,
+  routeEach,
   routeAll,
+  foldSchedules,
+  declaredRows,
   sweep,
   whenSweep,
+  tick,
+  whenTick,
   thenCommands,
   andThenEvents,
+  thenSchedules,
   thenScenarioTodos,
   O,
 }

package/tests/AutomationFromSliceGwtTest.res

@@ -18,6 +18,7 @@ module ShipPaid = {
   let maxRetries = 3
   let heartbeatInterval = 60
   let targetName = "Order"
+  let schedule = None
 }
 
 module ShipPaid_Automation = {
@@ -57,6 +58,7 @@ module ShipPaid_Automation = {
         | Orders.OrderCancelled({orderId}) => Some(orderId)
         | OrderPlaced(_) => None
         }
+      let reschedule = _ => []
     },
   )
 
@@ -74,6 +76,7 @@ module ShipPaid_Automation = {
         | Payments.Refunded(_) => None
         | Captured(_) => None
         }
+      let reschedule = _ => []
     },
   )
 

package/tests/AutomationFromSliceGwtTest.res.mjs

@@ -38,6 +38,7 @@ let ShipPaid = {
   maxRetries: 3,
   heartbeatInterval: 60,
   targetName: "Order",
+  schedule: undefined,
   authorizationOf: authorizationOf,
   commandTransition: commandTransition,
   traits: traits
@@ -106,13 +107,18 @@ function resolve(event) {
   }
 }
 
+function reschedule(param) {
+  return [];
+}
+
 let FromOrders = AutomationSlice$Reventless.Mapping.Make({
   Id: Id$Reventless.$$String,
   name: name,
   eventSchema: eventSchema
 })(ShipPaid)({
   collect: collect,
-  resolve: resolve
+  resolve: resolve,
+  reschedule: reschedule
 });
 
 function collect$1(event, sourceId, _ctx) {
@@ -132,13 +138,18 @@ function resolve$1(event) {
   
 }
 
+function reschedule$1(param) {
+  return [];
+}
+
 let FromPayments = AutomationSlice$Reventless.Mapping.Make({
   Id: Id$Reventless.$$String,
   name: name$1,
   eventSchema: eventSchema$1
 })(ShipPaid)({
   collect: collect$1,
-  resolve: resolve$1
+  resolve: resolve$1,
+  reschedule: reschedule$1
 });
 
 let mappings = [
@@ -325,10 +336,22 @@ let atTime = include.atTime;
 
 let latestRecorded = include.latestRecorded;
 
+let routeEach = include.routeEach;
+
 let routeAll = include.routeAll;
 
+let foldSchedules = include.foldSchedules;
+
+let declaredRows = include.declaredRows;
+
 let sweep = include.sweep;
 
+let tick = include.tick;
+
+let whenTick = include.whenTick;
+
+let thenSchedules = include.thenSchedules;
+
 export {
   ShipPaid,
   ShipPaid_Automation,
@@ -350,11 +373,17 @@ export {
   givenEvents,
   atTime,
   latestRecorded,
+  routeEach,
   routeAll,
+  foldSchedules,
+  declaredRows,
   sweep,
   whenSweep,
+  tick,
+  whenTick,
   thenCommands,
   andThenEvents,
+  thenSchedules,
   thenScenarioTodos,
   O,
   P,