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

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

@@ -0,0 +1,259 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Sury from "sury";
+import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
+import * as Id$Reventless from "@reventlessdev/reventless-spec/src/types/Id.res.mjs";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Pulumi from "@pulumi/pulumi";
+import * as Clock$Reventless from "@reventlessdev/reventless-spec/src/components/Clock.res.mjs";
+import * as Primitive_string from "@rescript/runtime/lib/es6/Primitive_string.js";
+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 Util_Sury$Reventless from "@reventlessdev/reventless-spec/src/util/Util_Sury.res.mjs";
+import * as Adapter$ReventlessInfra from "@reventlessdev/reventless-infra/src/adapter/Adapter.res.mjs";
+import * as LocalBus$ReventlessLocal from "../../../src/adapter/LocalBus.res.mjs";
+import * as AutomationSlice$Reventless from "@reventlessdev/reventless-spec/src/components/AutomationSlice.res.mjs";
+import * as TestRunner$ReventlessLocal from "../../../src/test/TestRunner.res.mjs";
+import * as TestFixtures$ReventlessLocal from "../../TestFixtures.res.mjs";
+import * as AutomationSlice_Builder$ReventlessLocal from "../../../src/components/AutomationSlice_Builder.res.mjs";
+import * as AutomationSlice_Schedules$ReventlessCore from "@reventlessdev/reventless-core/src/components/AutomationSlice/AutomationSlice_Schedules.res.mjs";
+import * as LocalAutomationSchedules$ReventlessLocal from "../../../src/components/LocalAutomationSchedules.res.mjs";
+
+let name = "DigestPreferencesEventTopic";
+
+let eventSchema = Sury.union([
+  Sury.$schema(s => ({
+    TAG: "DigestTimeChosen",
+    recipientId: s.m(Sury.string),
+    time: s.m(Schedule$Reventless.timeSchema)
+  })),
+  Sury.$schema(s => ({
+    TAG: "Unsubscribed",
+    recipientId: s.m(Sury.string)
+  }))
+]);
+
+let PreferencesSource = {
+  Id: undefined,
+  name: name,
+  eventSchema: eventSchema
+};
+
+let name$1 = "LocalDigest";
+
+let moduleUrl = import.meta.url;
+
+let todoItemSchema = Sury.$schema(s => ({
+  recipientId: s.m(Sury.string)
+}));
+
+let commandSchema = Sury.$schema(s => ({
+  TAG: "SendDigest",
+  recipientId: s.m(DcbTag$Reventless.string)
+}));
+
+function authorizationOf(param) {
+  return "AllowAuthenticated";
+}
+
+function commandTransition(param) {
+  return "Undeclared";
+}
+
+let traits = [];
+
+let DigestSpec = {
+  name: name$1,
+  moduleUrl: moduleUrl,
+  todoItemSchema: todoItemSchema,
+  commandSchema: commandSchema,
+  maxRetries: 2,
+  heartbeatInterval: 60,
+  targetName: "SendDigest",
+  schedule: undefined,
+  authorizationOf: authorizationOf,
+  commandTransition: commandTransition,
+  traits: traits
+};
+
+function collect(param, param$1, _ctx) {
+  let key = param.key;
+  return [[
+      Clock$Reventless.itemId(key, param.at),
+      {
+        recipientId: key
+      }
+    ]];
+}
+
+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
+})(DigestSpec)({
+  collect: collect,
+  resolve: resolve,
+  reschedule: reschedule
+});
+
+function collect$1(param, param$1, _ctx) {
+  return [];
+}
+
+function resolve$1(param) {
+  
+}
+
+function reschedule$1(event) {
+  if (event.TAG === "DigestTimeChosen") {
+    return [{
+        TAG: "Set",
+        key: event.recipientId,
+        time: event.time
+      }];
+  } else {
+    return [{
+        TAG: "Clear",
+        key: event.recipientId
+      }];
+  }
+}
+
+let FromPreferences = AutomationSlice$Reventless.Mapping.Make({
+  Id: Id$Reventless.$$String,
+  name: name,
+  eventSchema: eventSchema
+})(DigestSpec)({
+  collect: collect$1,
+  resolve: resolve$1,
+  reschedule: reschedule$1
+});
+
+function process(_id, item, param) {
+  return [
+    item.recipientId,
+    {
+      TAG: "SendDigest",
+      recipientId: item.recipientId
+    }
+  ];
+}
+
+function onExhausted(_id, _item) {
+  
+}
+
+let moduleUrl$1 = import.meta.url;
+
+AutomationSlice$Reventless.Mappings.Make(DigestSpec);
+
+let mappings = [
+  FromClock,
+  FromPreferences
+];
+
+let DigestAutomation = {
+  process: process,
+  onExhausted: onExhausted,
+  moduleUrl: moduleUrl$1,
+  mappings: mappings
+};
+
+let preferencesResource = Adapter$ReventlessInfra.make(Pulumi.output(name), Pulumi.output(name), Pulumi.output(name), Pulumi.output("memory:InMemory"), undefined, undefined, undefined, undefined, undefined, undefined);
+
+let Bus = LocalBus$ReventlessLocal.Make({});
+
+TestRunner$ReventlessLocal.setup();
+
+let AutomationSliceMaker = AutomationSlice_Builder$ReventlessLocal.Make(Bus);
+
+let Digest = AutomationSliceMaker.Make(DigestSpec)(DigestAutomation);
+
+let publishedCommands = {
+  contents: []
+};
+
+async function publishJsons(cmds) {
+  publishedCommands.contents = publishedCommands.contents.concat(cmds);
+}
+
+function makeSlice() {
+  return Digest.make(Object.fromEntries([[
+      name,
+      {
+        resources: [preferencesResource]
+      }
+    ]]), Pulumi.output(publishJsons), {
+    environment: "local",
+    platformName: "local",
+    pluginName: "TestPlugin",
+    sliceName: name$1
+  }, undefined, undefined);
+}
+
+function eventJson(event, recipientId) {
+  let newrecord = {...TestFixtures$ReventlessLocal.makeTestMeta(name)};
+  newrecord.time = new Date(Date.now()).toISOString();
+  return [
+    newrecord,
+    Object.fromEntries([
+      [
+        "id",
+        recipientId
+      ],
+      [
+        "meta",
+        Util_Sury$Reventless.toJson(newrecord, Message$Reventless.metaSchema)
+      ],
+      [
+        "event",
+        Util_Sury$Reventless.toJson(event, eventSchema)
+      ]
+    ])
+  ];
+}
+
+async function publish(event, recipientId) {
+  let match = eventJson(event, recipientId);
+  return await Bus.publishEvent(name, "test", match[0], match[1]);
+}
+
+function storedSchedules() {
+  return Stdlib_Array.filterMap(Stdlib_Option.getOr(Stdlib_Option.map(Bus.getQueryDbScan(Stdlib_Option.getOr(Digest.schedulesDbName, "")), scan => scan()), []).map(row => Util_Sury$Reventless.fromJson(row, AutomationSlice_Schedules$ReventlessCore.rowSchema)), row => Stdlib_Option.map(AutomationSlice_Schedules$ReventlessCore.timeOf(row), t => [
+    row.key,
+    t
+  ])).toSorted((param, param$1) => Primitive_string.compare(param[0], param$1[0]));
+}
+
+function timers() {
+  return LocalAutomationSchedules$ReventlessLocal.platformFor(name$1).names();
+}
+
+export {
+  PreferencesSource,
+  DigestSpec,
+  FromClock,
+  FromPreferences,
+  DigestAutomation,
+  preferencesResource,
+  Bus,
+  AutomationSliceMaker,
+  Digest,
+  publishedCommands,
+  publishJsons,
+  makeSlice,
+  eventJson,
+  publish,
+  storedSchedules,
+  timers,
+}
+/* eventSchema Not a pure module */

