@reventlessdev/reventless-gwt 1.0.0-alpha.242 → 1.0.0-alpha.244

package/tests/AutomationScheduleGwtTest.res

@@ -0,0 +1,140 @@
+// A declared schedule: the demand report every morning at 06:00. The slice maps the
+// framework's Clock source; each tick makes the day's item, `process` requests the
+// report, and the event that request records completes the item. The catalog team
+// can move the report or stop it with an event, which replaces the declared time.
+
+module DemandReport = {
+  let name = "DemandReport"
+  let moduleUrl = ""
+
+  @schema
+  type todoItem = {day: float}
+
+  @schema
+  type command = RequestDemandReport({day: float})
+
+  let maxRetries = 3
+  let heartbeatInterval = 60
+  let targetName = "ReportSettings"
+  let schedule = Some(Reventless.Schedule.Calendar({calendar: Daily({hour: 6, minute: 0})}))
+}
+
+module DemandReport_Automation = {
+  module M = Reventless.AutomationSlice.Mappings.Make(DemandReport)
+  module type Mapping = M.Mapping
+  let moduleUrl = ""
+
+  module CatalogDcbSource = {
+    module Id = Reventless.Id.String
+    let name = "CatalogDcbEventLog"
+    @schema
+    type event =
+      | DemandReportRequested({day: float})
+      | DemandReportTimeChanged({time: Reventless.Schedule.time})
+      | DemandReportStopped
+  }
+
+  module FromClock = Reventless.AutomationSlice.Mapping.Make(
+    Reventless.Clock,
+    DemandReport,
+    {
+      open Reventless.Clock
+      let collect = (Tick({key, at}), ~sourceId as _, _ctx) => [
+        (itemId(key, at), ({day: at}: DemandReport.todoItem)),
+      ]
+      let resolve = _ => None
+      let reschedule = _ => []
+    },
+  )
+
+  module FromCatalogDcb = Reventless.AutomationSlice.Mapping.Make(
+    CatalogDcbSource,
+    DemandReport,
+    {
+      let collect = (_, ~sourceId as _, _ctx) => []
+      let resolve = event =>
+        switch event {
+        | CatalogDcbSource.DemandReportRequested({day}) =>
+          Some(Reventless.Clock.itemId(Reventless.Clock.defaultKey, day))
+        | _ => None
+        }
+      let reschedule = event =>
+        switch event {
+        | CatalogDcbSource.DemandReportTimeChanged({time}) => [
+            Reventless.AutomationSlice.Set({key: Reventless.Clock.defaultKey, time}),
+          ]
+        | DemandReportStopped => [Clear({key: Reventless.Clock.defaultKey})]
+        | DemandReportRequested(_) => []
+        }
+    },
+  )
+
+  let mappings: array<module(Mapping)> = [module(FromClock), module(FromCatalogDcb)]
+
+  let process = (id, item: DemandReport.todoItem, ~now as _) => Some((
+    id,
+    DemandReport.RequestDemandReport({day: item.day}),
+  ))
+  let onExhausted = (_id, _item: DemandReport.todoItem) => None
+}
+
+open DemandReport
+open DemandReport_Automation
+include Automation_GWT.FromSlice(DemandReport, DemandReport_Automation)
+module Catalog = Mapping(FromCatalogDcb)
+
+let morning = Date.fromString("2026-10-16T06:00:00Z")->Date.getTime
+let dayItem = "default@2026-10-16T06:00Z"
+
+describe("a declared schedule", () => {
+  test("the tick makes the day's item, and process requests the report", () =>
+    givenEvents([])
+    ->whenTick(~at=morning)
+    ->thenCommands([(dayItem, RequestDemandReport({day: morning}))])
+  )
+
+  test("the same tick delivered twice makes one item", () =>
+    givenEvents([tick(morning)])
+    ->whenTick(~at=morning)
+    ->thenScenarioTodos([(dayItem, {day: morning})])
+  )
+
+  test("the report's own event completes the day's item", () =>
+    givenEvents([])
+    ->whenTick(~at=morning)
+    ->andThenEvents([Catalog.event(DemandReportRequested({day: morning}))])
+    ->thenScenarioTodos([])
+  )
+
+  test("the item id is the key and the scheduled minute, in UTC", () =>
+    givenEvents([])
+    ->whenTick(~key="r1", ~at=Date.fromString("2026-10-16T18:00:42Z")->Date.getTime)
+    ->thenScenarioTodos([
+      ("r1@2026-10-16T18:00Z", {day: Date.fromString("2026-10-16T18:00:42Z")->Date.getTime}),
+    ])
+  )
+})
+
+let daily6 = Reventless.Schedule.Calendar({calendar: Daily({hour: 6, minute: 0})})
+let weekdays730 = Reventless.Schedule.Calendar({
+  calendar: Weekly({days: [Mon, Tue, Wed, Thu, Fri], hour: 7, minute: 30}),
+})
+
+describe("the same schedule, moved by an event", () => {
+  test("with no event, the schedule is the declared one", () =>
+    givenEvents([])->whenSweep(~now=morning)->thenSchedules([("default", daily6)])
+  )
+
+  test("an event replaces the declared time", () =>
+    givenEvents([Catalog.event(DemandReportTimeChanged({time: weekdays730}))])
+    ->whenSweep(~now=morning)
+    ->thenSchedules([("default", weekdays730)])
+  )
+
+  test("an event that stops the report leaves no schedule", () =>
+    givenEvents([Catalog.event(DemandReportTimeChanged({time: weekdays730}))])
+    ->whenSweep(~now=morning)
+    ->andThenEvents([Catalog.event(DemandReportStopped)])
+    ->thenSchedules([])
+  )
+})

