@reventlessdev/reventless-core 3.0.0-alpha.295 → 3.0.0-alpha.296

package/src/plugin/component/Plugin_Builder.res

@@ -382,7 +382,7 @@ module Make = (
     // and idResolver paths). Slice output dicts are keyed by Spec.name; the
     // queryDb name appends a suffix per slice kind:
     //   StateViewSlice           — no suffix
-    //   AutomationSlice          — "Todo"
+    //   AutomationSlice          — "Todo", and "Schedule" when it maps the Clock
     //   OutboundTranslationSlice — "Todo"
     //   InboundTranslationSlice  — "Audit"
     dcbResult.stateViewSlicesOutputs
@@ -393,7 +393,10 @@ module Make = (
     ->Array.forEach(((k, v)) => allQueryDbs->Dict.set(k ++ "Audit", v.queryDb))
     dcbResult.automationSlicesOutputs
     ->Dict.toArray
-    ->Array.forEach(((k, v)) => allQueryDbs->Dict.set(k ++ "Todo", v.queryDb))
+    ->Array.forEach(((k, v)) => {
+      allQueryDbs->Dict.set(k ++ "Todo", v.queryDb)
+      v.schedulesDb->Option.forEach(db => allQueryDbs->Dict.set(k ++ "Schedule", db))
+    })
     dcbResult.outboundTranslationSlicesOutputs
     ->Dict.toArray
     ->Array.forEach(((k, v)) => allQueryDbs->Dict.set(k ++ "Todo", v.queryDb))
@@ -466,9 +469,13 @@ module Make = (
       let extractEventTypes = schema => Reventless.DcbTag.extractVariantNames(schema)
       let routingSchemas: Dict.t<Plugin_Helpers.pluginDeployedSchema> = Dict.make()
       automationSlices->Array.forEach((module(As: ReventlessInfra.AutomationSlice.T)) => {
-        // Union of source-event variants across every per-source mapping.
+        // Union of source-event variants across every per-source mapping. The
+        // Clock's tick is no event of the plugin's; its schedule says when it comes.
         let consumedEventTypes =
           As.Automation.mappings
+          ->Array.filter((module(M: As.Automation.Mapping)) =>
+            M.sourceName != Reventless.Clock.name
+          )
           ->Array.flatMap((module(M: As.Automation.Mapping)) =>
             extractEventTypes(M.sourceEventSchema->S.castToUnknown)
           )

package/src/plugin/component/Plugin_Builder.res.mjs

@@ -6,6 +6,7 @@ import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
 import * as Pulumi from "@pulumi/pulumi";
 import * as Belt_SetString from "@rescript/runtime/lib/es6/Belt_SetString.js";
 import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
+import * as Clock$Reventless from "@reventlessdev/reventless-spec/src/components/Clock.res.mjs";
 import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
 import * as DcbTag$Reventless from "@reventlessdev/reventless-spec/src/components/DcbTag.res.mjs";
 import * as Plugin$Reventless from "@reventlessdev/reventless-spec/src/components/Plugin.res.mjs";
@@ -284,7 +285,12 @@ function Make(Spec) {
           allQueryDbs[param[0] + "Audit"] = param[1].queryDb;
         });
         Object.entries(dcbResult.automationSlicesOutputs).forEach(param => {
-          allQueryDbs[param[0] + "Todo"] = param[1].queryDb;
+          let v = param[1];
+          let k = param[0];
+          allQueryDbs[k + "Todo"] = v.queryDb;
+          Stdlib_Option.forEach(v.schedulesDb, db => {
+            allQueryDbs[k + "Schedule"] = db;
+          });
         });
         Object.entries(dcbResult.outboundTranslationSlicesOutputs).forEach(param => {
           allQueryDbs[param[0] + "Todo"] = param[1].queryDb;
@@ -348,7 +354,7 @@ function Make(Spec) {
         });
         let routingSchemas = {};
         automationSlices.forEach(As => {
-          let consumedEventTypes = Belt_SetString.toArray(Belt_SetString.fromArray(As.Automation.mappings.flatMap(M => DcbTag$Reventless.extractVariantNames(M.sourceEventSchema))));
+          let consumedEventTypes = Belt_SetString.toArray(Belt_SetString.fromArray(As.Automation.mappings.filter(M => M.sourceName !== Clock$Reventless.name).flatMap(M => DcbTag$Reventless.extractVariantNames(M.sourceEventSchema))));
           routingSchemas[As.Spec.name] = {
             consumedEventTypes: consumedEventTypes,
             producedCommandTypes: DcbTag$Reventless.extractAllVariantNames(As.Spec.commandSchema),

package/src/plugin/component/Plugin_Structure.res

@@ -1775,6 +1775,8 @@ let make = (
       // contributes that one source's variants.
       let allConsumedVariants =
         AS.Automation.mappings
+        // The Clock's tick is no event of the plugin's; `schedule` says when it comes.
+        ->Array.filter((module(M: AS.Automation.Mapping)) => M.sourceName != Reventless.Clock.name)
         ->Array.flatMap((module(M: AS.Automation.Mapping)) =>
           eventVariantNames(M.sourceEventSchema->S.castToUnknown)
         )
@@ -1788,6 +1790,11 @@ let make = (
           producedCommandTypes: qualify(~prefix=name, commandVariantNames(AS.Spec.commandSchema)),
           targetName: AS.Spec.targetName,
           chapter: chapterOf(AS.Spec.name),
+          schedule: ?(
+            AS.Spec.schedule->Option.map(time =>
+              time->Reventless.Util_Sury.toJson(Reventless.Schedule.timeSchema)->JSON.stringify
+            )
+          ),
         }: Reventless.Plugin.automationSliceDef
       )
     })

package/src/plugin/component/Plugin_Structure.res.mjs

@@ -6,12 +6,14 @@ import * as Primitive_int from "@rescript/runtime/lib/es6/Primitive_int.js";
 import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
 import * as Belt_SetString from "@rescript/runtime/lib/es6/Belt_SetString.js";
 import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
+import * as Clock$Reventless from "@reventlessdev/reventless-spec/src/components/Clock.res.mjs";
 import * as Owner$Reventless from "@reventlessdev/reventless-spec/src/components/Owner.res.mjs";
 import * as Primitive_object from "@rescript/runtime/lib/es6/Primitive_object.js";
 import * as Primitive_string from "@rescript/runtime/lib/es6/Primitive_string.js";
 import * as Trait$Reventless from "@reventlessdev/reventless-spec/src/types/Trait.res.mjs";
 import * as DcbTag$Reventless from "@reventlessdev/reventless-spec/src/components/DcbTag.res.mjs";
 import * as Message$Reventless from "@reventlessdev/reventless-spec/src/types/Message.res.mjs";
+import * as Schedule$Reventless from "@reventlessdev/reventless-spec/src/types/Schedule.res.mjs";
 import * as Semantic$Reventless from "@reventlessdev/reventless-spec/src/semantic/Semantic.res.mjs";
 import * as Lifecycle$Reventless from "@reventlessdev/reventless-spec/src/types/Lifecycle.res.mjs";
 import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
@@ -1252,13 +1254,14 @@ function make(name, aggregatesOpt, readModelsOpt, stateViewSlicesOpt, stateChang
     };
   });
   let automationSliceDefs = automationSlices.map(AS => {
-    let allConsumedVariants = Belt_SetString.toArray(Belt_SetString.fromArray(AS.Automation.mappings.flatMap(M => DcbTag$Reventless.extractVariantNames(M.sourceEventSchema))));
+    let allConsumedVariants = Belt_SetString.toArray(Belt_SetString.fromArray(AS.Automation.mappings.filter(M => M.sourceName !== Clock$Reventless.name).flatMap(M => DcbTag$Reventless.extractVariantNames(M.sourceEventSchema))));
     return {
       name: AS.Spec.name,
       consumedEventTypes: qualify(name, allConsumedVariants),
       producedCommandTypes: qualify(name, DcbTag$Reventless.extractAllVariantNames(AS.Spec.commandSchema)),
       targetName: AS.Spec.targetName,
-      chapter: componentChapters[AS.Spec.name]
+      chapter: componentChapters[AS.Spec.name],
+      schedule: Stdlib_Option.map(AS.Spec.schedule, time => JSON.stringify(Util_Sury$Reventless.toJson(time, Schedule$Reventless.timeSchema)))
     };
   });
   let outboundTranslationSliceDefs = outboundTranslationSlices.map(OTS => ({

package/tests/admin/AdminApiSchemaDriftTest.res

@@ -120,6 +120,7 @@ let automation: automationSliceDef = {
   producedCommandTypes: ["Restock"],
   targetName: "Product",
   chapter: Some("Replenishment"),
+  schedule: `{"TAG":"Every","_0":{"TAG":"Minutes","_0":15}}`,
 }
 
 let outbound: outboundTranslationSliceDef = {

package/tests/admin/AdminApiSchemaDriftTest.res.mjs

@@ -184,12 +184,15 @@ let automation_producedCommandTypes = ["Restock"];
 
 let automation_chapter = "Replenishment";
 
+let automation_schedule = `{"TAG":"Every","_0":{"TAG":"Minutes","_0":15}}`;
+
 let automation = {
   name: "Restocker",
   consumedEventTypes: automation_consumedEventTypes,
   producedCommandTypes: automation_producedCommandTypes,
   targetName: "Product",
-  chapter: automation_chapter
+  chapter: automation_chapter,
+  schedule: automation_schedule
 };
 
 let outbound_consumedEventTypes = ["OrderPlaced"];

package/tests/automationslice/AutomationSliceSchedulesTest.res

@@ -0,0 +1,143 @@
+// A slice's schedule rows, and how the platform is brought in line with them: the
+// declared time is written unless an event set or cleared the slice-wide key, the
+// platform gets what it is missing and loses what the rows do not hold, and a
+// once-only time already past is not put again.
+
+open JestGlobals
+
+module Schedules = AutomationSlice_Schedules
+
+let at = iso => Date.fromString(iso)->Date.getTime
+let daily6 = Reventless.Schedule.Calendar({calendar: Daily({hour: 6, minute: 0})})
+let daily18 = Reventless.Schedule.Calendar({calendar: Daily({hour: 18, minute: 0})})
+let now = at("2026-10-16T12:00:00Z")
+
+// A platform that holds its schedules in a dict and records what it was told.
+let fakePlatform = (~held: array<string>=[]) => {
+  let schedules = Dict.fromArray(held->Array.map(name => (name, daily6)))
+  let calls = []
+  let platform: ReventlessInfra.AutomationSlice.platformSchedules = {
+    put: async (~key, time) => {
+      calls->Array.push(`put ${key}`)
+      schedules->Dict.set(key, time)
+    },
+    removeName: async name => {
+      calls->Array.push(`remove ${name}`)
+      schedules->Dict.delete(name)
+    },
+    names: async () => schedules->Dict.keysToArray,
+    nameOf: key => key,
+  }
+  (platform, schedules, calls)
+}
+
+let liveKeys = rows =>
+  rows
+  ->Dict.valuesToArray
+  ->Array.filter(row => row.Schedules.time->Option.isSome)
+  ->Array.map(row => row.key)
+  ->Array.toSorted(String.compare)
+
+let set = (rows, key, time, ~recordedAt=now) =>
+  rows->Schedules.apply(Set({key, time}), ~setBy="event", ~recordedAt)
+let clear = (rows, key) => rows->Schedules.apply(Clear({key: key}), ~setBy="event", ~recordedAt=now)
+
+describe("the declared time", () => {
+  testSync("is written when no event has touched the slice-wide key", () => {
+    let rows = Dict.make()
+    rows->Schedules.declare(Some(daily6), ~now)
+    expect(rows->Dict.get("default")->Option.flatMap(Schedules.timeOf))->toEqual(Some(daily6))
+  })
+
+  testSync("does not replace a time an event set", () => {
+    let rows = Dict.make()
+    let _ = rows->set("default", daily18)
+    rows->Schedules.declare(Some(daily6), ~now)
+    expect(rows->Dict.get("default")->Option.flatMap(Schedules.timeOf))->toEqual(Some(daily18))
+  })
+
+  testSync("does not come back after an event cleared it", () => {
+    let rows = Dict.make()
+    rows->Schedules.declare(Some(daily6), ~now)
+    let _ = rows->clear("default")
+    rows->Schedules.declare(Some(daily6), ~now)
+    expect(rows->liveKeys)->toEqual([])
+  })
+
+  testSync("follows a changed declaration, and goes with it", () => {
+    let rows = Dict.make()
+    rows->Schedules.declare(Some(daily6), ~now)
+    rows->Schedules.declare(Some(daily18), ~now)
+    let changed = rows->Dict.get("default")->Option.flatMap(Schedules.timeOf)
+    rows->Schedules.declare(None, ~now)
+    expect((changed, rows->liveKeys))->toEqual((Some(daily18), []))
+  })
+})
+
+describe("a change an event makes", () => {
+  testSync("counts an After from when the event was recorded", () => {
+    let rows = Dict.make()
+    let _ =
+      rows->set("o1", Once({moment: After(Minutes(10))}), ~recordedAt=at("2026-10-16T09:00:00Z"))
+    expect(rows->Dict.get("o1")->Option.flatMap(Schedules.timeOf))->toEqual(
+      Some(
+        Reventless.Schedule.Once({
+          moment: At({year: 2026, month: 10, day: 16, hour: 9, minute: 10}),
+        }),
+      ),
+    )
+  })
+
+  testSync("refuses a time that cannot fire, and changes nothing", () => {
+    let rows = Dict.make()
+    let refused = rows->set("r1", Calendar({calendar: Daily({hour: 25, minute: 0})}))
+    expect((refused->Result.isError, rows->liveKeys))->toEqual((true, []))
+  })
+
+  testSync("removes a once-only schedule when it fires, not a recurring one", () => {
+    let rows = Dict.make()
+    let _ = rows->set("o1", Once({moment: After(Minutes(10))}))
+    let _ = rows->set("r1", daily18)
+    rows->Schedules.fired(~key="o1")
+    rows->Schedules.fired(~key="r1")
+    expect(rows->liveKeys)->toEqual(["r1"])
+  })
+})
+
+describe("the reconcile", () => {
+  testPromise(
+    "puts what the platform is missing and removes what the rows do not hold",
+    async () => {
+      let rows = Dict.make()
+      let _ = rows->set("r1", daily18)
+      let _ = rows->set("r2", daily18)
+      let (platform, held, _) = fakePlatform(~held=["r2", "stray"])
+      await rows->Schedules.reconcile(platform, ~declaredTime=None, ~now)
+      expect(held->Dict.keysToArray->Array.toSorted(String.compare))->toEqual(["r1", "r2"])
+    },
+  )
+
+  testPromise("does not put again a schedule an event set and the platform holds", async () => {
+    let rows = Dict.make()
+    let _ = rows->set("r1", daily18)
+    let (platform, _, calls) = fakePlatform(~held=["r1"])
+    await rows->Schedules.reconcile(platform, ~declaredTime=None, ~now)
+    expect(calls)->toEqual([])
+  })
+
+  testPromise("puts the declared time again, in case it changed", async () => {
+    let rows = Dict.make()
+    let (platform, _, calls) = fakePlatform(~held=["default"])
+    await rows->Schedules.reconcile(platform, ~declaredTime=Some(daily6), ~now)
+    expect(calls)->toEqual(["put default"])
+  })
+
+  testPromise("drops a once-only time already past, from the rows and the platform", async () => {
+    let rows = Dict.make()
+    let _ =
+      rows->set("o1", Once({moment: After(Minutes(10))}), ~recordedAt=at("2026-10-16T09:00:00Z"))
+    let (platform, held, _) = fakePlatform(~held=["o1"])
+    await rows->Schedules.reconcile(platform, ~declaredTime=None, ~now)
+    expect((rows->liveKeys, held->Dict.keysToArray))->toEqual(([], []))
+  })
+})

package/tests/automationslice/AutomationSliceSchedulesTest.res.mjs

@@ -0,0 +1,247 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stdlib_Dict from "@rescript/runtime/lib/es6/Stdlib_Dict.js";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Stdlib_Result from "@rescript/runtime/lib/es6/Stdlib_Result.js";
+import * as Primitive_string from "@rescript/runtime/lib/es6/Primitive_string.js";
+import * as AutomationSlice_Schedules$ReventlessCore from "../../src/components/AutomationSlice/AutomationSlice_Schedules.res.mjs";
+
+function at(iso) {
+  return new Date(iso).getTime();
+}
+
+let daily6 = {
+  TAG: "Calendar",
+  calendar: {
+    TAG: "Daily",
+    hour: 6,
+    minute: 0
+  }
+};
+
+let daily18 = {
+  TAG: "Calendar",
+  calendar: {
+    TAG: "Daily",
+    hour: 18,
+    minute: 0
+  }
+};
+
+let now = new Date("2026-10-16T12:00:00Z").getTime();
+
+function fakePlatform(heldOpt) {
+  let held = heldOpt !== undefined ? heldOpt : [];
+  let schedules = Object.fromEntries(held.map(name => [
+    name,
+    daily6
+  ]));
+  let calls = [];
+  let platform_put = async (key, time) => {
+    calls.push(`put ` + key);
+    schedules[key] = time;
+  };
+  let platform_removeName = async name => {
+    calls.push(`remove ` + name);
+    return Stdlib_Dict.$$delete(schedules, name);
+  };
+  let platform_names = async () => Object.keys(schedules);
+  let platform_nameOf = key => key;
+  let platform = {
+    put: platform_put,
+    removeName: platform_removeName,
+    names: platform_names,
+    nameOf: platform_nameOf
+  };
+  return [
+    platform,
+    schedules,
+    calls
+  ];
+}
+
+function liveKeys(rows) {
+  return Object.values(rows).filter(row => Stdlib_Option.isSome(row.time)).map(row => row.key).toSorted(Primitive_string.compare);
+}
+
+function set(rows, key, time, recordedAtOpt) {
+  let recordedAt = recordedAtOpt !== undefined ? recordedAtOpt : now;
+  return AutomationSlice_Schedules$ReventlessCore.apply(rows, {
+    TAG: "Set",
+    key: key,
+    time: time
+  }, "event", recordedAt);
+}
+
+function clear(rows, key) {
+  return AutomationSlice_Schedules$ReventlessCore.apply(rows, {
+    TAG: "Clear",
+    key: key
+  }, "event", now);
+}
+
+globalThis.describe("the declared time", () => {
+  globalThis.test("is written when no event has touched the slice-wide key", () => {
+    let rows = {};
+    AutomationSlice_Schedules$ReventlessCore.declare(rows, daily6, now);
+    globalThis.expect(Stdlib_Option.flatMap(rows["default"], AutomationSlice_Schedules$ReventlessCore.timeOf)).toEqual(daily6);
+  });
+  globalThis.test("does not replace a time an event set", () => {
+    let rows = {};
+    set(rows, "default", daily18, undefined);
+    AutomationSlice_Schedules$ReventlessCore.declare(rows, daily6, now);
+    globalThis.expect(Stdlib_Option.flatMap(rows["default"], AutomationSlice_Schedules$ReventlessCore.timeOf)).toEqual(daily18);
+  });
+  globalThis.test("does not come back after an event cleared it", () => {
+    let rows = {};
+    AutomationSlice_Schedules$ReventlessCore.declare(rows, daily6, now);
+    clear(rows, "default");
+    AutomationSlice_Schedules$ReventlessCore.declare(rows, daily6, now);
+    globalThis.expect(liveKeys(rows)).toEqual([]);
+  });
+  globalThis.test("follows a changed declaration, and goes with it", () => {
+    let rows = {};
+    AutomationSlice_Schedules$ReventlessCore.declare(rows, daily6, now);
+    AutomationSlice_Schedules$ReventlessCore.declare(rows, daily18, now);
+    let changed = Stdlib_Option.flatMap(rows["default"], AutomationSlice_Schedules$ReventlessCore.timeOf);
+    AutomationSlice_Schedules$ReventlessCore.declare(rows, undefined, now);
+    globalThis.expect([
+      changed,
+      liveKeys(rows)
+    ]).toEqual([
+      daily18,
+      []
+    ]);
+  });
+});
+
+globalThis.describe("a change an event makes", () => {
+  globalThis.test("counts an After from when the event was recorded", () => {
+    let rows = {};
+    set(rows, "o1", {
+      TAG: "Once",
+      moment: {
+        TAG: "After",
+        _0: {
+          TAG: "Minutes",
+          _0: 10
+        }
+      }
+    }, new Date("2026-10-16T09:00:00Z").getTime());
+    globalThis.expect(Stdlib_Option.flatMap(rows["o1"], AutomationSlice_Schedules$ReventlessCore.timeOf)).toEqual({
+      TAG: "Once",
+      moment: {
+        TAG: "At",
+        _0: {
+          year: 2026,
+          month: 10,
+          day: 16,
+          hour: 9,
+          minute: 10
+        }
+      }
+    });
+  });
+  globalThis.test("refuses a time that cannot fire, and changes nothing", () => {
+    let rows = {};
+    let refused = set(rows, "r1", {
+      TAG: "Calendar",
+      calendar: {
+        TAG: "Daily",
+        hour: 25,
+        minute: 0
+      }
+    }, undefined);
+    globalThis.expect([
+      Stdlib_Result.isError(refused),
+      liveKeys(rows)
+    ]).toEqual([
+      true,
+      []
+    ]);
+  });
+  globalThis.test("removes a once-only schedule when it fires, not a recurring one", () => {
+    let rows = {};
+    set(rows, "o1", {
+      TAG: "Once",
+      moment: {
+        TAG: "After",
+        _0: {
+          TAG: "Minutes",
+          _0: 10
+        }
+      }
+    }, undefined);
+    set(rows, "r1", daily18, undefined);
+    AutomationSlice_Schedules$ReventlessCore.fired(rows, "o1");
+    AutomationSlice_Schedules$ReventlessCore.fired(rows, "r1");
+    globalThis.expect(liveKeys(rows)).toEqual(["r1"]);
+  });
+});
+
+globalThis.describe("the reconcile", () => {
+  globalThis.test("puts what the platform is missing and removes what the rows do not hold", async () => {
+    let rows = {};
+    set(rows, "r1", daily18, undefined);
+    set(rows, "r2", daily18, undefined);
+    let match = fakePlatform([
+      "r2",
+      "stray"
+    ]);
+    await AutomationSlice_Schedules$ReventlessCore.reconcile(rows, match[0], undefined, now);
+    globalThis.expect(Object.keys(match[1]).toSorted(Primitive_string.compare)).toEqual([
+      "r1",
+      "r2"
+    ]);
+  });
+  globalThis.test("does not put again a schedule an event set and the platform holds", async () => {
+    let rows = {};
+    set(rows, "r1", daily18, undefined);
+    let match = fakePlatform(["r1"]);
+    await AutomationSlice_Schedules$ReventlessCore.reconcile(rows, match[0], undefined, now);
+    globalThis.expect(match[2]).toEqual([]);
+  });
+  globalThis.test("puts the declared time again, in case it changed", async () => {
+    let rows = {};
+    let match = fakePlatform(["default"]);
+    await AutomationSlice_Schedules$ReventlessCore.reconcile(rows, match[0], daily6, now);
+    globalThis.expect(match[2]).toEqual(["put default"]);
+  });
+  globalThis.test("drops a once-only time already past, from the rows and the platform", async () => {
+    let rows = {};
+    set(rows, "o1", {
+      TAG: "Once",
+      moment: {
+        TAG: "After",
+        _0: {
+          TAG: "Minutes",
+          _0: 10
+        }
+      }
+    }, new Date("2026-10-16T09:00:00Z").getTime());
+    let match = fakePlatform(["o1"]);
+    await AutomationSlice_Schedules$ReventlessCore.reconcile(rows, match[0], undefined, now);
+    globalThis.expect([
+      liveKeys(rows),
+      Object.keys(match[1])
+    ]).toEqual([
+      [],
+      []
+    ]);
+  });
+});
+
+let Schedules;
+
+export {
+  Schedules,
+  at,
+  daily6,
+  daily18,
+  now,
+  fakePlatform,
+  liveKeys,
+  set,
+  clear,
+}
+/* now Not a pure module */