package/tests/components/automationslice/AutomationRescheduleTest.res

@@ -0,0 +1,96 @@
+// Schedules set by events, on the local platform: a recipient's choice is stored and
+// starts their timer, the timer's tick sends their digest, unsubscribing removes
+// both, and a rebuild from the events reproduces the rows and removes a stray timer.
+
+open JestGlobals
+open AutomationRescheduleFixtures
+
+type jestObj
+@module("@jest/globals") external jest: jestObj = "jest"
+@send external useFakeTimers: jestObj => unit = "useFakeTimers"
+@send external useRealTimers: jestObj => unit = "useRealTimers"
+@send external setSystemTime: (jestObj, float) => unit = "setSystemTime"
+@send
+external advanceTimersByTimeAsync: (jestObj, float) => promise<unit> = "advanceTimersByTimeAsync"
+
+let time = iso => Date.fromString(iso)->Date.getTime
+let at18 = Reventless.Schedule.Calendar({calendar: Daily({hour: 18, minute: 0})})
+let at19Berlin = Reventless.Schedule.Calendar({
+  calendar: Daily({hour: 19, minute: 0}),
+  zone: "Europe/Berlin",
+})
+
+let settle = async () =>
+  for _ in 1 to 20 {
+    await jest->advanceTimersByTimeAsync(0.)
+  }
+
+let sorted = keys => keys->Array.toSorted(String.compare)
+
+describe("schedules set by events, locally", () => {
+  let slice = ref(None)
+  let ops = async () =>
+    await slice.contents->Option.getOrThrow->ReventlessCore.Component.operations->TestRunner.resolve
+
+  let _ = beforeAllAsync(async () => {
+    jest->useFakeTimers
+    jest->setSystemTime(time("2026-10-16T12:00:00Z"))
+    slice := Some(makeSlice())
+    let _ = await ops()
+    await settle()
+  })
+  let _ = afterAll(() => {
+    LocalAutomationSchedules.reset()
+    jest->useRealTimers
+  })
+
+  testPromise("a choice is stored and starts the recipient's timer", async () => {
+    await publish(DigestTimeChosen({recipientId: "r1", time: at18}), ~recipientId="r1")
+    await publish(DigestTimeChosen({recipientId: "r2", time: at19Berlin}), ~recipientId="r2")
+    await settle()
+    expect((storedSchedules(), (await timers())->sorted))->toEqual((
+      [("r1", at18), ("r2", at19Berlin)],
+      ["r1", "r2"],
+    ))
+  })
+
+  testPromise("each recipient's tick comes at their own time and sends their digest", async () => {
+    // 18:00 UTC is r1's; 19:00 in Berlin is 17:00 UTC, r2's.
+    await jest->advanceTimersByTimeAsync(5. *. 3_600_000. +. 1_000.)
+    await settle()
+    expect(publishedCommands.contents->Array.map(c => c.id))->toEqual(["r2"])
+    await jest->advanceTimersByTimeAsync(3_600_000.)
+    await settle()
+    // Nothing answers r2's command here, so 18:00's pass, an hour on, sends it again.
+    expect(publishedCommands.contents->Array.map(c => c.id))->toEqual(["r2", "r2", "r1"])
+  })
+
+  testPromise("unsubscribing removes the recipient's row and timer, and only theirs", async () => {
+    await publish(Unsubscribed({recipientId: "r1"}), ~recipientId="r1")
+    await settle()
+    expect((storedSchedules(), await timers()))->toEqual(([("r2", at19Berlin)], ["r2"]))
+  })
+
+  testPromise("a later reconcile keeps the times events set", async () => {
+    let ops = await ops()
+    await ops.reconcileSchedules()
+    expect((storedSchedules(), await timers()))->toEqual(([("r2", at19Berlin)], ["r2"]))
+  })
+
+  testPromise(
+    "a rebuild reproduces the rows from the events and removes a stray timer",
+    async () => {
+      let platform = LocalAutomationSchedules.platformFor(~slice=DigestSpec.name)
+      await platform.put(~key="stray", at18)
+      let events =
+        [
+          eventJson(DigestTimeChosen({recipientId: "r1", time: at18}), ~recipientId="r1"),
+          eventJson(DigestTimeChosen({recipientId: "r3", time: at19Berlin}), ~recipientId="r3"),
+          eventJson(Unsubscribed({recipientId: "r1"}), ~recipientId="r1"),
+        ]->Array.map(((_, json)) => json)
+      let ops = await ops()
+      await ops.rebuildSchedules(events)
+      expect((storedSchedules(), (await timers())->sorted))->toEqual(([("r3", at19Berlin)], ["r3"]))
+    },
+  )
+})

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