package/tests/AutomationScheduleGwtTest.res.mjs

@@ -0,0 +1,356 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Sury from "sury";
+import * as Id$Reventless from "@reventlessdev/reventless-spec/src/types/Id.res.mjs";
+import * as Clock$Reventless from "@reventlessdev/reventless-spec/src/components/Clock.res.mjs";
+import * as Schedule$Reventless from "@reventlessdev/reventless-spec/src/types/Schedule.res.mjs";
+import * as AutomationSlice$Reventless from "@reventlessdev/reventless-spec/src/components/AutomationSlice.res.mjs";
+import * as Automation_GWT$ReventlessGwt from "../src/Automation_GWT.res.mjs";
+
+let todoItemSchema = Sury.$schema(s => ({
+  day: s.m(Sury.number)
+}));
+
+let commandSchema = Sury.$schema(s => ({
+  TAG: "RequestDemandReport",
+  day: s.m(Sury.number)
+}));
+
+function authorizationOf(param) {
+  return "AllowAuthenticated";
+}
+
+function commandTransition(param) {
+  return "Undeclared";
+}
+
+let traits = [];
+
+let DemandReport_schedule = {
+  TAG: "Calendar",
+  calendar: {
+    TAG: "Daily",
+    hour: 6,
+    minute: 0
+  }
+};
+
+let DemandReport = {
+  name: "DemandReport",
+  moduleUrl: "",
+  todoItemSchema: todoItemSchema,
+  commandSchema: commandSchema,
+  maxRetries: 3,
+  heartbeatInterval: 60,
+  targetName: "ReportSettings",
+  schedule: DemandReport_schedule,
+  authorizationOf: authorizationOf,
+  commandTransition: commandTransition,
+  traits: traits
+};
+
+let M = AutomationSlice$Reventless.Mappings.Make(DemandReport);
+
+let moduleUrl = "";
+
+let name = "CatalogDcbEventLog";
+
+let eventSchema = Sury.union([
+  Sury.$schema(s => ({
+    TAG: "DemandReportRequested",
+    day: s.m(Sury.number)
+  })),
+  Sury.$schema(s => ({
+    TAG: "DemandReportTimeChanged",
+    time: s.m(Schedule$Reventless.timeSchema)
+  })),
+  Sury.literal("DemandReportStopped")
+]);
+
+let CatalogDcbSource = {
+  Id: undefined,
+  name: name,
+  eventSchema: eventSchema
+};
+
+function collect(param, param$1, _ctx) {
+  let at = param.at;
+  return [[
+      Clock$Reventless.itemId(param.key, at),
+      {
+        day: at
+      }
+    ]];
+}
+
+function resolve(param) {
+  
+}
+
+function reschedule(param) {
+  return [];
+}
+
+let FromClock = AutomationSlice$Reventless.Mapping.Make({
+  Id: Id$Reventless.$$String,
+  name: Clock$Reventless.name,
+  eventSchema: Clock$Reventless.eventSchema
+})(DemandReport)({
+  collect: collect,
+  resolve: resolve,
+  reschedule: reschedule
+});
+
+function collect$1(param, param$1, _ctx) {
+  return [];
+}
+
+function resolve$1(event) {
+  if (typeof event !== "object" || event.TAG !== "DemandReportRequested") {
+    return;
+  } else {
+    return Clock$Reventless.itemId(Clock$Reventless.defaultKey, event.day);
+  }
+}
+
+function reschedule$1(event) {
+  if (typeof event !== "object") {
+    return [{
+        TAG: "Clear",
+        key: Clock$Reventless.defaultKey
+      }];
+  } else if (event.TAG === "DemandReportRequested") {
+    return [];
+  } else {
+    return [{
+        TAG: "Set",
+        key: Clock$Reventless.defaultKey,
+        time: event.time
+      }];
+  }
+}
+
+let FromCatalogDcb = AutomationSlice$Reventless.Mapping.Make({
+  Id: Id$Reventless.$$String,
+  name: name,
+  eventSchema: eventSchema
+})(DemandReport)({
+  collect: collect$1,
+  resolve: resolve$1,
+  reschedule: reschedule$1
+});
+
+let mappings = [
+  FromClock,
+  FromCatalogDcb
+];
+
+function process(id, item, param) {
+  return [
+    id,
+    {
+      TAG: "RequestDemandReport",
+      day: item.day
+    }
+  ];
+}
+
+function onExhausted(_id, _item) {
+  
+}
+
+let DemandReport_Automation = {
+  M: M,
+  moduleUrl: moduleUrl,
+  CatalogDcbSource: CatalogDcbSource,
+  FromClock: FromClock,
+  FromCatalogDcb: FromCatalogDcb,
+  mappings: mappings,
+  process: process,
+  onExhausted: onExhausted
+};
+
+let include = Automation_GWT$ReventlessGwt.FromSlice(DemandReport)({
+  process: process,
+  onExhausted: onExhausted,
+  moduleUrl: moduleUrl,
+  mappings: mappings
+});
+
+let describe = include.describe;
+
+let test = include.test;
+
+let Mapping = include.Mapping;
+
+let givenEvents = include.givenEvents;
+
+let whenSweep = include.whenSweep;
+
+let tick = include.tick;
+
+let whenTick = include.whenTick;
+
+let thenCommands = include.thenCommands;
+
+let andThenEvents = include.andThenEvents;
+
+let thenSchedules = include.thenSchedules;
+
+let thenScenarioTodos = include.thenScenarioTodos;
+
+let Catalog = Mapping(FromCatalogDcb);
+
+let morning = new Date("2026-10-16T06:00:00Z").getTime();
+
+let dayItem = "default@2026-10-16T06:00Z";
+
+describe("a declared schedule", () => {
+  test("the tick makes the day's item, and process requests the report", () => thenCommands(whenTick(givenEvents([]), undefined, morning, undefined), [[
+      dayItem,
+      {
+        TAG: "RequestDemandReport",
+        day: morning
+      }
+    ]]));
+  test("the same tick delivered twice makes one item", () => thenScenarioTodos(whenTick(givenEvents([tick(undefined, morning)]), undefined, morning, undefined), [[
+      dayItem,
+      {
+        day: morning
+      }
+    ]]));
+  test("the report's own event completes the day's item", () => thenScenarioTodos(andThenEvents(whenTick(givenEvents([]), undefined, morning, undefined), [Catalog.event({
+      TAG: "DemandReportRequested",
+      day: morning
+    }, undefined, undefined)], undefined), []));
+  test("the item id is the key and the scheduled minute, in UTC", () => thenScenarioTodos(whenTick(givenEvents([]), "r1", new Date("2026-10-16T18:00:42Z").getTime(), undefined), [[
+      "r1@2026-10-16T18:00Z",
+      {
+        day: new Date("2026-10-16T18:00:42Z").getTime()
+      }
+    ]]));
+});
+
+let daily6 = {
+  TAG: "Calendar",
+  calendar: {
+    TAG: "Daily",
+    hour: 6,
+    minute: 0
+  }
+};
+
+let weekdays730_0 = {
+  TAG: "Weekly",
+  days: [
+    "Mon",
+    "Tue",
+    "Wed",
+    "Thu",
+    "Fri"
+  ],
+  hour: 7,
+  minute: 30
+};
+
+let weekdays730 = {
+  TAG: "Calendar",
+  calendar: weekdays730_0
+};
+
+describe("the same schedule, moved by an event", () => {
+  test("with no event, the schedule is the declared one", () => thenSchedules(whenSweep(givenEvents([]), undefined, morning), [[
+      "default",
+      daily6
+    ]]));
+  test("an event replaces the declared time", () => thenSchedules(whenSweep(givenEvents([Catalog.event({
+      TAG: "DemandReportTimeChanged",
+      time: weekdays730
+    }, undefined, undefined)]), undefined, morning), [[
+      "default",
+      weekdays730
+    ]]));
+  test("an event that stops the report leaves no schedule", () => thenSchedules(andThenEvents(whenSweep(givenEvents([Catalog.event({
+      TAG: "DemandReportTimeChanged",
+      time: weekdays730
+    }, undefined, undefined)]), undefined, morning), [Catalog.event("DemandReportStopped", undefined, undefined)], undefined), []));
+});
+
+let Route = include.Route;
+
+let testContext = include.testContext;
+
+let withRecordedAt = include.withRecordedAt;
+
+let encTodos = include.encTodos;
+
+let encPair = include.encPair;
+
+let thenTodos = include.thenTodos;
+
+let thenResolved = include.thenResolved;
+
+let givenTodo = include.givenTodo;
+
+let whenProcess = include.whenProcess;
+
+let whenExhausted = include.whenExhausted;
+
+let thenCommand = include.thenCommand;
+
+let thenNoCommand = include.thenNoCommand;
+
+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;
+
+export {
+  DemandReport,
+  DemandReport_Automation,
+  Route,
+  describe,
+  test,
+  testContext,
+  withRecordedAt,
+  encTodos,
+  encPair,
+  thenTodos,
+  thenResolved,
+  Mapping,
+  givenTodo,
+  whenProcess,
+  whenExhausted,
+  thenCommand,
+  thenNoCommand,
+  givenEvents,
+  atTime,
+  latestRecorded,
+  routeEach,
+  routeAll,
+  foldSchedules,
+  declaredRows,
+  sweep,
+  whenSweep,
+  tick,
+  whenTick,
+  thenCommands,
+  andThenEvents,
+  thenSchedules,
+  thenScenarioTodos,
+  Catalog,
+  morning,
+  dayItem,
+  daily6,
+  weekdays730,
+}
+/* todoItemSchema Not a pure module */

package/tests/FlowGwtTest.res

@@ -73,7 +73,7 @@ module AutoShipSlice = {
     | OrderPlaced(_) => None
     }
 
-  let process = (id, _todo) => Some((id, ShipOrder({orderId: id})))
+  let process = (id, _todo, ~now as _) => Some((id, ShipOrder({orderId: id})))
   let onExhausted = (_id, _todo) => None
 }
 

package/tests/FlowGwtTest.res.mjs

@@ -122,7 +122,7 @@ function resolve(event) {
   }
 }
 
-function process(id, _todo) {
+function process(id, _todo, param) {
   return [
     id,
     {