@reventlessdev/reventless-aws 3.0.0-alpha.381 → 3.0.0-alpha.383

package/tests/AutomationSliceEntryPoint_OpsTest.res

@@ -224,6 +224,9 @@ describe("AutomationSliceEntryPoint_Ops.makeAutomationJsonEventsHandler", () =>
         steps->Array.push("phase1")
       },
       phase2: async _publish => steps->Array.push("phase2"),
+      schedules: Dict.make(),
+      takeScheduleChanges: () => [],
+      rebuildSchedules: _ => (),
     }
     let context: Reventless.AutomationSlice.context = {
       environment: "test",
@@ -250,6 +253,50 @@ describe("AutomationSliceEntryPoint_Ops.makeAutomationJsonEventsHandler", () =>
     // the reloaded backlog unprocessed until another invocation.
     expect(steps)->toEqual(["restore", "phase1", "sync", "phase2", "sync"])
   })
+
+  // The rows are the truth: a platform told before they are stored could hold a
+  // schedule no row knows of, if the store write then failed.
+  test("stores a changed schedule's rows before telling the platform", async () => {
+    let steps = []
+    let daily = Reventless.Schedule.Calendar({calendar: Daily({hour: 6, minute: 0})})
+    let callback: AutomationSliceEntryPoint_Ops.automationCallback = {
+      todoItems: Dict.make(),
+      phase1: (_jsons, _ctx) => steps->Array.push("phase1"),
+      phase2: async _publish => steps->Array.push("phase2"),
+      schedules: Dict.make(),
+      takeScheduleChanges: () => [Put({key: "r1", time: daily})],
+      rebuildSchedules: _ => (),
+    }
+    let schedules: AutomationSliceEntryPoint_Ops.schedulesStep = {
+      load: async () => steps->Array.push("load schedules"),
+      sync: async () => steps->Array.push("sync schedules"),
+      platform: {
+        put: async (~key, _) => steps->Array.push(`put ${key}`),
+        removeName: async name => steps->Array.push(`remove ${name}`),
+        names: async () => [],
+        nameOf: key => key,
+      },
+    }
+    let handler = AutomationSliceEntryPoint_Ops.makeAutomationJsonEventsHandler(
+      ~context={environment: "test", platformName: "P", pluginName: "Pl", sliceName: "S"},
+      ~callback,
+      ~publishJsons=noopPublish,
+      ~syncTodoItems=async () => steps->Array.push("sync"),
+      ~loadTodoItems=async () => steps->Array.push("restore"),
+      ~schedules=() => Some(schedules),
+    )
+    await Stream.fromIterable([str("e")])->handler->Effect.runPromise
+    expect(steps)->toEqual([
+      "restore",
+      "load schedules",
+      "phase1",
+      "sync",
+      "sync schedules",
+      "put r1",
+      "phase2",
+      "sync",
+    ])
+  })
 })
 
 describe("AutomationSliceEntryPoint_Ops.runSweeps", () => {
@@ -260,6 +307,9 @@ describe("AutomationSliceEntryPoint_Ops.runSweeps", () => {
     registered: dummyRegistered,
     sweep: run,
     comp,
+    name: comp,
+    tick: None,
+    reconcile: None,
   }
 
   test("sweeps every slice", async () => {
@@ -285,6 +335,47 @@ describe("AutomationSliceEntryPoint_Ops.runSweeps", () => {
   })
 })
 
+describe("AutomationSliceEntryPoint_Ops.runTick", () => {
+  let dummyRegistered: StreamRoutedEntryPoint_Ops.registeredHandler = {
+    handler: (_event, _context) => Effect.succeed(),
+  }
+  let ticks = []
+  let slice = (~name, ~tick): AutomationSliceEntryPoint_Ops.builtSlice => {
+    registered: dummyRegistered,
+    sweep: async () => (),
+    comp: name,
+    name,
+    tick,
+    reconcile: None,
+  }
+  let slices = [
+    slice(~name="Outbound", ~tick=None),
+    slice(~name="DemandReport", ~tick=Some(async (~key, ~at) => ticks->Array.push((key, at)))),
+  ]
+
+  test("delivers the scheduled time to the named slice", async () => {
+    await AutomationSliceEntryPoint_Ops.runTick(
+      slices,
+      {slice: "DemandReport", key: "default", at: "2026-10-16T06:00:00Z"},
+    )
+    expect(ticks)->toEqual([("default", Date.fromString("2026-10-16T06:00:00Z")->Date.getTime)])
+  })
+
+  // A throw makes the Scheduler retry, and leaves a log line to find.
+  test("refuses a slice it does not host, or one that maps no Clock", async () => {
+    let refused = async invocation =>
+      switch await AutomationSliceEntryPoint_Ops.runTick(slices, invocation) {
+      | () => false
+      | exception _ => true
+      }
+    expect(await refused({slice: "Nobody", key: "default", at: "2026-10-16T06:00:00Z"}))->toBe(true)
+    expect(await refused({slice: "Outbound", key: "default", at: "2026-10-16T06:00:00Z"}))->toBe(
+      true,
+    )
+    expect(await refused({slice: "DemandReport", key: "default", at: "soon"}))->toBe(true)
+  })
+})
+
 // Consumed-event fixture for the outbound decode: one consumed variant with a
 // payload, one payload-less, decoded from a source that also emits types this
 // slice does not consume.

package/tests/AutomationSliceEntryPoint_OpsTest.res.mjs

@@ -328,10 +328,16 @@ globalThis.describe("AutomationSliceEntryPoint_Ops.makeAutomationJsonEventsHandl
     let callback_phase2 = async _publish => {
       steps.push("phase2");
     };
+    let callback_schedules = {};
+    let callback_takeScheduleChanges = () => [];
+    let callback_rebuildSchedules = param => {};
     let callback = {
       todoItems: callback_todoItems,
       phase1: callback_phase1,
-      phase2: callback_phase2
+      phase2: callback_phase2,
+      schedules: callback_schedules,
+      takeScheduleChanges: callback_takeScheduleChanges,
+      rebuildSchedules: callback_rebuildSchedules
     };
     let handler = AutomationSliceEntryPoint_Ops$ReventlessAws.makeAutomationJsonEventsHandler({
       environment: "test",
@@ -342,7 +348,7 @@ globalThis.describe("AutomationSliceEntryPoint_Ops.makeAutomationJsonEventsHandl
       steps.push("sync");
     }, async () => {
       steps.push("restore");
-    });
+    }, undefined);
     let envelope = Object.fromEntries([
       [
         "meta",
@@ -373,6 +379,80 @@ globalThis.describe("AutomationSliceEntryPoint_Ops.makeAutomationJsonEventsHandl
       "sync"
     ]);
   });
+  globalThis.test("stores a changed schedule's rows before telling the platform", async () => {
+    let steps = [];
+    let callback_todoItems = {};
+    let callback_phase1 = (_jsons, _ctx) => {
+      steps.push("phase1");
+    };
+    let callback_phase2 = async _publish => {
+      steps.push("phase2");
+    };
+    let callback_schedules = {};
+    let callback_takeScheduleChanges = () => [{
+        TAG: "Put",
+        key: "r1",
+        time: {
+          TAG: "Calendar",
+          calendar: {
+            TAG: "Daily",
+            hour: 6,
+            minute: 0
+          }
+        }
+      }];
+    let callback_rebuildSchedules = param => {};
+    let callback = {
+      todoItems: callback_todoItems,
+      phase1: callback_phase1,
+      phase2: callback_phase2,
+      schedules: callback_schedules,
+      takeScheduleChanges: callback_takeScheduleChanges,
+      rebuildSchedules: callback_rebuildSchedules
+    };
+    let schedules_load = async () => {
+      steps.push("load schedules");
+    };
+    let schedules_sync = async () => {
+      steps.push("sync schedules");
+    };
+    let schedules_platform = {
+      put: async (key, param) => {
+        steps.push(`put ` + key);
+      },
+      removeName: async name => {
+        steps.push(`remove ` + name);
+      },
+      names: async () => [],
+      nameOf: key => key
+    };
+    let schedules = {
+      load: schedules_load,
+      sync: schedules_sync,
+      platform: schedules_platform
+    };
+    let handler = AutomationSliceEntryPoint_Ops$ReventlessAws.makeAutomationJsonEventsHandler({
+      environment: "test",
+      platformName: "P",
+      pluginName: "Pl",
+      sliceName: "S"
+    }, callback, noopPublish, async () => {
+      steps.push("sync");
+    }, async () => {
+      steps.push("restore");
+    }, () => schedules);
+    await Effect.runPromise(handler(Stream.fromIterable(["e"])));
+    globalThis.expect(steps).toEqual([
+      "restore",
+      "load schedules",
+      "phase1",
+      "sync",
+      "sync schedules",
+      "put r1",
+      "phase2",
+      "sync"
+    ]);
+  });
 });
 
 globalThis.describe("AutomationSliceEntryPoint_Ops.runSweeps", () => {
@@ -380,23 +460,23 @@ globalThis.describe("AutomationSliceEntryPoint_Ops.runSweeps", () => {
   let dummyRegistered = {
     handler: dummyRegistered_handler
   };
+  let sliceThat = (comp, run) => ({
+    registered: dummyRegistered,
+    sweep: run,
+    comp: comp,
+    name: comp,
+    tick: undefined,
+    reconcile: undefined
+  });
   globalThis.test("sweeps every slice", async () => {
     let swept = [];
     await AutomationSliceEntryPoint_Ops$ReventlessAws.runSweeps([
-      {
-        registered: dummyRegistered,
-        sweep: async () => {
-          swept.push("a");
-        },
-        comp: "A"
-      },
-      {
-        registered: dummyRegistered,
-        sweep: async () => {
-          swept.push("b");
-        },
-        comp: "B"
-      }
+      sliceThat("A", async () => {
+        swept.push("a");
+      }),
+      sliceThat("B", async () => {
+        swept.push("b");
+      })
     ]);
     globalThis.expect(swept).toEqual([
       "a",
@@ -406,25 +486,13 @@ globalThis.describe("AutomationSliceEntryPoint_Ops.runSweeps", () => {
   globalThis.test("a throwing slice does not stop the others", async () => {
     let swept = [];
     await AutomationSliceEntryPoint_Ops$ReventlessAws.runSweeps([
-      {
-        registered: dummyRegistered,
-        sweep: async () => {
-          swept.push("a");
-        },
-        comp: "A"
-      },
-      {
-        registered: dummyRegistered,
-        sweep: async () => Stdlib_JsError.throwWithMessage("gateway down"),
-        comp: "Boom"
-      },
-      {
-        registered: dummyRegistered,
-        sweep: async () => {
-          swept.push("c");
-        },
-        comp: "C"
-      }
+      sliceThat("A", async () => {
+        swept.push("a");
+      }),
+      sliceThat("Boom", async () => Stdlib_JsError.throwWithMessage("gateway down")),
+      sliceThat("C", async () => {
+        swept.push("c");
+      })
     ]);
     globalThis.expect(swept).toEqual([
       "a",
@@ -433,6 +501,74 @@ globalThis.describe("AutomationSliceEntryPoint_Ops.runSweeps", () => {
   });
 });
 
+globalThis.describe("AutomationSliceEntryPoint_Ops.runTick", () => {
+  let dummyRegistered_handler = (_event, _context) => Effect.succeed();
+  let dummyRegistered = {
+    handler: dummyRegistered_handler
+  };
+  let ticks = [];
+  let slice = (name, tick) => ({
+    registered: dummyRegistered,
+    sweep: async () => {},
+    comp: name,
+    name: name,
+    tick: tick,
+    reconcile: undefined
+  });
+  let slices = [
+    {
+      registered: dummyRegistered,
+      sweep: async () => {},
+      comp: "Outbound",
+      name: "Outbound",
+      tick: undefined,
+      reconcile: undefined
+    },
+    slice("DemandReport", async (key, at) => {
+      ticks.push([
+        key,
+        at
+      ]);
+    })
+  ];
+  globalThis.test("delivers the scheduled time to the named slice", async () => {
+    await AutomationSliceEntryPoint_Ops$ReventlessAws.runTick(slices, {
+      slice: "DemandReport",
+      key: "default",
+      at: "2026-10-16T06:00:00Z"
+    });
+    globalThis.expect(ticks).toEqual([[
+        "default",
+        new Date("2026-10-16T06:00:00Z").getTime()
+      ]]);
+  });
+  globalThis.test("refuses a slice it does not host, or one that maps no Clock", async () => {
+    let refused = async invocation => {
+      try {
+        await AutomationSliceEntryPoint_Ops$ReventlessAws.runTick(slices, invocation);
+        return false;
+      } catch (exn) {
+        return true;
+      }
+    };
+    globalThis.expect(await refused({
+      slice: "Nobody",
+      key: "default",
+      at: "2026-10-16T06:00:00Z"
+    })).toBe(true);
+    globalThis.expect(await refused({
+      slice: "Outbound",
+      key: "default",
+      at: "2026-10-16T06:00:00Z"
+    })).toBe(true);
+    globalThis.expect(await refused({
+      slice: "DemandReport",
+      key: "default",
+      at: "soon"
+    })).toBe(true);
+  });
+});
+
 let outboundEventSchema = Sury.union([
   Sury.$schema(s => ({
     TAG: "OrderPlaced",

package/tests/ScheduledPublisher_EventBridgeSchedulerTest.res

@@ -57,4 +57,34 @@ describe("ScheduledPublisher_EventBridgeScheduler_Runtime", () => {
       "arn:aws:scheduler:*:123456789012:schedule/SchedulerRole-*/*",
     )
   })
+
+  testSync("a schedule group's tags carry no empty value, which AWS refuses", () => {
+    let tags = Dict.fromArray([("Name", "SchedulerScheduleGroup"), ("reventless:plugin", "")])
+    expect(tags->AWS.Tags.withoutEmpty->Dict.toArray)->toEqual([("Name", "SchedulerScheduleGroup")])
+  })
+
+  testSync("names an automation's schedule <slice>.<key>, or hashes a key it would refuse", () => {
+    expect(Runtime.tickScheduleName(~slice="MarketingDigest", ~key="r1"))->toBe(
+      "MarketingDigest.r1",
+    )
+    let hashed = Runtime.tickScheduleName(~slice="MarketingDigest", ~key="customer:42")
+    expect((hashed->String.startsWith("MarketingDigest."), hashed->String.length))->toEqual((
+      true,
+      16 + 16,
+    ))
+    let long = "A"->String.repeat(60)
+    let cut = Runtime.tickScheduleName(~slice=long, ~key="default")
+    expect((cut->String.length, cut->Runtime.isSliceSchedule(~slice=long)))->toEqual((57, true))
+  })
+
+  testSync("tells a slice's schedules from another slice's sharing its prefix", () => {
+    expect("Digest.r1"->Runtime.isSliceSchedule(~slice="Digest"))->toBe(true)
+    expect("DigestWeekly.r1"->Runtime.isSliceSchedule(~slice="Digest"))->toBe(false)
+  })
+
+  testSync("invokes the automation Lambda with the slice, the key and the scheduled time", () => {
+    expect(
+      Runtime.tickInput(~slice="MarketingDigest", ~key="r1"),
+    )->toBe(`{"reventlessTick":{"slice":"MarketingDigest","key":"r1","at":"<aws.scheduler.scheduled-time>"}}`)
+  })
 })

package/tests/ScheduledPublisher_EventBridgeSchedulerTest.res.mjs

@@ -1,6 +1,7 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
 import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as AWS_Tags$ReventlessAws from "../src/adapter/AWS_Tags.res.mjs";
 import * as ScheduledPublisher_EventBridgeScheduler_Runtime$ReventlessAws from "../src/adapter/ScheduledPublisher/ScheduledPublisher_EventBridgeScheduler_Runtime.res.mjs";
 
 let roleArn = "arn:aws:iam::123456789012:role/SchedulerRole-1a2b3c4";
@@ -83,6 +84,49 @@ globalThis.describe("ScheduledPublisher_EventBridgeScheduler_Runtime", () => {
     globalThis.expect(ScheduledPublisher_EventBridgeScheduler_Runtime$ReventlessAws.schedulesOfRoleArn(roleArn)).toBe("arn:aws:scheduler:*:123456789012:schedule/SchedulerRole-1a2b3c4/*");
     globalThis.expect(ScheduledPublisher_EventBridgeScheduler_Runtime$ReventlessAws.schedulesOfAccount("123456789012")).toBe("arn:aws:scheduler:*:123456789012:schedule/SchedulerRole-*/*");
   });
+  globalThis.test("a schedule group's tags carry no empty value, which AWS refuses", () => {
+    let tags = Object.fromEntries([
+      [
+        "Name",
+        "SchedulerScheduleGroup"
+      ],
+      [
+        "reventless:plugin",
+        ""
+      ]
+    ]);
+    globalThis.expect(Object.entries(AWS_Tags$ReventlessAws.withoutEmpty(tags))).toEqual([[
+        "Name",
+        "SchedulerScheduleGroup"
+      ]]);
+  });
+  globalThis.test("names an automation's schedule <slice>.<key>, or hashes a key it would refuse", () => {
+    globalThis.expect(ScheduledPublisher_EventBridgeScheduler_Runtime$ReventlessAws.tickScheduleName("MarketingDigest", "r1")).toBe("MarketingDigest.r1");
+    let hashed = ScheduledPublisher_EventBridgeScheduler_Runtime$ReventlessAws.tickScheduleName("MarketingDigest", "customer:42");
+    globalThis.expect([
+      hashed.startsWith("MarketingDigest."),
+      hashed.length
+    ]).toEqual([
+      true,
+      32
+    ]);
+    let long = "A".repeat(60);
+    let cut = ScheduledPublisher_EventBridgeScheduler_Runtime$ReventlessAws.tickScheduleName(long, "default");
+    globalThis.expect([
+      cut.length,
+      ScheduledPublisher_EventBridgeScheduler_Runtime$ReventlessAws.isSliceSchedule(cut, long)
+    ]).toEqual([
+      57,
+      true
+    ]);
+  });
+  globalThis.test("tells a slice's schedules from another slice's sharing its prefix", () => {
+    globalThis.expect(ScheduledPublisher_EventBridgeScheduler_Runtime$ReventlessAws.isSliceSchedule("Digest.r1", "Digest")).toBe(true);
+    globalThis.expect(ScheduledPublisher_EventBridgeScheduler_Runtime$ReventlessAws.isSliceSchedule("DigestWeekly.r1", "Digest")).toBe(false);
+  });
+  globalThis.test("invokes the automation Lambda with the slice, the key and the scheduled time", () => {
+    globalThis.expect(ScheduledPublisher_EventBridgeScheduler_Runtime$ReventlessAws.tickInput("MarketingDigest", "r1")).toBe(`{"reventlessTick":{"slice":"MarketingDigest","key":"r1","at":"<aws.scheduler.scheduled-time>"}}`);
+  });
 });
 
 let Runtime;