@@ -0,0 +1,177 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Globals from "@jest/globals";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.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 Component$ReventlessCore from "@reventlessdev/reventless-core/src/components/Component.res.mjs";
+import * as TestRunner$ReventlessLocal from "../../../src/test/TestRunner.res.mjs";
+import * as LocalAutomationSchedules$ReventlessLocal from "../../../src/components/LocalAutomationSchedules.res.mjs";
+import * as AutomationRescheduleFixtures$ReventlessLocal from "./AutomationRescheduleFixtures.res.mjs";
+
+function time(iso) {
+  return new Date(iso).getTime();
+}
+
+let at18 = {
+  TAG: "Calendar",
+  calendar: {
+    TAG: "Daily",
+    hour: 18,
+    minute: 0
+  }
+};
+
+let at19Berlin = {
+  TAG: "Calendar",
+  calendar: {
+    TAG: "Daily",
+    hour: 19,
+    minute: 0
+  },
+  zone: "Europe/Berlin"
+};
+
+async function settle() {
+  for (let _for = 1; _for <= 20; ++_for) {
+    await Globals.jest.advanceTimersByTimeAsync(0);
+  }
+}
+
+function sorted(keys) {
+  return keys.toSorted(Primitive_string.compare);
+}
+
+globalThis.describe("schedules set by events, locally", () => {
+  let slice = {
+    contents: undefined
+  };
+  let ops = async () => await TestRunner$ReventlessLocal.resolve(Component$ReventlessCore.operations(Stdlib_Option.getOrThrow(slice.contents, undefined)));
+  globalThis.beforeAll(async () => {
+    Globals.jest.useFakeTimers();
+    Globals.jest.setSystemTime(new Date("2026-10-16T12:00:00Z").getTime());
+    slice.contents = Primitive_option.some(AutomationRescheduleFixtures$ReventlessLocal.makeSlice());
+    await ops();
+    return await settle();
+  });
+  globalThis.afterAll(() => {
+    LocalAutomationSchedules$ReventlessLocal.reset();
+    Globals.jest.useRealTimers();
+  });
+  globalThis.test("a choice is stored and starts the recipient's timer", async () => {
+    await AutomationRescheduleFixtures$ReventlessLocal.publish({
+      TAG: "DigestTimeChosen",
+      recipientId: "r1",
+      time: at18
+    }, "r1");
+    await AutomationRescheduleFixtures$ReventlessLocal.publish({
+      TAG: "DigestTimeChosen",
+      recipientId: "r2",
+      time: at19Berlin
+    }, "r2");
+    await settle();
+    globalThis.expect([
+      AutomationRescheduleFixtures$ReventlessLocal.storedSchedules(),
+      sorted(await AutomationRescheduleFixtures$ReventlessLocal.timers())
+    ]).toEqual([
+      [
+        [
+          "r1",
+          at18
+        ],
+        [
+          "r2",
+          at19Berlin
+        ]
+      ],
+      [
+        "r1",
+        "r2"
+      ]
+    ]);
+  });
+  globalThis.test("each recipient's tick comes at their own time and sends their digest", async () => {
+    await Globals.jest.advanceTimersByTimeAsync(5 * 3600000 + 1000);
+    await settle();
+    globalThis.expect(AutomationRescheduleFixtures$ReventlessLocal.publishedCommands.contents.map(c => c.id)).toEqual(["r2"]);
+    await Globals.jest.advanceTimersByTimeAsync(3600000);
+    await settle();
+    globalThis.expect(AutomationRescheduleFixtures$ReventlessLocal.publishedCommands.contents.map(c => c.id)).toEqual([
+      "r2",
+      "r2",
+      "r1"
+    ]);
+  });
+  globalThis.test("unsubscribing removes the recipient's row and timer, and only theirs", async () => {
+    await AutomationRescheduleFixtures$ReventlessLocal.publish({
+      TAG: "Unsubscribed",
+      recipientId: "r1"
+    }, "r1");
+    await settle();
+    globalThis.expect([
+      AutomationRescheduleFixtures$ReventlessLocal.storedSchedules(),
+      await AutomationRescheduleFixtures$ReventlessLocal.timers()
+    ]).toEqual([
+      [[
+          "r2",
+          at19Berlin
+        ]],
+      ["r2"]
+    ]);
+  });
+  globalThis.test("a later reconcile keeps the times events set", async () => {
+    let ops$1 = await ops();
+    await ops$1.reconcileSchedules();
+    globalThis.expect([
+      AutomationRescheduleFixtures$ReventlessLocal.storedSchedules(),
+      await AutomationRescheduleFixtures$ReventlessLocal.timers()
+    ]).toEqual([
+      [[
+          "r2",
+          at19Berlin
+        ]],
+      ["r2"]
+    ]);
+  });
+  globalThis.test("a rebuild reproduces the rows from the events and removes a stray timer", async () => {
+    let platform = LocalAutomationSchedules$ReventlessLocal.platformFor(AutomationRescheduleFixtures$ReventlessLocal.DigestSpec.name);
+    await platform.put("stray", at18);
+    let events = [
+      AutomationRescheduleFixtures$ReventlessLocal.eventJson({
+        TAG: "DigestTimeChosen",
+        recipientId: "r1",
+        time: at18
+      }, "r1"),
+      AutomationRescheduleFixtures$ReventlessLocal.eventJson({
+        TAG: "DigestTimeChosen",
+        recipientId: "r3",
+        time: at19Berlin
+      }, "r3"),
+      AutomationRescheduleFixtures$ReventlessLocal.eventJson({
+        TAG: "Unsubscribed",
+        recipientId: "r1"
+      }, "r1")
+    ].map(param => param[1]);
+    let ops$1 = await ops();
+    await ops$1.rebuildSchedules(events);
+    globalThis.expect([
+      AutomationRescheduleFixtures$ReventlessLocal.storedSchedules(),
+      sorted(await AutomationRescheduleFixtures$ReventlessLocal.timers())
+    ]).toEqual([
+      [[
+          "r3",
+          at19Berlin
+        ]],
+      ["r3"]
+    ]);
+  });
+});
+
+export {
+  time,
+  at18,
+  at19Berlin,
+  settle,
+  sorted,
+}
+/*  Not a pure module */

