@reventlessdev/reventless-local 3.0.0-alpha.285 → 3.0.0-alpha.286

package/CHANGELOG.md

@@ -3,6 +3,25 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+# 3.0.0-alpha.286 (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))
+* feat!: schedules take a Schedule.time, run on EventBridge Scheduler on AWS ([2d74557](https://github.com/ReventlessDev/reventless-core/commit/2d74557a6304917ded8f2b9f4107af9298c91ac0))
+### Features
+
+* **local:** sweep pending automation items, as AWS does ([96acec0](https://github.com/ReventlessDev/reventless-core/commit/96acec0ba226ee560790bd14b6fd38e44328a47c))
+
+### BREAKING CHANGES
+
+* a process the PPX does not see — in an Automation module
+written by hand, or a SliceSpec given to the deprecated Automation_GWT.Make
+or Flow_GWT.AutomationStep — must take ~now.
+* Schedule.rate is replaced by Schedule.time, and a
+schedule's `rate` field is now `time`. A once-only time already past
+never fires, locally as on AWS.
+
+
+
 # 3.0.0-alpha.285 (2026-10-14)
 
 **Note:** Version bump only for package @reventlessdev/reventless-local

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reventlessdev/reventless-local",
-  "version": "3.0.0-alpha.285",
+  "version": "3.0.0-alpha.286",
   "description": "Local platform for Reventless (in-memory or SQLite backend, for development and testing without AWS)",
   "license": "Apache-2.0",
   "bin": {
@@ -34,19 +34,19 @@
     "graphql-yoga": "^5.21.0",
     "sury": "11.0.0",
     "ws": "^8.18.0",
-    "@reventlessdev/rescript-effect": "0.1.0-alpha.35",
+    "@reventlessdev/rescript-effect": "1.0.0-alpha.0",
     "@reventlessdev/rescript-graphql-yoga": "1.0.0-alpha.29",
+    "@reventlessdev/rescript-mcp-sdk": "1.0.0-alpha.23",
     "@reventlessdev/rescript-jest": "1.0.0-alpha.12",
     "@reventlessdev/rescript-node": "2.0.0-alpha.22",
-    "@reventlessdev/rescript-mcp-sdk": "1.0.0-alpha.23",
+    "@reventlessdev/reventless-core": "3.0.0-alpha.295",
+    "@reventlessdev/reventless-graphql-server": "1.0.0-alpha.143",
+    "@reventlessdev/reventless-gwt": "1.0.0-alpha.243",
     "@reventlessdev/rescript-pulumi-pulumi": "2.3.0-alpha.23",
-    "@reventlessdev/reventless-core": "3.0.0-alpha.294",
-    "@reventlessdev/reventless-graphql-server": "1.0.0-alpha.142",
-    "@reventlessdev/reventless-gwt": "1.0.0-alpha.242",
+    "@reventlessdev/reventless-infra": "3.0.0-alpha.192",
     "@reventlessdev/reventless-seed": "1.0.0-alpha.34",
-    "@reventlessdev/reventless-spec": "3.0.0-alpha.163",
-    "@reventlessdev/reventless-postgres": "3.0.0-alpha.158",
-    "@reventlessdev/reventless-infra": "3.0.0-alpha.191"
+    "@reventlessdev/reventless-spec": "3.0.0-alpha.164",
+    "@reventlessdev/reventless-postgres": "3.0.0-alpha.159"
   },
   "devDependencies": {
     "rescript": "12.3.1",

package/src/adapter/Scheduler/LocalScheduledPublisher.res

@@ -1,10 +1,9 @@
 // In-memory ScheduledPublisher — satisfies Scheduler_Adapter.ScheduledPublisher.
 //
-// createSchedule: sets up a setInterval that fires Bus.publishEvent when the schedule triggers.
-// deleteSchedule: clears the interval.
-//
-// The schedule.payload is published as the event body. For Single(…) schedules a
-// one-shot setTimeout is used; all recurring rates use setInterval.
+// createSchedule waits for each firing `ScheduleTime.nextFiring` names and publishes the
+// payload as an event on the first channel resource; a once-only time fires once, one
+// already past never. A second createSchedule under the same name replaces the first,
+// as on AWS. deleteSchedule stops it.
 //
 // Usage: create a Scheduler with Scheduler_Builder.Make(LocalScheduledPublisher.Make(Bus))
 // and pass the resulting component to Plugin_Builder or Task_Builder.
@@ -13,29 +12,40 @@ module Make = (Bus: LocalBus.T) => {
   type timerHandle
 
   @val
-  external setIntervalJs: (unit => unit, int) => timerHandle = "setInterval"
-  @val
-  external setTimeoutJs: (unit => unit, int) => timerHandle = "setTimeout"
+  external setTimeoutJs: (unit => unit, float) => timerHandle = "setTimeout"
   @val
   external clearTimerJs: timerHandle => unit = "clearTimeout"
 
   let activeTimers: ref<dict<timerHandle>> = ref(Dict.make())
 
-  let rateToMs = (rate: Reventless.Schedule.rate) =>
-    switch rate {
-    | Minutes(n) => n * 60 * 1000
-    | Hours(n) => n * 60 * 60 * 1000
-    | Days(n) => n * 24 * 60 * 60 * 1000
-    | Daily(_, _) => 24 * 60 * 60 * 1000
-    | Weekdays(_, _) => 24 * 60 * 60 * 1000
-    | WeekdaysAndSaturday(_, _) => 24 * 60 * 60 * 1000
-    | Single(_, _, _, _, _) => 0
+  // Node fires a delay above 2^31 - 1 ms at once, so a far firing is reached a day at a time.
+  let maxWaitMs = 86_400_000.
+
+  let stop = name =>
+    switch activeTimers.contents->Dict.get(name) {
+    | Some(handle) =>
+      clearTimerJs(handle)
+      activeTimers.contents->Dict.delete(name)
+    | None => ()
     }
 
-  let isSingleShot = rate =>
-    switch rate {
-    | Reventless.Schedule.Single(_, _, _, _, _) => true
-    | _ => false
+  let rec waitUntil = (name, at, fire) => {
+    let delay = at -. Date.now()
+    let handle =
+      delay > maxWaitMs
+        ? setTimeoutJs(() => waitUntil(name, at, fire), maxWaitMs)
+        : setTimeoutJs(fire, Math.max(delay, 0.))
+    activeTimers.contents->Dict.set(name, handle)
+  }
+
+  let rec arm = (name, time, ~after, ~publish) =>
+    switch ReventlessCore.ScheduleTime.nextFiring(time, ~after) {
+    | None => activeTimers.contents->Dict.delete(name)
+    | Some(at) =>
+      waitUntil(name, at, () => {
+        publish()
+        arm(name, time, ~after=at, ~publish)
+      })
     }
 
   let scheduleMeta: ReventlessCore.Message.meta = {
@@ -52,6 +62,7 @@ module Make = (Bus: LocalBus.T) => {
       channelResources,
       schedule,
     ) => {
+      ReventlessCore.ScheduleTime.validate(schedule.time)
       let topicName = switch channelResources {
       | [] => ""
       | resources => (resources->Array.getUnsafe(0)).name
@@ -60,23 +71,19 @@ module Make = (Bus: LocalBus.T) => {
       | json => json
       | exception _ => schedule.payload->JSON.Encode.string
       }
-      let fire = () => Bus.publishEvent(topicName, "Scheduler", scheduleMeta, payloadJson)->ignore
-      let handle = if schedule.rate->isSingleShot {
-        setTimeoutJs(fire, 0)
-      } else {
-        setIntervalJs(fire, rateToMs(schedule.rate))
-      }
-      activeTimers.contents->Dict.set(schedule.name, handle)
+      let publish = () =>
+        Bus.publishEvent(topicName, "Scheduler", scheduleMeta, payloadJson)->ignore
+      let setAt = Date.now()
+      stop(schedule.name)
+      arm(
+        schedule.name,
+        schedule.time->ReventlessCore.ScheduleTime.resolveOnce(~from=setAt),
+        ~after=setAt,
+        ~publish,
+      )
     }
 
-    let deleteSchedule: ReventlessInfra.Scheduler.deleteSchedule = async (_, name) => {
-      switch activeTimers.contents->Dict.get(name) {
-      | Some(handle) =>
-        clearTimerJs(handle)
-        activeTimers.contents->Dict.delete(name)
-      | None => ()
-      }
-    }
+    let deleteSchedule: ReventlessInfra.Scheduler.deleteSchedule = async (_, name) => stop(name)
 
     {
       resource: ReventlessInfra.Adapter.make(

package/src/adapter/Scheduler/LocalScheduledPublisher.res.mjs

@@ -4,26 +4,35 @@ import * as Stdlib_Dict from "@rescript/runtime/lib/es6/Stdlib_Dict.js";
 import * as Pulumi from "@pulumi/pulumi";
 import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
 import * as Adapter$ReventlessInfra from "@reventlessdev/reventless-infra/src/adapter/Adapter.res.mjs";
+import * as ScheduleTime$ReventlessCore from "@reventlessdev/reventless-core/src/util/ScheduleTime.res.mjs";
 
 function Make(Bus) {
   let activeTimers = {
     contents: {}
   };
-  let rateToMs = rate => {
-    switch (rate.TAG) {
-      case "Single" :
-        return 0;
-      case "Minutes" :
-        return (rate._0 * 60 | 0) * 1000 | 0;
-      case "Hours" :
-        return ((rate._0 * 60 | 0) * 60 | 0) * 1000 | 0;
-      case "Days" :
-        return (((rate._0 * 24 | 0) * 60 | 0) * 60 | 0) * 1000 | 0;
-      default:
-        return 86400000;
+  let stop = name => {
+    let handle = activeTimers.contents[name];
+    if (handle !== undefined) {
+      clearTimeout(Primitive_option.valFromOption(handle));
+      return Stdlib_Dict.$$delete(activeTimers.contents, name);
+    }
+  };
+  let waitUntil = (name, at, fire) => {
+    let delay = at - Date.now();
+    let handle = delay > 86400000 ? setTimeout(() => waitUntil(name, at, fire), 86400000) : setTimeout(fire, Math.max(delay, 0));
+    activeTimers.contents[name] = handle;
+  };
+  let arm = (name, time, after, publish) => {
+    let at = ScheduleTime$ReventlessCore.nextFiring(time, after);
+    if (at !== undefined) {
+      return waitUntil(name, at, () => {
+        publish();
+        arm(name, time, at, publish);
+      });
+    } else {
+      return Stdlib_Dict.$$delete(activeTimers.contents, name);
     }
   };
-  let isSingleShot = rate => rate.TAG === "Single";
   let scheduleMeta = {
     service: "Scheduler",
     time: "",
@@ -34,6 +43,7 @@ function Make(Bus) {
   };
   let make = (param, param$1) => {
     let createSchedule = async (channelResources, schedule) => {
+      ScheduleTime$ReventlessCore.validate(schedule.time);
       let topicName = channelResources.length !== 0 ? channelResources[0].name : "";
       let payloadJson;
       try {
@@ -41,19 +51,14 @@ function Make(Bus) {
       } catch (exn) {
         payloadJson = schedule.payload;
       }
-      let fire = () => {
+      let publish = () => {
         Bus.publishEvent(topicName, "Scheduler", scheduleMeta, payloadJson);
       };
-      let handle = isSingleShot(schedule.rate) ? setTimeout(fire, 0) : setInterval(fire, rateToMs(schedule.rate));
-      activeTimers.contents[schedule.name] = handle;
-    };
-    let deleteSchedule = async (param, name) => {
-      let handle = activeTimers.contents[name];
-      if (handle !== undefined) {
-        clearTimeout(Primitive_option.valFromOption(handle));
-        return Stdlib_Dict.$$delete(activeTimers.contents, name);
-      }
+      let setAt = Date.now();
+      stop(schedule.name);
+      return arm(schedule.name, ScheduleTime$ReventlessCore.resolveOnce(schedule.time, setAt), setAt, publish);
     };
+    let deleteSchedule = async (param, name) => stop(name);
     return {
       resource: Adapter$ReventlessInfra.make(Pulumi.output(""), Pulumi.output(""), Pulumi.output(""), Pulumi.output("memory:InMemory"), undefined, undefined, undefined, undefined, undefined, undefined),
       operations: Pulumi.output({
@@ -70,8 +75,10 @@ function Make(Bus) {
   };
   return {
     activeTimers: activeTimers,
-    rateToMs: rateToMs,
-    isSingleShot: isSingleShot,
+    maxWaitMs: 86400000,
+    stop: stop,
+    waitUntil: waitUntil,
+    arm: arm,
     scheduleMeta: scheduleMeta,
     make: make,
     reset: reset

package/src/components/AutomationSlice_Builder.res

@@ -1,5 +1,6 @@
 // In-memory AutomationSlice builder.
-// Wires in-memory adapters and delegates to the core ReventlessCore.AutomationSlice_Builder.
+// Wires in-memory adapters and delegates to the core ReventlessCore.AutomationSlice_Builder;
+// each slice it makes joins the local automation sweep.
 
 module Make = (Bus: LocalBus.T) => {
   module RuntimeEnvironment = LocalRuntimeEnvironment
@@ -36,6 +37,13 @@ module Make = (Bus: LocalBus.T) => {
     type component = Inner.component
     let queryDbName = Inner.queryDbName
     let sourceNames = Inner.sourceNames
-    let make = Inner.make
+    let make = (~allEventTopics, ~publishJsons, ~context, ~runtime=?, ~opts=?) => {
+      let component = Inner.make(~allEventTopics, ~publishJsons, ~context, ~runtime?, ~opts?)
+      LocalAutomationSweep.register(~name=Spec.name, async () => {
+        let ops = await component->ReventlessCore.Component.operations->TestRunner.resolve
+        await ops.processPending()
+      })
+      component
+    }
   }
 }

package/src/components/AutomationSlice_Builder.res.mjs

@@ -1,6 +1,9 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
+import * as Component$ReventlessCore from "@reventlessdev/reventless-core/src/components/Component.res.mjs";
+import * as TestRunner$ReventlessLocal from "../test/TestRunner.res.mjs";
 import * as LocalQueryDbStorage$ReventlessLocal from "../adapter/QueryDb/LocalQueryDbStorage.res.mjs";
+import * as LocalAutomationSweep$ReventlessLocal from "./LocalAutomationSweep.res.mjs";
 import * as AutomationSlice_Builder$ReventlessCore from "@reventlessdev/reventless-core/src/components/AutomationSlice/AutomationSlice_Builder.res.mjs";
 import * as LocalRuntimeEnvironment$ReventlessLocal from "../adapter/Runtime/LocalRuntimeEnvironment.res.mjs";
 import * as QueryDbResolvers_GraphQL$ReventlessLocal from "../adapter/QueryDb/QueryDbResolvers_GraphQL.res.mjs";
@@ -34,12 +37,20 @@ function Make(Bus) {
   })(EventCollectorChannel)(EventCollectorRuntimeBuilder)(Api);
   let Make$1 = Spec => (Automation => {
     let Inner = CoreMaker.Make(Spec)(Automation);
+    let make = (allEventTopics, publishJsons, context, runtime, opts) => {
+      let component = Inner.make(allEventTopics, publishJsons, context, runtime, opts);
+      LocalAutomationSweep$ReventlessLocal.register(Spec.name, async () => {
+        let ops = await TestRunner$ReventlessLocal.resolve(Component$ReventlessCore.operations(component));
+        return await ops.processPending();
+      });
+      return component;
+    };
     return {
       Spec: Spec,
       Automation: Automation,
       queryDbName: Inner.queryDbName,
       sourceNames: Inner.sourceNames,
-      make: Inner.make
+      make: make
     };
   });
   return {
@@ -57,4 +68,4 @@ function Make(Bus) {
 export {
   Make,
 }
-/* LocalQueryDbStorage-ReventlessLocal Not a pure module */
+/* Component-ReventlessCore Not a pure module */

package/src/components/LocalAutomationSweep.res

@@ -0,0 +1,61 @@
+// The local platform's automation sweep. As on AWS, one sweep serves every
+// automation: each interval it runs every slice's `processPending`, one after
+// another, so an item `process` left pending or one whose command failed is tried
+// again without waiting for the next event. The interval is five minutes, as on
+// AWS; REVENTLESS_LOCAL_SWEEP_SECONDS shortens it for development.
+
+let defaultIntervalSeconds = 300
+
+let intervalSeconds = () =>
+  switch NodeProcess.env
+  ->Dict.get("REVENTLESS_LOCAL_SWEEP_SECONDS")
+  ->Option.flatMap(s => Int.fromString(s)) {
+  | Some(seconds) if seconds > 0 => seconds
+  | _ => defaultIntervalSeconds
+  }
+
+let sweeps: dict<unit => promise<unit>> = Dict.make()
+let timer: ref<option<NodeTimers.timeout>> = ref(None)
+let running = ref(false)
+
+/** Runs every registered slice's sweep once. A failing slice is logged and the rest still run;
+    a sweep still running when the next one is due is not started twice. */
+let sweepOnce = async () =>
+  if !running.contents {
+    running := true
+    let _ = await sweeps
+    ->Dict.toArray
+    ->Array.reduce(Promise.resolve(), async (previous, (name, sweep)) => {
+      await previous
+      try await sweep() catch {
+      | exn =>
+        let message =
+          exn->JsExn.fromException->Option.flatMap(JsExn.message)->Option.getOr("unknown")
+        ReventlessCore.EffectLogger.logError(
+          ~comp="LocalAutomationSweep",
+          `sweep of ${name} failed: ${message}`,
+        )->Effect.runSync
+      }
+    })
+    running := false
+  }
+
+/** Adds a slice's sweep, replacing one of the same name; the first starts the timer. */
+let register = (~name, sweep) => {
+  sweeps->Dict.set(name, sweep)
+  if timer.contents->Option.isNone {
+    let handle = NodeTimers.setInterval(() => {
+      let _ = sweepOnce()
+    }, intervalSeconds() * 1000)
+    // A backstop: never the reason a process stays up.
+    handle->NodeTimers.unref
+    timer := Some(handle)
+  }
+}
+
+/** Stops the timer and forgets every sweep — call in afterAll/afterEach for test isolation. */
+let reset = () => {
+  timer.contents->Option.forEach(NodeTimers.clearInterval)
+  timer := None
+  sweeps->Dict.keysToArray->Array.forEach(name => sweeps->Dict.delete(name))
+}

package/src/components/LocalAutomationSweep.res.mjs

@@ -0,0 +1,83 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stdlib_Int from "@rescript/runtime/lib/es6/Stdlib_Int.js";
+import * as Stdlib_Dict from "@rescript/runtime/lib/es6/Stdlib_Dict.js";
+import * as Nodetimers from "node:timers";
+import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
+import * as Stdlib_JsExn from "@rescript/runtime/lib/es6/Stdlib_JsExn.js";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Effect from "effect/Effect";
+import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
+import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
+import * as EffectLogger$ReventlessCore from "@reventlessdev/reventless-core/src/util/EffectLogger.res.mjs";
+
+function intervalSeconds() {
+  let seconds = Stdlib_Option.flatMap(process.env["REVENTLESS_LOCAL_SWEEP_SECONDS"], s => Stdlib_Int.fromString(s, undefined));
+  if (seconds !== undefined && seconds > 0) {
+    return seconds;
+  } else {
+    return 300;
+  }
+}
+
+let sweeps = {};
+
+let timer = {
+  contents: undefined
+};
+
+let running = {
+  contents: false
+};
+
+async function sweepOnce() {
+  if (!running.contents) {
+    running.contents = true;
+    await Stdlib_Array.reduce(Object.entries(sweeps), Promise.resolve(), async (previous, param) => {
+      await previous;
+      try {
+        return await param[1]();
+      } catch (raw_exn) {
+        let exn = Primitive_exceptions.internalToException(raw_exn);
+        let message = Stdlib_Option.getOr(Stdlib_Option.flatMap(Stdlib_JsExn.fromException(exn), Stdlib_JsExn.message), "unknown");
+        return Effect.runSync(EffectLogger$ReventlessCore.logError("LocalAutomationSweep", undefined, `sweep of ` + param[0] + ` failed: ` + message));
+      }
+    });
+    running.contents = false;
+    return;
+  }
+}
+
+function register(name, sweep) {
+  sweeps[name] = sweep;
+  if (!Stdlib_Option.isNone(timer.contents)) {
+    return;
+  }
+  let handle = Nodetimers.setInterval(() => {
+    sweepOnce();
+  }, intervalSeconds() * 1000 | 0);
+  handle.unref();
+  timer.contents = Primitive_option.some(handle);
+}
+
+function reset() {
+  Stdlib_Option.forEach(timer.contents, prim => {
+    Nodetimers.clearInterval(prim);
+  });
+  timer.contents = undefined;
+  Object.keys(sweeps).forEach(name => Stdlib_Dict.$$delete(sweeps, name));
+}
+
+let defaultIntervalSeconds = 300;
+
+export {
+  defaultIntervalSeconds,
+  intervalSeconds,
+  sweeps,
+  timer,
+  running,
+  sweepOnce,
+  register,
+  reset,
+}
+/* node:timers Not a pure module */

package/src/test/TestRunner.res

@@ -44,6 +44,7 @@ let resetGraphQLServer = () => DomainGraphQL_Server.reset()
 // Clear all active heartbeat timers started by LocalHeartbeatRunner.
 // Call in afterAll when using Plugin_Builder with LocalHeartbeatRunner.
 let resetHeartbeatRunner = () => LocalHeartbeatRunner.reset()
+let resetAutomationSweep = () => LocalAutomationSweep.reset()
 
 // ─────────────────────────────────────────────────────────────
 // Bus test utilities

package/src/test/TestRunner.res.mjs

@@ -2,6 +2,7 @@
 
 import * as Pulumi from "@pulumi/pulumi";
 import * as DomainGraphQL_Server$ReventlessLocal from "../adapter/DomainGraphQL_Server.res.mjs";
+import * as LocalAutomationSweep$ReventlessLocal from "../components/LocalAutomationSweep.res.mjs";
 import * as LocalHeartbeatRunner$ReventlessLocal from "../adapter/Heartbeat/LocalHeartbeatRunner.res.mjs";
 
 function setup() {
@@ -30,6 +31,10 @@ function resetHeartbeatRunner() {
   LocalHeartbeatRunner$ReventlessLocal.reset();
 }
 
+function resetAutomationSweep() {
+  LocalAutomationSweep$ReventlessLocal.reset();
+}
+
 function collectNEvents(subscribeToEvents, topicName, n) {
   if (n <= 0) {
     return Promise.resolve([]);
@@ -66,6 +71,7 @@ export {
   stopGraphQLServer,
   resetGraphQLServer,
   resetHeartbeatRunner,
+  resetAutomationSweep,
   collectNEvents,
 }
 /* @pulumi/pulumi Not a pure module */