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

package/tests/adapter/ScheduledPublisherTest.res.mjs

@@ -1,8 +1,10 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
 import * as Globals from "@jest/globals";
+import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
 import * as LocalBus$ReventlessLocal from "../../src/adapter/LocalBus.res.mjs";
 import * as TestRunner$ReventlessLocal from "../../src/test/TestRunner.res.mjs";
+import * as ScheduleTime$ReventlessCore from "@reventlessdev/reventless-core/src/util/ScheduleTime.res.mjs";
 import * as LocalScheduledPublisher$ReventlessLocal from "../../src/adapter/Scheduler/LocalScheduledPublisher.res.mjs";
 
 globalThis.beforeAll(() => {
@@ -30,174 +32,274 @@ function makeTopicResource(topicName) {
   };
 }
 
+let hour = 60 * 60000;
+
+let day = 24 * hour;
+
+function at(iso) {
+  return new Date(iso).getTime();
+}
+
+async function flush() {
+  await Promise.resolve();
+  await Promise.resolve();
+}
+
+async function advance(ms) {
+  Globals.jest.advanceTimersByTime(ms);
+  return await flush();
+}
+
+let TestBus = LocalBus$ReventlessLocal.Make({});
+
+let SP = LocalScheduledPublisher$ReventlessLocal.Make(TestBus);
+
+let topicCount = {
+  contents: 0
+};
+
+function fired(topic) {
+  let count = {
+    contents: 0
+  };
+  TestBus.subscribeToEvents(topic, async (param, param$1, param$2) => {
+    count.contents = count.contents + 1 | 0;
+  });
+  return count;
+}
+
+async function schedule(now, time) {
+  Globals.jest.setSystemTime(new Date(now).getTime());
+  topicCount.contents = topicCount.contents + 1 | 0;
+  let topic = `sched-topic-` + topicCount.contents.toString();
+  let count = fired(topic);
+  let ops = await TestRunner$ReventlessLocal.resolve(SP.make("scheduler", {}).operations);
+  await ops.createSchedule([makeTopicResource(topic)], {
+    name: topic,
+    time: time,
+    payload: "{}"
+  });
+  return [
+    ops,
+    topic,
+    count
+  ];
+}
+
 globalThis.describe("LocalScheduledPublisher", () => {
-  globalThis.describe("createSchedule", () => {
-    globalThis.test("single-shot schedule fires event after runAllTimers", async () => {
-      let TestBus = LocalBus$ReventlessLocal.Make({});
-      let SP = LocalScheduledPublisher$ReventlessLocal.Make(TestBus);
-      let count = {
-        contents: 0
-      };
-      TestBus.subscribeToEvents("sched-topic", async (param, param$1, param$2) => {
-        count.contents = count.contents + 1 | 0;
+  globalThis.afterEach(() => SP.reset());
+  globalThis.describe("Every", () => {
+    globalThis.test("fires one interval after it is set, and again each interval", async () => {
+      let match = await schedule("2026-10-16T10:00:00Z", {
+        TAG: "Every",
+        _0: {
+          TAG: "Minutes",
+          _0: 3
+        }
+      });
+      let count = match[2];
+      await advance(3 * 60000 - 1);
+      globalThis.expect(count.contents).toBe(0);
+      await advance(1);
+      globalThis.expect(count.contents).toBe(1);
+      await advance(3 * 60000);
+      globalThis.expect(count.contents).toBe(2);
+    });
+    globalThis.test("Hours(n) fires after n hours", async () => {
+      let match = await schedule("2026-10-16T10:00:00Z", {
+        TAG: "Every",
+        _0: {
+          TAG: "Hours",
+          _0: 2
+        }
+      });
+      await advance(2 * hour);
+      globalThis.expect(match[2].contents).toBe(1);
+    });
+  });
+  globalThis.describe("Calendar", () => {
+    globalThis.test("fires at the wall-clock time each day, not 24 hours after it is set", async () => {
+      let match = await schedule("2026-10-16T05:58:00Z", {
+        TAG: "Calendar",
+        calendar: {
+          TAG: "Daily",
+          hour: 6,
+          minute: 0
+        }
       });
-      let pub = SP.make("scheduler", {});
-      let ops = await TestRunner$ReventlessLocal.resolve(pub.operations);
-      await ops.createSchedule([makeTopicResource("sched-topic")], {
-        name: "one-shot",
-        rate: {
-          TAG: "Single",
-          _0: 2024,
-          _1: 1,
-          _2: 1,
-          _3: 0,
-          _4: 0
+      let count = match[2];
+      await advance(2 * 60000);
+      globalThis.expect(count.contents).toBe(1);
+      await advance(day);
+      globalThis.expect(count.contents).toBe(2);
+    });
+    globalThis.test("skips a day whose time falls in the hour daylight saving skips", async () => {
+      let match = await schedule("2027-03-27T12:00:00Z", {
+        TAG: "Calendar",
+        calendar: {
+          TAG: "Daily",
+          hour: 2,
+          minute: 30
         },
-        payload: "{}"
+        zone: "Europe/Berlin"
+      });
+      let count = match[2];
+      await advance(new Date("2027-03-29T12:00:00Z").getTime() - new Date("2027-03-27T12:00:00Z").getTime());
+      globalThis.expect(count.contents).toBe(1);
+      await advance(new Date("2027-03-30T12:00:00Z").getTime() - new Date("2027-03-29T12:00:00Z").getTime());
+      globalThis.expect(count.contents).toBe(2);
+    });
+    globalThis.test("reaches a firing further away than a timer can wait", async () => {
+      let match = await schedule("2026-10-16T10:00:00Z", {
+        TAG: "Calendar",
+        calendar: {
+          TAG: "Yearly",
+          month: 1,
+          day: 1,
+          hour: 6,
+          minute: 0
+        }
       });
-      Globals.jest.runAllTimers();
-      await Promise.resolve();
-      await Promise.resolve();
+      let count = match[2];
+      await advance(new Date("2027-01-01T05:59:00Z").getTime() - new Date("2026-10-16T10:00:00Z").getTime());
+      globalThis.expect(count.contents).toBe(0);
+      await advance(60000);
+      globalThis.expect(count.contents).toBe(1);
+    });
+  });
+  globalThis.describe("Once", () => {
+    globalThis.test("fires once, a period after it is set", async () => {
+      let match = await schedule("2026-10-16T10:00:00Z", {
+        TAG: "Once",
+        moment: {
+          TAG: "After",
+          _0: {
+            TAG: "Minutes",
+            _0: 10
+          }
+        }
+      });
+      let count = match[2];
+      await advance(10 * 60000);
+      globalThis.expect(count.contents).toBe(1);
+      await advance(day);
       globalThis.expect(count.contents).toBe(1);
-      return SP.reset();
     });
-    globalThis.test("recurring schedule fires on each interval advance", async () => {
-      let TestBus = LocalBus$ReventlessLocal.Make({});
-      let SP = LocalScheduledPublisher$ReventlessLocal.Make(TestBus);
-      let count = {
-        contents: 0
-      };
-      TestBus.subscribeToEvents("repeat-topic", async (param, param$1, param$2) => {
-        count.contents = count.contents + 1 | 0;
+    globalThis.test("never fires at a moment already past", async () => {
+      let match = await schedule("2026-10-16T10:00:00Z", {
+        TAG: "Once",
+        moment: {
+          TAG: "At",
+          _0: {
+            year: 2024,
+            month: 1,
+            day: 1,
+            hour: 0,
+            minute: 0
+          }
+        }
       });
-      let pub = SP.make("scheduler2", {});
-      let ops = await TestRunner$ReventlessLocal.resolve(pub.operations);
-      await ops.createSchedule([makeTopicResource("repeat-topic")], {
-        name: "every-minute",
-        rate: {
+      await advance(day);
+      globalThis.expect(match[2].contents).toBe(0);
+    });
+  });
+  globalThis.describe("createSchedule", () => {
+    globalThis.test("replaces a schedule of the same name", async () => {
+      let match = await schedule("2026-10-16T10:00:00Z", {
+        TAG: "Every",
+        _0: {
           TAG: "Minutes",
           _0: 1
+        }
+      });
+      let topic = match[1];
+      await match[0].createSchedule([makeTopicResource(topic)], {
+        name: topic,
+        time: {
+          TAG: "Every",
+          _0: {
+            TAG: "Minutes",
+            _0: 5
+          }
         },
         payload: "{}"
       });
-      Globals.jest.advanceTimersByTime(60000);
-      await Promise.resolve();
-      await Promise.resolve();
-      Globals.jest.advanceTimersByTime(60000);
-      await Promise.resolve();
-      await Promise.resolve();
-      globalThis.expect(count.contents).toBe(2);
-      return SP.reset();
+      await advance(5 * 60000);
+      globalThis.expect(match[2].contents).toBe(1);
+    });
+    globalThis.test("refuses a time that cannot fire", async () => {
+      let ops = await TestRunner$ReventlessLocal.resolve(SP.make("scheduler", {}).operations);
+      let refused;
+      try {
+        await ops.createSchedule([makeTopicResource("refused")], {
+          name: "refused",
+          time: {
+            TAG: "Calendar",
+            calendar: {
+              TAG: "Daily",
+              hour: 25,
+              minute: 0
+            },
+            zone: "Mars/Base"
+          },
+          payload: "{}"
+        });
+        refused = false;
+      } catch (raw_exn) {
+        let exn = Primitive_exceptions.internalToException(raw_exn);
+        if (exn.RE_EXN_ID === ScheduleTime$ReventlessCore.InvalidTime) {
+          refused = true;
+        } else {
+          throw exn;
+        }
+      }
+      globalThis.expect(refused).toBe(true);
     });
   });
   globalThis.describe("deleteSchedule", () => {
-    globalThis.test("clears a named schedule; advancing timers does not fire it", async () => {
-      let TestBus = LocalBus$ReventlessLocal.Make({});
-      let SP = LocalScheduledPublisher$ReventlessLocal.Make(TestBus);
-      let count = {
-        contents: 0
-      };
-      TestBus.subscribeToEvents("del-topic", async (param, param$1, param$2) => {
-        count.contents = count.contents + 1 | 0;
-      });
-      let pub = SP.make("scheduler3", {});
-      let ops = await TestRunner$ReventlessLocal.resolve(pub.operations);
-      await ops.createSchedule([makeTopicResource("del-topic")], {
-        name: "to-delete",
-        rate: {
+    globalThis.test("stops a schedule; advancing timers does not fire it", async () => {
+      let match = await schedule("2026-10-16T10:00:00Z", {
+        TAG: "Every",
+        _0: {
           TAG: "Minutes",
           _0: 1
-        },
-        payload: "{}"
+        }
       });
-      await ops.deleteSchedule([], "to-delete");
-      Globals.jest.advanceTimersByTime(60000);
-      globalThis.expect(count.contents).toBe(0);
-      return SP.reset();
+      await match[0].deleteSchedule([], match[1]);
+      await advance(60000);
+      globalThis.expect(match[2].contents).toBe(0);
     });
   });
   globalThis.describe("reset", () => {
     globalThis.test("clears all active timers; subsequent advance does not fire", async () => {
-      let TestBus = LocalBus$ReventlessLocal.Make({});
-      let SP = LocalScheduledPublisher$ReventlessLocal.Make(TestBus);
-      let count = {
-        contents: 0
-      };
-      TestBus.subscribeToEvents("reset-topic", async (param, param$1, param$2) => {
-        count.contents = count.contents + 1 | 0;
-      });
-      let pub = SP.make("scheduler4", {});
-      let ops = await TestRunner$ReventlessLocal.resolve(pub.operations);
-      await ops.createSchedule([makeTopicResource("reset-topic")], {
-        name: "reset-sched",
-        rate: {
+      let match = await schedule("2026-10-16T10:00:00Z", {
+        TAG: "Every",
+        _0: {
           TAG: "Minutes",
           _0: 5
-        },
-        payload: "{}"
+        }
       });
       SP.reset();
-      Globals.jest.advanceTimersByTime(300000);
-      globalThis.expect(count.contents).toBe(0);
-    });
-  });
-  globalThis.describe("rateToMs", () => {
-    globalThis.test("Minutes(n) fires after n minutes", async () => {
-      let TestBus = LocalBus$ReventlessLocal.Make({});
-      let SP = LocalScheduledPublisher$ReventlessLocal.Make(TestBus);
-      let count = {
-        contents: 0
-      };
-      TestBus.subscribeToEvents("rate-topic", async (param, param$1, param$2) => {
-        count.contents = count.contents + 1 | 0;
-      });
-      let pub = SP.make("rate-scheduler", {});
-      let ops = await TestRunner$ReventlessLocal.resolve(pub.operations);
-      await ops.createSchedule([makeTopicResource("rate-topic")], {
-        name: "rate-sched",
-        rate: {
-          TAG: "Minutes",
-          _0: 3
-        },
-        payload: "{}"
-      });
-      Globals.jest.advanceTimersByTime(179999);
-      globalThis.expect(count.contents).toBe(0);
-      Globals.jest.advanceTimersByTime(1);
-      await Promise.resolve();
-      await Promise.resolve();
-      globalThis.expect(count.contents).toBe(1);
-      return SP.reset();
-    });
-    globalThis.test("Hours(n) fires after n hours", async () => {
-      let TestBus = LocalBus$ReventlessLocal.Make({});
-      let SP = LocalScheduledPublisher$ReventlessLocal.Make(TestBus);
-      let count = {
-        contents: 0
-      };
-      TestBus.subscribeToEvents("hours-topic", async (param, param$1, param$2) => {
-        count.contents = count.contents + 1 | 0;
-      });
-      let pub = SP.make("hours-scheduler", {});
-      let ops = await TestRunner$ReventlessLocal.resolve(pub.operations);
-      await ops.createSchedule([makeTopicResource("hours-topic")], {
-        name: "hours-sched",
-        rate: {
-          TAG: "Hours",
-          _0: 2
-        },
-        payload: "{}"
-      });
-      Globals.jest.advanceTimersByTime(7200000);
-      await Promise.resolve();
-      await Promise.resolve();
-      globalThis.expect(count.contents).toBe(1);
-      return SP.reset();
+      await advance(5 * 60000);
+      globalThis.expect(match[2].contents).toBe(0);
     });
   });
 });
 
+let minute = 60000;
+
 export {
   makeTopicResource,
+  minute,
+  hour,
+  day,
+  at,
+  flush,
+  advance,
+  TestBus,
+  SP,
+  topicCount,
+  fired,
+  schedule,
 }
 /*  Not a pure module */

package/tests/components/automationslice/AutomationSliceFixtures.res

@@ -106,7 +106,7 @@ module SkipProcessMapping = Reventless.AutomationSlice.Mapping.Make(
 
 module ShipOrderAutomation: Reventless.AutomationSlice.Automation
   with module Spec := ShipOrderSpec = {
-  let process = (id, _item: ShipOrderSpec.todoItem) => Some((
+  let process = (id, _item: ShipOrderSpec.todoItem, ~now as _) => Some((
     id,
     ShipOrderSpec.CreateShipment({orderId: id}),
   ))
@@ -119,7 +119,7 @@ module ShipOrderAutomation: Reventless.AutomationSlice.Automation
 
 module SkipProcessAutomation: Reventless.AutomationSlice.Automation
   with module Spec := SkipProcessSpec = {
-  let process = (_id, _item: SkipProcessSpec.todoItem) => None
+  let process = (_id, _item: SkipProcessSpec.todoItem, ~now as _) => None
   let onExhausted = (_id, _item: SkipProcessSpec.todoItem) => None
   let moduleUrl: string = %raw(`import.meta.url`)
   module M = Reventless.AutomationSlice.Mappings.Make(SkipProcessSpec)

package/tests/components/automationslice/AutomationSliceFixtures.res.mjs

@@ -174,7 +174,7 @@ let SkipProcessMapping = AutomationSlice$Reventless.Mapping.Make({
   resolve: resolve$1
 });
 
-function process(id, _item) {
+function process(id, _item, param) {
   return [
     id,
     {
@@ -201,7 +201,7 @@ let ShipOrderAutomation = {
   mappings: mappings
 };
 
-function process$1(_id, _item) {
+function process$1(_id, _item, param) {
   
 }
 

package/tests/components/automationslice/AutomationSliceSelfDeadlockFixtures.res

@@ -156,7 +156,10 @@ module FromDcb = AutomationSlice.Mapping.Make(
 )
 
 module AutoShipAutomation: AutomationSlice.Automation with module Spec := AutoShipSpec = {
-  let process = (id, _item: AutoShipSpec.todoItem) => Some((id, AutoShipSpec.Ship({orderId: id})))
+  let process = (id, _item: AutoShipSpec.todoItem, ~now as _) => Some((
+    id,
+    AutoShipSpec.Ship({orderId: id}),
+  ))
   let onExhausted = (_id, _item: AutoShipSpec.todoItem) => None
   let moduleUrl: string = %raw(`import.meta.url`)
   module M = AutomationSlice.Mappings.Make(AutoShipSpec)

package/tests/components/automationslice/AutomationSliceSelfDeadlockFixtures.res.mjs

@@ -278,7 +278,7 @@ let FromDcb = AutomationSlice$Reventless.Mapping.Make({
   resolve: resolve
 });
 
-function process(id, _item) {
+function process(id, _item, param) {
   return [
     id,
     {

package/tests/components/automationslice/AutomationSweepFixtures.res

@@ -0,0 +1,129 @@
+// A deadline: `collect` counts when an order is due from the time its event was
+// recorded, and `process` sends nothing until `~now` reaches it. Only a sweep
+// moves the item once its time has come, since no further event arrives. The
+// tests fix the time with Jest's fake Date.
+
+open TestFixtures
+open Reventless
+
+module OrderSource = {
+  module Id = Id.String
+  let name = "DeadlineOrderEventTopic"
+  @schema
+  type event = OrderPlaced({orderId: string, within: float})
+}
+
+module CancelUnshippedSpec = {
+  let name = "CancelUnshipped"
+  let moduleUrl: string = %raw(`import.meta.url`)
+
+  @schema
+  type todoItem = {orderId: string, dueAt: float}
+
+  @schema
+  type command = CancelOrder({orderId: @s.matches(DcbTag.string) string})
+
+  let maxRetries = 2
+  let heartbeatInterval = 60
+  let targetName = "CancelOrder"
+}
+
+module FromOrders = AutomationSlice.Mapping.Make(
+  OrderSource,
+  CancelUnshippedSpec,
+  {
+    let collect = (event: OrderSource.event, ~sourceId as _, ctx: AutomationSlice.context) =>
+      switch (event, ctx.recordedAt) {
+      | (OrderPlaced({orderId, within}), Some(placedAt)) => [
+          (orderId, ({orderId, dueAt: placedAt +. within}: CancelUnshippedSpec.todoItem)),
+        ]
+      | (OrderPlaced(_), None) => []
+      }
+    let resolve = (_event: OrderSource.event) => None
+  },
+)
+
+module CancelUnshippedAutomation: AutomationSlice.Automation
+  with module Spec := CancelUnshippedSpec = {
+  let process = (id, item: CancelUnshippedSpec.todoItem, ~now) =>
+    now >= item.dueAt ? Some((id, CancelUnshippedSpec.CancelOrder({orderId: item.orderId}))) : None
+  let onExhausted = (_id, _item: CancelUnshippedSpec.todoItem) => None
+  let moduleUrl: string = %raw(`import.meta.url`)
+  module M = AutomationSlice.Mappings.Make(CancelUnshippedSpec)
+  module type Mapping = M.Mapping
+  let mappings: array<module(Mapping)> = [module(FromOrders)]
+}
+
+let orderResource: ReventlessInfra.Adapter.resource = ReventlessInfra.Adapter.make(
+  ~name=OrderSource.name->Pulumi.Output.make,
+  ~id=OrderSource.name->Pulumi.Output.make,
+  ~urn=OrderSource.name->Pulumi.Output.make,
+  ~service="memory:InMemory"->Pulumi.Output.make,
+)
+
+let allEventTopics: ReventlessCore.EventTopic.allOutputs = Dict.fromArray([
+  (OrderSource.name, {ReventlessInfra.EventTopic.resources: [orderResource]}),
+])
+
+module Bus = LocalBus.Make()
+let _ = TestRunner.setup()
+
+module AutomationSliceMaker = AutomationSlice_Builder.Make(Bus)
+module CancelUnshipped = AutomationSliceMaker.Make(CancelUnshippedSpec, CancelUnshippedAutomation)
+
+// Commands are captured; `failPublish` makes the next publishes throw.
+let publishedCommands: ref<array<Reventless.Message.commandJson>> = ref([])
+let failPublish = ref(false)
+let publishJsons: ReventlessInfra.CommandTopic.publishJsons = async cmds =>
+  if failPublish.contents {
+    JsError.throwWithMessage("command topic unavailable")
+  } else {
+    publishedCommands := publishedCommands.contents->Array.concat(cmds)
+  }
+
+let slice = CancelUnshipped.make(
+  ~allEventTopics,
+  ~publishJsons=publishJsons->Pulumi.Output.make,
+  ~context={
+    environment: "local",
+    platformName: "local",
+    pluginName: "TestPlugin",
+    sliceName: CancelUnshippedSpec.name,
+  },
+)
+
+/** Places an order now, as the fake Date has it, due `within` milliseconds later. */
+let placeOrder = async (orderId, ~within) => {
+  let meta = {
+    ...makeTestMeta(~service=OrderSource.name),
+    time: Date.now()->Date.fromTime->Date.toISOString,
+  }
+  let eventJson = JSON.Encode.object(
+    Dict.fromArray([
+      ("id", orderId->JSON.Encode.string),
+      ("meta", meta->Reventless.Util_Sury.toJson(Message.metaSchema)),
+      (
+        "event",
+        OrderSource.OrderPlaced({orderId, within})->Reventless.Util_Sury.toJson(
+          OrderSource.eventSchema,
+        ),
+      ),
+    ]),
+  )
+  await Bus.publishEvent(OrderSource.name, "test", meta, eventJson)
+  // The event's own phase 2 runs detached; let it finish.
+  let _ = await Promise.resolve()
+  let _ = await Promise.resolve()
+}
+
+/** The stored to-do row of `id`, as the query store holds it. */
+let storedRow = id =>
+  Bus.getQueryDbScan(CancelUnshipped.queryDbName)
+  ->Option.map(scan => scan())
+  ->Option.getOr([])
+  ->Array.find(row =>
+    row->JSON.Decode.object->Option.flatMap(o => o->Dict.get("id")) == Some(id->JSON.Encode.string)
+  )
+  ->Option.map(row =>
+    row->Reventless.Util_Sury.fromJson(ReventlessCore.AutomationSlice_Callback.todoRowSchema)
+  )