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

package/tests/components/automationslice/AutomationSweepFixtures.res

@@ -0,0 +1,131 @@
+// 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"
+  let schedule = None
+}
+
+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
+    let reschedule = _ => []
+  },
+)
+
+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)
+  )

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

@@ -0,0 +1,223 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Sury from "sury";
+import * as Stdlib_JSON from "@rescript/runtime/lib/es6/Stdlib_JSON.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 Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
+import * as Primitive_object from "@rescript/runtime/lib/es6/Primitive_object.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 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_Callback$ReventlessCore from "@reventlessdev/reventless-core/src/components/AutomationSlice/AutomationSlice_Callback.res.mjs";
+
+let name = "DeadlineOrderEventTopic";
+
+let eventSchema = Sury.$schema(s => ({
+  TAG: "OrderPlaced",
+  orderId: s.m(Sury.string),
+  within: s.m(Sury.number)
+}));
+
+let OrderSource = {
+  Id: undefined,
+  name: name,
+  eventSchema: eventSchema
+};
+
+let name$1 = "CancelUnshipped";
+
+let moduleUrl = import.meta.url;
+
+let todoItemSchema = Sury.$schema(s => ({
+  orderId: s.m(Sury.string),
+  dueAt: s.m(Sury.number)
+}));
+
+let commandSchema = Sury.$schema(s => ({
+  TAG: "CancelOrder",
+  orderId: s.m(DcbTag$Reventless.string)
+}));
+
+function authorizationOf(param) {
+  return "AllowAuthenticated";
+}
+
+function commandTransition(param) {
+  return "Undeclared";
+}
+
+let traits = [];
+
+let CancelUnshippedSpec = {
+  name: name$1,
+  moduleUrl: moduleUrl,
+  todoItemSchema: todoItemSchema,
+  commandSchema: commandSchema,
+  maxRetries: 2,
+  heartbeatInterval: 60,
+  targetName: "CancelOrder",
+  schedule: undefined,
+  authorizationOf: authorizationOf,
+  commandTransition: commandTransition,
+  traits: traits
+};
+
+function collect(event, param, ctx) {
+  let match = ctx.recordedAt;
+  if (match === undefined) {
+    return [];
+  }
+  let orderId = event.orderId;
+  return [[
+      orderId,
+      {
+        orderId: orderId,
+        dueAt: match + event.within
+      }
+    ]];
+}
+
+function resolve(_event) {
+  
+}
+
+function reschedule(param) {
+  return [];
+}
+
+let FromOrders = AutomationSlice$Reventless.Mapping.Make({
+  Id: Id$Reventless.$$String,
+  name: name,
+  eventSchema: eventSchema
+})(CancelUnshippedSpec)({
+  collect: collect,
+  resolve: resolve,
+  reschedule: reschedule
+});
+
+function process(id, item, now) {
+  if (now >= item.dueAt) {
+    return [
+      id,
+      {
+        TAG: "CancelOrder",
+        orderId: item.orderId
+      }
+    ];
+  }
+}
+
+function onExhausted(_id, _item) {
+  
+}
+
+let moduleUrl$1 = import.meta.url;
+
+AutomationSlice$Reventless.Mappings.Make(CancelUnshippedSpec);
+
+let mappings = [FromOrders];
+
+let CancelUnshippedAutomation = {
+  process: process,
+  onExhausted: onExhausted,
+  moduleUrl: moduleUrl$1,
+  mappings: mappings
+};
+
+let orderResource = Adapter$ReventlessInfra.make(Pulumi.output(name), Pulumi.output(name), Pulumi.output(name), Pulumi.output("memory:InMemory"), undefined, undefined, undefined, undefined, undefined, undefined);
+
+let allEventTopics = Object.fromEntries([[
+    name,
+    {
+      resources: [orderResource]
+    }
+  ]]);
+
+let Bus = LocalBus$ReventlessLocal.Make({});
+
+TestRunner$ReventlessLocal.setup();
+
+let AutomationSliceMaker = AutomationSlice_Builder$ReventlessLocal.Make(Bus);
+
+let CancelUnshipped = AutomationSliceMaker.Make(CancelUnshippedSpec)(CancelUnshippedAutomation);
+
+let publishedCommands = {
+  contents: []
+};
+
+let failPublish = {
+  contents: false
+};
+
+async function publishJsons(cmds) {
+  if (failPublish.contents) {
+    return Stdlib_JsError.throwWithMessage("command topic unavailable");
+  } else {
+    publishedCommands.contents = publishedCommands.contents.concat(cmds);
+    return;
+  }
+}
+
+let slice = CancelUnshipped.make(allEventTopics, Pulumi.output(publishJsons), {
+  environment: "local",
+  platformName: "local",
+  pluginName: "TestPlugin",
+  sliceName: name$1
+}, undefined, undefined);
+
+async function placeOrder(orderId, within) {
+  let newrecord = {...TestFixtures$ReventlessLocal.makeTestMeta(name)};
+  newrecord.time = new Date(Date.now()).toISOString();
+  let eventJson = Object.fromEntries([
+    [
+      "id",
+      orderId
+    ],
+    [
+      "meta",
+      Util_Sury$Reventless.toJson(newrecord, Message$Reventless.metaSchema)
+    ],
+    [
+      "event",
+      Util_Sury$Reventless.toJson({
+        TAG: "OrderPlaced",
+        orderId: orderId,
+        within: within
+      }, eventSchema)
+    ]
+  ]);
+  await Bus.publishEvent(name, "test", newrecord, eventJson);
+  await Promise.resolve();
+  await Promise.resolve();
+}
+
+function storedRow(id) {
+  return Stdlib_Option.map(Stdlib_Option.getOr(Stdlib_Option.map(Bus.getQueryDbScan(CancelUnshipped.queryDbName), scan => scan()), []).find(row => Primitive_object.equal(Stdlib_Option.flatMap(Stdlib_JSON.Decode.object(row), o => o["id"]), id)), row => Util_Sury$Reventless.fromJson(row, AutomationSlice_Callback$ReventlessCore.todoRowSchema));
+}
+
+export {
+  OrderSource,
+  CancelUnshippedSpec,
+  FromOrders,
+  CancelUnshippedAutomation,
+  orderResource,
+  allEventTopics,
+  Bus,
+  AutomationSliceMaker,
+  CancelUnshipped,
+  publishedCommands,
+  failPublish,
+  publishJsons,
+  slice,
+  placeOrder,
+  storedRow,
+}
+/* eventSchema Not a pure module */

