@reventlessdev/reventless-aws 3.0.0-alpha.382 → 3.0.0-alpha.384

package/src/components/AutomationSlice_Builder.res.mjs

@@ -1,6 +1,8 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
+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 Component$ReventlessCore from "@reventlessdev/reventless-core/src/components/Component.res.mjs";
 import * as EventTopic$ReventlessCore from "@reventlessdev/reventless-core/src/components/EventTopic/EventTopic.res.mjs";
 import * as Util_Bundle$ReventlessAws from "../util/Util_Bundle.res.mjs";
@@ -11,6 +13,20 @@ import * as RuntimeEnvironment_Lambda$ReventlessAws from "../adapter/Runtime/Run
 import * as EventCollectorChannel_DynamoDbStream$ReventlessAws from "../adapter/EventCollector/EventCollectorChannel_DynamoDbStream.res.mjs";
 import * as AutomationSliceRuntime_Builder_Single$ReventlessAws from "../adapter/Runtime/AutomationSliceRuntime_Builder_Single.res.mjs";
 
+function platformFor(slice) {
+  let refuse = () => Stdlib_JsError.throwWithMessage(`AutomationSlice(` + slice + `): schedules are set by its Lambda, not at deploy`);
+  return {
+    put: async (param, param$1) => refuse(),
+    removeName: async param => refuse(),
+    names: async () => refuse(),
+    nameOf: key => key
+  };
+}
+
+let DeployTimeSchedules = {
+  platformFor: platformFor
+};
+
 function Make(Api) {
   let Inner = AutomationSlice_Builder$ReventlessCore.Make({
     make: RuntimeEnvironment_Lambda$ReventlessAws.make,
@@ -35,7 +51,7 @@ function Make(Api) {
     },
     forEventCollector: AutomationSliceRuntime_Builder_Single$ReventlessAws.forEventCollector,
     finish: AutomationSliceRuntime_Builder_Single$ReventlessAws.finish
-  })(Api);
+  })(Api)(DeployTimeSchedules);
   let Make$1 = Spec => (Automation => {
     let InnerMake = Inner.Make(Spec)(Automation);
     let sourceNames = InnerMake.sourceNames;
@@ -46,13 +62,14 @@ function Make(Api) {
       let queryDbTableName = tableResource.name;
       let sourceTopics = EventTopic$ReventlessCore.filter(allEventTopics, Belt_SetString.fromArray(sourceNames));
       let consumesDcbLog = sourceNames.length === 0 || sourceNames.some(name => !(name in allEventTopics));
-      AutomationSliceRuntime_Builder_Single$ReventlessAws.registerAutomationSlice(Spec.name, Util_Bundle$ReventlessAws.getModuleSpecifier(Spec.moduleUrl), Util_Bundle$ReventlessAws.getModuleSpecifier(Automation.moduleUrl), "automation", queryDbTableName, queryDbOutputs.resources, context, sourceTopics, consumesDcbLog, undefined);
+      AutomationSliceRuntime_Builder_Single$ReventlessAws.registerAutomationSlice(Spec.name, Util_Bundle$ReventlessAws.getModuleSpecifier(Spec.moduleUrl), Util_Bundle$ReventlessAws.getModuleSpecifier(Automation.moduleUrl), "automation", queryDbTableName, queryDbOutputs.resources, context, sourceTopics, consumesDcbLog, undefined, Spec.schedule, Stdlib_Option.mapOr(Component$ReventlessCore.outputs(as_).schedulesDb, [], db => db.resources));
       return as_;
     };
     return {
       Spec: Spec,
       Automation: Automation,
       queryDbName: InnerMake.queryDbName,
+      schedulesDbName: InnerMake.schedulesDbName,
       sourceNames: sourceNames,
       make: make
     };
@@ -75,6 +92,7 @@ export {
   EventCollectorChannel,
   RuntimeEnvironment,
   EventCollectorRuntimeBuilder,
+  DeployTimeSchedules,
   Make,
 }
 /* Component-ReventlessCore Not a pure module */

package/src/components/OutboundTranslationSlice_Builder.res.mjs

@@ -63,7 +63,7 @@ function Make(Api) {
       let declaredSources = Spec.sourceNames;
       let sourceTopics = EventTopic$ReventlessCore.filter(allEventTopics, Belt_SetString.fromArray(declaredSources));
       let consumesDcbLog = declaredSources.length === 0 || declaredSources.some(name => !(name in allEventTopics));
-      AutomationSliceRuntime_Builder_Single$ReventlessAws.registerAutomationSlice(Spec.name, Util_Bundle$ReventlessAws.getModuleSpecifier(Spec.moduleUrl), Util_Bundle$ReventlessAws.getModuleSpecifier(Translation.moduleUrl), "outbound", queryDbTableName, queryDbOutputs.resources, undefined, sourceTopics, consumesDcbLog, Spec.targetName);
+      AutomationSliceRuntime_Builder_Single$ReventlessAws.registerAutomationSlice(Spec.name, Util_Bundle$ReventlessAws.getModuleSpecifier(Spec.moduleUrl), Util_Bundle$ReventlessAws.getModuleSpecifier(Translation.moduleUrl), "outbound", queryDbTableName, queryDbOutputs.resources, undefined, sourceTopics, consumesDcbLog, Spec.targetName, undefined, undefined);
       return ots;
     };
     return {

package/tests/AppSync_AdapterTest.res

@@ -606,6 +606,58 @@ describe("AppSync_Adapter.injectAwsAuth — systemCallable dual-auth", () => {
       )
     },
   )
+
+  // The resolvers check no rule, so a door the gate misses reads the gated rows.
+  // Run through the real generator, so a door it adds later is covered too.
+  testSync("a roles-gated entry's every generated door carries its groups", () => {
+    let byCategory: Reventless.ReadModel.indexConfig = {
+      index: "byCategory",
+      type_: "S",
+      idField: "categoryId",
+      projectionType: ALL,
+    }
+    let gated = (
+      ~single,
+      ~list,
+      ~subIdField=?,
+      ~indexQueries=?,
+    ): ReventlessInfra.Api.querySchemaEntry => {
+      singleFieldName: single,
+      listFieldName: list,
+      returnTypeName: single,
+      stateSchema: S.unknown,
+      authorization: None,
+      permission: AllowRoles([Reventless.Role.make("Admin")]),
+      ?subIdField,
+      ?indexQueries,
+    }
+    let entries = [
+      gated(~single="p_Item", ~list="p_Items", ~indexQueries=[byCategory]),
+      gated(~single="p_Line", ~list="p_Lines", ~subIdField="lineId"),
+    ]
+    let frag = ReventlessCore.GraphQL_FragmentGenerator.generate(
+      ~mutationEntries=[],
+      ~queryEntries=entries,
+    )
+    let queries = (
+      AppSync_Adapter.injectAwsAuth(
+        frag,
+        ~mutationEntries=[],
+        ~queryEntries=entries,
+      )->decodeFragment
+    ).queries
+    let names = queries->Array.map(ReventlessCore.GraphQL_Stitcher.extractLeadingName)
+    expect(
+      ["p_ItemsByIds", "p_ItemsRefs", "p_ItemByCategory", "p_LineItems"]->Array.every(
+        door => names->Array.includes(door),
+      ),
+    )->toBe(true)
+    expect(
+      queries->Array.filter(
+        field => !(field->String.includes(`@aws_cognito_user_pools(cognito_groups: ["Admin"])`)),
+      ),
+    )->toEqual([])
+  })
 })
 
 // ── Type-level dual-auth ─────────────────────────────────────────────────────