package/tests/components/automationslice/AutomationScheduleFixtures.res

@@ -0,0 +1,118 @@
+// A declared schedule: the demand report every morning at 06:00 UTC. Its one
+// mapping reads the framework's Clock source; each tick makes the day's item and
+// `process` requests the report. The slice is made by `makeSlice`, not at import, so
+// a test can fix the time its schedule is set at.
+
+open Reventless
+
+module DemandReportSpec = {
+  let name = "LocalDemandReport"
+  let moduleUrl: string = %raw(`import.meta.url`)
+
+  @schema
+  type todoItem = {day: float}
+
+  @schema
+  type command = RequestDemandReport({day: float})
+
+  let maxRetries = 2
+  let heartbeatInterval = 60
+  let targetName = "ReportSettings"
+  let schedule = Some(Schedule.Calendar({calendar: Daily({hour: 6, minute: 0})}))
+}
+
+module FromClock = AutomationSlice.Mapping.Make(
+  Clock,
+  DemandReportSpec,
+  {
+    open Clock
+    let collect = (Tick({key, at}), ~sourceId as _, _ctx) => [
+      (itemId(key, at), ({day: at}: DemandReportSpec.todoItem)),
+    ]
+    let resolve = _ => None
+    let reschedule = _ => []
+  },
+)
+
+module DemandReportAutomation: AutomationSlice.Automation with module Spec := DemandReportSpec = {
+  let process = (id, item: DemandReportSpec.todoItem, ~now as _) => Some((
+    id,
+    DemandReportSpec.RequestDemandReport({day: item.day}),
+  ))
+  let onExhausted = (_id, _item: DemandReportSpec.todoItem) => None
+  let moduleUrl: string = %raw(`import.meta.url`)
+  module M = AutomationSlice.Mappings.Make(DemandReportSpec)
+  module type Mapping = M.Mapping
+  let mappings: array<module(Mapping)> = [module(FromClock)]
+}
+
+// The same slice with its schedule left out: nothing would ever tick it.
+module UnscheduledSpec = {
+  include DemandReportSpec
+  let name = "LocalUnscheduledReport"
+  let schedule: option<Schedule.time> = None
+}
+
+module FromClockUnscheduled = AutomationSlice.Mapping.Make(
+  Clock,
+  UnscheduledSpec,
+  {
+    let collect = (_, ~sourceId as _, _ctx) => []
+    let resolve = _ => None
+    let reschedule = _ => []
+  },
+)
+
+module UnscheduledAutomation: AutomationSlice.Automation with module Spec := UnscheduledSpec = {
+  let process = (_id, _item: UnscheduledSpec.todoItem, ~now as _) => None
+  let onExhausted = (_id, _item: UnscheduledSpec.todoItem) => None
+  let moduleUrl: string = %raw(`import.meta.url`)
+  module M = AutomationSlice.Mappings.Make(UnscheduledSpec)
+  module type Mapping = M.Mapping
+  let mappings: array<module(Mapping)> = [module(FromClockUnscheduled)]
+}
+
+module Bus = LocalBus.Make()
+let _ = TestRunner.setup()
+
+module AutomationSliceMaker = AutomationSlice_Builder.Make(Bus)
+module DemandReport = AutomationSliceMaker.Make(DemandReportSpec, DemandReportAutomation)
+module Unscheduled = AutomationSliceMaker.Make(UnscheduledSpec, UnscheduledAutomation)
+
+let publishedCommands: ref<array<Reventless.Message.commandJson>> = ref([])
+let publishJsons: ReventlessInfra.CommandTopic.publishJsons = async cmds =>
+  publishedCommands := publishedCommands.contents->Array.concat(cmds)
+
+let context = (sliceName): AutomationSlice.context => {
+  environment: "local",
+  platformName: "local",
+  pluginName: "TestPlugin",
+  sliceName,
+}
+
+/** Makes the demand report, which starts its declared schedule at the current time. */
+let makeSlice = () =>
+  DemandReport.make(
+    ~allEventTopics=Dict.make(),
+    ~publishJsons=publishJsons->Pulumi.Output.make,
+    ~context=context(DemandReportSpec.name),
+  )
+
+let makeUnscheduled = () =>
+  Unscheduled.make(
+    ~allEventTopics=Dict.make(),
+    ~publishJsons=publishJsons->Pulumi.Output.make,
+    ~context=context(UnscheduledSpec.name),
+  )
+
+/** The stored to-do row of `id`, as the query store holds it. */
+let storedRow = id =>
+  Bus.getQueryDbScan(DemandReport.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)
+  )