package/tests/components/automationslice/AutomationSweepTest.res

@@ -0,0 +1,107 @@
+// The local platform sweeps pending automation items as AWS does: a deadline,
+// counted from its event's recorded time, passes without another event, a failed command is retried up to maxRetries,
+// and what the sweep moved is written back to the query store.
+
+open JestGlobals
+open AutomationSweepFixtures
+
+module Callback = ReventlessCore.AutomationSlice_Callback
+
+// Only Date is faked, so `process` sees the time a test sets while Effect's own
+// scheduling still runs on real timers.
+type jestObj
+type fakeTimersConfig = {doNotFake: array<string>}
+@module("@jest/globals") external jest: jestObj = "jest"
+@send external useFakeTimers: (jestObj, fakeTimersConfig) => unit = "useFakeTimers"
+@send external useRealTimers: jestObj => unit = "useRealTimers"
+@send external setSystemTime: (jestObj, float) => unit = "setSystemTime"
+
+let setNow = millis => jest->setSystemTime(millis)
+
+let commandIds = () => publishedCommands.contents->Array.map(c => c.id)
+
+describe("the local automation sweep", () => {
+  let _ = beforeAll(() =>
+    jest->useFakeTimers({
+      doNotFake: [
+        "hrtime",
+        "nextTick",
+        "performance",
+        "queueMicrotask",
+        "setImmediate",
+        "clearImmediate",
+        "setInterval",
+        "clearInterval",
+        "setTimeout",
+        "clearTimeout",
+      ],
+    })
+  )
+  let _ = afterAll(() => jest->useRealTimers)
+
+  let _ = beforeAllAsync(async () => {
+    let _ = await slice->ReventlessCore.Component.operations->TestRunner.resolve
+    let _ = await orderResource.name->TestRunner.resolve
+    let _ = await Promise.resolve()
+    let _ = await Promise.resolve()
+  })
+
+  let _ = beforeEach(() => {
+    publishedCommands := []
+    failPublish := false
+    setNow(0.)
+  })
+
+  testPromise("sends a deadline's command once it is due, with no further event", async () => {
+    await placeOrder("o1", ~within=100.)
+    expect(commandIds())->toEqual([])
+
+    await LocalAutomationSweep.sweepOnce()
+    expect(commandIds())->toEqual([])
+
+    setNow(100.)
+    await LocalAutomationSweep.sweepOnce()
+    expect(commandIds())->toEqual(["o1"])
+  })
+
+  testPromise("writes what it moved back to the query store", async () => {
+    await placeOrder("o2", ~within=100.)
+    expect(storedRow("o2")->Option.map(row => row.status))->toEqual(Some(Callback.Pending))
+
+    setNow(100.)
+    await LocalAutomationSweep.sweepOnce()
+    expect(storedRow("o2")->Option.map(row => row.status))->toEqual(Some(Callback.Processing))
+  })
+
+  testPromise("retries a failed command up to maxRetries, then abandons it", async () => {
+    setNow(100.)
+    failPublish := true
+    await placeOrder("o3", ~within=0.)
+    expect(storedRow("o3")->Option.map(row => (row.status, row.retryCount)))->toEqual(
+      Some((Callback.Failed, 1)),
+    )
+
+    await LocalAutomationSweep.sweepOnce()
+    expect(storedRow("o3")->Option.map(row => (row.status, row.retryCount)))->toEqual(
+      Some((Callback.Abandoned, 2)),
+    )
+
+    failPublish := false
+    await LocalAutomationSweep.sweepOnce()
+    expect(commandIds()->Array.includes("o3"))->toBe(false)
+  })
+
+  testSync("waits five minutes by default, as on AWS", () => {
+    expect(LocalAutomationSweep.intervalSeconds())->toBe(300)
+  })
+
+  testSync("waits REVENTLESS_LOCAL_SWEEP_SECONDS when it is a positive number", () => {
+    let key = "REVENTLESS_LOCAL_SWEEP_SECONDS"
+    NodeProcess.env->Dict.set(key, "15")
+    let shortened = LocalAutomationSweep.intervalSeconds()
+    NodeProcess.env->Dict.set(key, "soon")
+    let malformed = LocalAutomationSweep.intervalSeconds()
+    NodeProcess.env->Dict.delete(key)
+    expect((shortened, malformed))->toEqual((15, 300))
+  })
+})

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