package/tests/AppSync_AdapterTest.res.mjs

@@ -12,6 +12,7 @@ import * as GraphQL_Stitcher$ReventlessCore from "@reventlessdev/reventless-core
 import * as Platform_AdminApi$ReventlessCore from "@reventlessdev/reventless-core/src/admin/Platform_AdminApi.res.mjs";
 import * as AppSync_SdlDecorate$ReventlessAws from "../src/components/Api/AppSync_SdlDecorate.res.mjs";
 import * as PluginBaseFragment$ReventlessCore from "@reventlessdev/reventless-core/src/plugin/api/PluginBaseFragment.res.mjs";
+import * as GraphQL_FragmentGenerator$ReventlessCore from "@reventlessdev/reventless-core/src/components/Api/GraphQL_FragmentGenerator.res.mjs";
 
 globalThis.describe("AppSync_Adapter.sha256Hex", () => {
   globalThis.test("returns a 64-character hex string", () => {
@@ -596,6 +597,40 @@ globalThis.describe("AppSync_Adapter.injectAwsAuth — systemCallable dual-auth"
       }
     });
   });
+  globalThis.test("a roles-gated entry's every generated door carries its groups", () => {
+    let gated = (single, list, subIdField, indexQueries) => ({
+      singleFieldName: single,
+      listFieldName: list,
+      returnTypeName: single,
+      stateSchema: Sury.unknown,
+      authorization: undefined,
+      permission: {
+        TAG: "AllowRoles",
+        _0: ["Admin"]
+      },
+      subIdField: subIdField,
+      indexQueries: indexQueries
+    });
+    let entries = [
+      gated("p_Item", "p_Items", undefined, [{
+          index: "byCategory",
+          type_: "S",
+          idField: "categoryId",
+          projectionType: "ALL"
+        }]),
+      gated("p_Line", "p_Lines", "lineId", undefined)
+    ];
+    let frag = GraphQL_FragmentGenerator$ReventlessCore.generate([], entries);
+    let queries = GraphQL_Stitcher$ReventlessCore.decode(AppSync_Adapter$ReventlessAws.injectAwsAuth(frag, [], entries)).queries;
+    let names = queries.map(GraphQL_Stitcher$ReventlessCore.extractLeadingName);
+    globalThis.expect([
+      "p_ItemsByIds",
+      "p_ItemsRefs",
+      "p_ItemByCategory",
+      "p_LineItems"
+    ].every(door => names.includes(door))).toBe(true);
+    globalThis.expect(queries.filter(field => !field.includes(`@aws_cognito_user_pools(cognito_groups: ["Admin"])`))).toEqual([]);
+  });
 });
 
 globalThis.describe("AppSync_Adapter — type-level dual-auth", () => {

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

@@ -62,4 +62,29 @@ describe("ScheduledPublisher_EventBridgeScheduler_Runtime", () => {
     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

@@ -100,6 +100,33 @@ globalThis.describe("ScheduledPublisher_EventBridgeScheduler_Runtime", () => {
         "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;