@@ -0,0 +1,116 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stdlib_Dict from "@rescript/runtime/lib/es6/Stdlib_Dict.js";
+import * as Globals from "@jest/globals";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.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 LocalAutomationSweep$ReventlessLocal from "../../../src/components/LocalAutomationSweep.res.mjs";
+import * as AutomationSweepFixtures$ReventlessLocal from "./AutomationSweepFixtures.res.mjs";
+
+function setNow(millis) {
+  Globals.jest.setSystemTime(millis);
+}
+
+function commandIds() {
+  return AutomationSweepFixtures$ReventlessLocal.publishedCommands.contents.map(c => c.id);
+}
+
+globalThis.describe("the local automation sweep", () => {
+  globalThis.beforeAll(() => {
+    Globals.jest.useFakeTimers({
+      doNotFake: [
+        "hrtime",
+        "nextTick",
+        "performance",
+        "queueMicrotask",
+        "setImmediate",
+        "clearImmediate",
+        "setInterval",
+        "clearInterval",
+        "setTimeout",
+        "clearTimeout"
+      ]
+    });
+  });
+  globalThis.afterAll(() => {
+    Globals.jest.useRealTimers();
+  });
+  globalThis.beforeAll(async () => {
+    await TestRunner$ReventlessLocal.resolve(Component$ReventlessCore.operations(AutomationSweepFixtures$ReventlessLocal.slice));
+    await TestRunner$ReventlessLocal.resolve(AutomationSweepFixtures$ReventlessLocal.orderResource.name);
+    await Promise.resolve();
+    await Promise.resolve();
+  });
+  globalThis.beforeEach(() => {
+    AutomationSweepFixtures$ReventlessLocal.publishedCommands.contents = [];
+    AutomationSweepFixtures$ReventlessLocal.failPublish.contents = false;
+    Globals.jest.setSystemTime(0);
+  });
+  globalThis.test("sends a deadline's command once it is due, with no further event", async () => {
+    await AutomationSweepFixtures$ReventlessLocal.placeOrder("o1", 100);
+    globalThis.expect(commandIds()).toEqual([]);
+    await LocalAutomationSweep$ReventlessLocal.sweepOnce();
+    globalThis.expect(commandIds()).toEqual([]);
+    Globals.jest.setSystemTime(100);
+    await LocalAutomationSweep$ReventlessLocal.sweepOnce();
+    globalThis.expect(commandIds()).toEqual(["o1"]);
+  });
+  globalThis.test("writes what it moved back to the query store", async () => {
+    await AutomationSweepFixtures$ReventlessLocal.placeOrder("o2", 100);
+    globalThis.expect(Stdlib_Option.map(AutomationSweepFixtures$ReventlessLocal.storedRow("o2"), row => row.status)).toEqual("Pending");
+    Globals.jest.setSystemTime(100);
+    await LocalAutomationSweep$ReventlessLocal.sweepOnce();
+    globalThis.expect(Stdlib_Option.map(AutomationSweepFixtures$ReventlessLocal.storedRow("o2"), row => row.status)).toEqual("Processing");
+  });
+  globalThis.test("retries a failed command up to maxRetries, then abandons it", async () => {
+    Globals.jest.setSystemTime(100);
+    AutomationSweepFixtures$ReventlessLocal.failPublish.contents = true;
+    await AutomationSweepFixtures$ReventlessLocal.placeOrder("o3", 0);
+    globalThis.expect(Stdlib_Option.map(AutomationSweepFixtures$ReventlessLocal.storedRow("o3"), row => [
+      row.status,
+      row.retryCount
+    ])).toEqual([
+      "Failed",
+      1
+    ]);
+    await LocalAutomationSweep$ReventlessLocal.sweepOnce();
+    globalThis.expect(Stdlib_Option.map(AutomationSweepFixtures$ReventlessLocal.storedRow("o3"), row => [
+      row.status,
+      row.retryCount
+    ])).toEqual([
+      "Abandoned",
+      2
+    ]);
+    AutomationSweepFixtures$ReventlessLocal.failPublish.contents = false;
+    await LocalAutomationSweep$ReventlessLocal.sweepOnce();
+    globalThis.expect(commandIds().includes("o3")).toBe(false);
+  });
+  globalThis.test("waits five minutes by default, as on AWS", () => {
+    globalThis.expect(LocalAutomationSweep$ReventlessLocal.intervalSeconds()).toBe(300);
+  });
+  globalThis.test("waits REVENTLESS_LOCAL_SWEEP_SECONDS when it is a positive number", () => {
+    let key = "REVENTLESS_LOCAL_SWEEP_SECONDS";
+    process.env[key] = "15";
+    let shortened = LocalAutomationSweep$ReventlessLocal.intervalSeconds();
+    process.env[key] = "soon";
+    let malformed = LocalAutomationSweep$ReventlessLocal.intervalSeconds();
+    Stdlib_Dict.$$delete(process.env, key);
+    globalThis.expect([
+      shortened,
+      malformed
+    ]).toEqual([
+      15,
+      300
+    ]);
+  });
+});
+
+let Callback;
+
+export {
+  Callback,
+  setNow,
+  commandIds,
+}
+/*  Not a pure module */

package/tests/components/automationslice/MixedSourceAutomationSliceFixtures.res

@@ -55,6 +55,7 @@ module AutoFulfillSpec = {
   let maxRetries = 3
   let heartbeatInterval = 60
   let targetName = "MarkFulfilled"
+  let schedule = None
 }
 
 // Forward-declared per-source mappings live below; the merged `Automation`
@@ -88,6 +89,7 @@ module FromOrderAggregate = AutomationSlice.Mapping.Make(
       }
     }
     let resolve = (_event: OrderAggregateSource.event) => None
+    let reschedule = _ => []
   },
 )
 
@@ -115,6 +117,7 @@ module FromInventoryDcb = AutomationSlice.Mapping.Make(
       | StockReleased({orderId, productId}) => Some(orderId ++ ":" ++ productId)
       | StockReserved(_) => None
       }
+    let reschedule = _ => []
   },
 )
 
@@ -123,7 +126,7 @@ module FromInventoryDcb = AutomationSlice.Mapping.Make(
 // ─────────────────────────────────────────────────────────────
 
 module AutoFulfillAutomation: AutomationSlice.Automation with module Spec := AutoFulfillSpec = {
-  let process = (id, item: AutoFulfillSpec.todoItem) => Some((
+  let process = (id, item: AutoFulfillSpec.todoItem, ~now as _) => Some((
     id,
     AutoFulfillSpec.MarkFulfilled({orderId: item.orderId, productId: item.productId}),
   ))

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

@@ -82,6 +82,7 @@ let AutoFulfillSpec = {
   maxRetries: 3,
   heartbeatInterval: 60,
   targetName: "MarkFulfilled",
+  schedule: undefined,
   authorizationOf: authorizationOf,
   commandTransition: commandTransition,
   traits: traits
@@ -109,13 +110,18 @@ function resolve(_event) {
   
 }
 
+function reschedule(param) {
+  return [];
+}
+
 let FromOrderAggregate = AutomationSlice$Reventless.Mapping.Make({
   Id: Id$Reventless.$$String,
   name: name,
   eventSchema: eventSchema
 })(AutoFulfillSpec)({
   collect: collect,
-  resolve: resolve
+  resolve: resolve,
+  reschedule: reschedule
 });
 
 function collect$1(event, param, _ctx) {
@@ -142,16 +148,21 @@ function resolve$1(event) {
   }
 }
 
+function reschedule$1(param) {
+  return [];
+}
+
 let FromInventoryDcb = AutomationSlice$Reventless.Mapping.Make({
   Id: Id$Reventless.$$String,
   name: name$1,
   eventSchema: eventSchema$1
 })(AutoFulfillSpec)({
   collect: collect$1,
-  resolve: resolve$1
+  resolve: resolve$1,
+  reschedule: reschedule$1
 });
 
-function process(id, item) {
+function process(id, item, param) {
   return [
     id,
     {

package/tests/components/scheduler/SchedulerTest.res

@@ -21,10 +21,10 @@ describe("Scheduler_Builder.Make:", () => {
             count := count.contents + 1
           },
         )
-        // createSchedule async body has no await — setInterval registered synchronously
+        // createSchedule async body has no await — the timer is set synchronously
         let _ = ops.createSchedule(
           [makeTopicResource("sched-recurring")],
-          {name: "test-recurring", rate: Reventless.Schedule.Minutes(1), payload: "{}"},
+          {name: "test-recurring", time: Every(Minutes(1)), payload: "{}"},
         )
         // Two microtask ticks: publishEvent uses Effect.all(concurrency=unbounded) which forks
         // child fibers via startFork — one tick runs the child fiber (Queue.offer),
@@ -55,11 +55,11 @@ describe("Scheduler_Builder.Make:", () => {
           [makeTopicResource("sched-single")],
           {
             name: "test-single",
-            rate: Reventless.Schedule.Single(2024, 1, 1, 0, 0),
+            time: Once({moment: After(Minutes(1))}),
             payload: "{}",
           },
         )
-        jest->advanceTimersByTime(0)
+        jest->advanceTimersByTime(60 * 1000)
         let _ = await Promise.resolve()
         let _ = await Promise.resolve()
         expect(count.contents)->toBe(1)
@@ -83,7 +83,7 @@ describe("Scheduler_Builder.Make:", () => {
         )
         let _ = ops.createSchedule(
           [makeTopicResource("sched-delete")],
-          {name: "test-delete", rate: Reventless.Schedule.Minutes(2), payload: "{}"},
+          {name: "test-delete", time: Every(Minutes(2)), payload: "{}"},
         )
         let _ = ops.deleteSchedule([], "test-delete")
         jest->advanceTimersByTime(2 * 60 * 1000)