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

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)
+  )

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

@@ -0,0 +1,263 @@
+// 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 Clock$Reventless from "@reventlessdev/reventless-spec/src/components/Clock.res.mjs";
+import * as Primitive_object from "@rescript/runtime/lib/es6/Primitive_object.js";
+import * as Util_Sury$Reventless from "@reventlessdev/reventless-spec/src/util/Util_Sury.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 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 = "LocalDemandReport";
+
+let moduleUrl = import.meta.url;
+
+let todoItemSchema = Sury.$schema(s => ({
+  day: s.m(Sury.number)
+}));
+
+let commandSchema = Sury.$schema(s => ({
+  TAG: "RequestDemandReport",
+  day: s.m(Sury.number)
+}));
+
+let targetName = "ReportSettings";
+
+function authorizationOf(param) {
+  return "AllowAuthenticated";
+}
+
+function commandTransition(param) {
+  return "Undeclared";
+}
+
+let traits = [];
+
+let DemandReportSpec_schedule = {
+  TAG: "Calendar",
+  calendar: {
+    TAG: "Daily",
+    hour: 6,
+    minute: 0
+  }
+};
+
+let DemandReportSpec = {
+  name: name,
+  moduleUrl: moduleUrl,
+  todoItemSchema: todoItemSchema,
+  commandSchema: commandSchema,
+  maxRetries: 2,
+  heartbeatInterval: 60,
+  targetName: targetName,
+  schedule: DemandReportSpec_schedule,
+  authorizationOf: authorizationOf,
+  commandTransition: commandTransition,
+  traits: traits
+};
+
+function collect(param, param$1, _ctx) {
+  let at = param.at;
+  return [[
+      Clock$Reventless.itemId(param.key, at),
+      {
+        day: at
+      }
+    ]];
+}
+
+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
+})(DemandReportSpec)({
+  collect: collect,
+  resolve: resolve,
+  reschedule: reschedule
+});
+
+function process(id, item, param) {
+  return [
+    id,
+    {
+      TAG: "RequestDemandReport",
+      day: item.day
+    }
+  ];
+}
+
+function onExhausted(_id, _item) {
+  
+}
+
+let moduleUrl$1 = import.meta.url;
+
+AutomationSlice$Reventless.Mappings.Make(DemandReportSpec);
+
+let mappings = [FromClock];
+
+let DemandReportAutomation = {
+  process: process,
+  onExhausted: onExhausted,
+  moduleUrl: moduleUrl$1,
+  mappings: mappings
+};
+
+let name$1 = "LocalUnscheduledReport";
+
+let UnscheduledSpec = {
+  moduleUrl: moduleUrl,
+  todoItemSchema: todoItemSchema,
+  commandSchema: commandSchema,
+  maxRetries: 2,
+  heartbeatInterval: 60,
+  targetName: targetName,
+  authorizationOf: authorizationOf,
+  commandTransition: commandTransition,
+  traits: traits,
+  name: name$1,
+  schedule: undefined
+};
+
+function collect$1(param, param$1, _ctx) {
+  return [];
+}
+
+function resolve$1(param) {
+  
+}
+
+function reschedule$1(param) {
+  return [];
+}
+
+let FromClockUnscheduled = AutomationSlice$Reventless.Mapping.Make({
+  Id: Id$Reventless.$$String,
+  name: Clock$Reventless.name,
+  eventSchema: Clock$Reventless.eventSchema
+})({
+  name: name$1,
+  moduleUrl: moduleUrl,
+  todoItemSchema: todoItemSchema,
+  commandSchema: commandSchema,
+  maxRetries: 2,
+  heartbeatInterval: 60,
+  targetName: targetName,
+  schedule: undefined
+})({
+  collect: collect$1,
+  resolve: resolve$1,
+  reschedule: reschedule$1
+});
+
+function process$1(_id, _item, param) {
+  
+}
+
+function onExhausted$1(_id, _item) {
+  
+}
+
+let moduleUrl$2 = import.meta.url;
+
+AutomationSlice$Reventless.Mappings.Make({
+  name: name$1,
+  moduleUrl: moduleUrl,
+  todoItemSchema: todoItemSchema,
+  commandSchema: commandSchema,
+  maxRetries: 2,
+  heartbeatInterval: 60,
+  targetName: targetName,
+  schedule: undefined
+});
+
+let mappings$1 = [FromClockUnscheduled];
+
+let UnscheduledAutomation = {
+  process: process$1,
+  onExhausted: onExhausted$1,
+  moduleUrl: moduleUrl$2,
+  mappings: mappings$1
+};
+
+let Bus = LocalBus$ReventlessLocal.Make({});
+
+TestRunner$ReventlessLocal.setup();
+
+let AutomationSliceMaker = AutomationSlice_Builder$ReventlessLocal.Make(Bus);
+
+let DemandReport = AutomationSliceMaker.Make(DemandReportSpec)(DemandReportAutomation);
+
+let Unscheduled = AutomationSliceMaker.Make({
+  name: name$1,
+  moduleUrl: moduleUrl,
+  todoItemSchema: todoItemSchema,
+  commandSchema: commandSchema,
+  maxRetries: 2,
+  heartbeatInterval: 60,
+  targetName: targetName,
+  schedule: undefined
+})(UnscheduledAutomation);
+
+let publishedCommands = {
+  contents: []
+};
+
+async function publishJsons(cmds) {
+  publishedCommands.contents = publishedCommands.contents.concat(cmds);
+}
+
+function context(sliceName) {
+  return {
+    environment: "local",
+    platformName: "local",
+    pluginName: "TestPlugin",
+    sliceName: sliceName
+  };
+}
+
+function makeSlice() {
+  return DemandReport.make({}, Pulumi.output(publishJsons), context(name), undefined, undefined);
+}
+
+function makeUnscheduled() {
+  return Unscheduled.make({}, Pulumi.output(publishJsons), context(name$1), undefined, undefined);
+}
+
+function storedRow(id) {
+  return Stdlib_Option.map(Stdlib_Option.getOr(Stdlib_Option.map(Bus.getQueryDbScan(DemandReport.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 {
+  DemandReportSpec,
+  FromClock,
+  DemandReportAutomation,
+  UnscheduledSpec,
+  FromClockUnscheduled,
+  UnscheduledAutomation,
+  Bus,
+  AutomationSliceMaker,
+  DemandReport,
+  Unscheduled,
+  publishedCommands,
+  publishJsons,
+  context,
+  makeSlice,
+  makeUnscheduled,
+  storedRow,
+}
+/* moduleUrl Not a pure module */

package/tests/components/automationslice/AutomationScheduleTest.res

@@ -0,0 +1,88 @@
+// A declared schedule on the local platform: it ticks the slice at its time, a tick
+// delivered twice sends one command, a command left unanswered is sent again after
+// the timeout, and a slice that maps the Clock without a schedule is refused.
+
+open JestGlobals
+open AutomationScheduleFixtures
+
+module Callback = ReventlessCore.AutomationSlice_Callback
+
+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 morning = time("2026-10-16T06:00:00Z")
+let dayItem = "default@2026-10-16T06:00Z"
+
+let commandIds = () => publishedCommands.contents->Array.map(c => c.id)
+
+// Lets the tick's detached work and Effect's own scheduling run to the end.
+let settle = async () =>
+  for _ in 1 to 20 {
+    await jest->advanceTimersByTimeAsync(0.)
+  }
+
+describe("a declared schedule, 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-16T05:59:00Z"))
+    slice := Some(makeSlice())
+    let _ = await ops()
+    await settle()
+  })
+  let _ = afterAll(() => {
+    LocalAutomationSchedules.reset()
+    jest->useRealTimers
+  })
+
+  testPromise("ticks the slice at its time, and process requests the report", async () => {
+    await jest->advanceTimersByTimeAsync(59_000.)
+    await settle()
+    expect(commandIds())->toEqual([])
+
+    await jest->advanceTimersByTimeAsync(1_000.)
+    await settle()
+    expect(commandIds())->toEqual([dayItem])
+    expect(storedRow(dayItem)->Option.map(row => row.status))->toEqual(Some(Callback.Processing))
+  })
+
+  testPromise("the same tick delivered twice sends one command", async () => {
+    let ops = await ops()
+    await ops.tick(~key=Reventless.Clock.defaultKey, ~at=morning)
+    await settle()
+    expect(commandIds())->toEqual([dayItem])
+  })
+
+  testPromise("a command left unanswered is sent again after the timeout", async () => {
+    await LocalAutomationSweep.sweepOnce()
+    expect(commandIds())->toEqual([dayItem])
+
+    jest->setSystemTime(Date.now() +. 15. *. 60_000.)
+    await LocalAutomationSweep.sweepOnce()
+    expect(commandIds())->toEqual([dayItem, dayItem])
+    expect(storedRow(dayItem)->Option.map(row => (row.status, row.retryCount)))->toEqual(
+      Some((Callback.Processing, 1)),
+    )
+  })
+
+  testSync("a slice that maps the Clock without a schedule is refused", () => {
+    let refusal = switch makeUnscheduled() {
+    | _ => None
+    | exception JsExn(err) => err->JsExn.message
+    }
+    expect(
+      refusal->Option.map(
+        m => m->String.includes("maps the Clock source but declares no schedule"),
+      ),
+    )->toEqual(Some(true))
+  })
+})

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

@@ -0,0 +1,108 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stdlib_JsExn from "@rescript/runtime/lib/es6/Stdlib_JsExn.js";
+import * as Globals from "@jest/globals";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Clock$Reventless from "@reventlessdev/reventless-spec/src/components/Clock.res.mjs";
+import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
+import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.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 LocalAutomationSchedules$ReventlessLocal from "../../../src/components/LocalAutomationSchedules.res.mjs";
+import * as AutomationScheduleFixtures$ReventlessLocal from "./AutomationScheduleFixtures.res.mjs";
+
+function time(iso) {
+  return new Date(iso).getTime();
+}
+
+let morning = new Date("2026-10-16T06:00:00Z").getTime();
+
+let dayItem = "default@2026-10-16T06:00Z";
+
+function commandIds() {
+  return AutomationScheduleFixtures$ReventlessLocal.publishedCommands.contents.map(c => c.id);
+}
+
+async function settle() {
+  for (let _for = 1; _for <= 20; ++_for) {
+    await Globals.jest.advanceTimersByTimeAsync(0);
+  }
+}
+
+globalThis.describe("a declared schedule, 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-16T05:59:00Z").getTime());
+    slice.contents = Primitive_option.some(AutomationScheduleFixtures$ReventlessLocal.makeSlice());
+    await ops();
+    return await settle();
+  });
+  globalThis.afterAll(() => {
+    LocalAutomationSchedules$ReventlessLocal.reset();
+    Globals.jest.useRealTimers();
+  });
+  globalThis.test("ticks the slice at its time, and process requests the report", async () => {
+    await Globals.jest.advanceTimersByTimeAsync(59000);
+    await settle();
+    globalThis.expect(commandIds()).toEqual([]);
+    await Globals.jest.advanceTimersByTimeAsync(1000);
+    await settle();
+    globalThis.expect(commandIds()).toEqual([dayItem]);
+    globalThis.expect(Stdlib_Option.map(AutomationScheduleFixtures$ReventlessLocal.storedRow(dayItem), row => row.status)).toEqual("Processing");
+  });
+  globalThis.test("the same tick delivered twice sends one command", async () => {
+    let ops$1 = await ops();
+    await ops$1.tick(Clock$Reventless.defaultKey, morning);
+    await settle();
+    globalThis.expect(commandIds()).toEqual([dayItem]);
+  });
+  globalThis.test("a command left unanswered is sent again after the timeout", async () => {
+    await LocalAutomationSweep$ReventlessLocal.sweepOnce();
+    globalThis.expect(commandIds()).toEqual([dayItem]);
+    Globals.jest.setSystemTime(Date.now() + 15 * 60000);
+    await LocalAutomationSweep$ReventlessLocal.sweepOnce();
+    globalThis.expect(commandIds()).toEqual([
+      dayItem,
+      dayItem
+    ]);
+    globalThis.expect(Stdlib_Option.map(AutomationScheduleFixtures$ReventlessLocal.storedRow(dayItem), row => [
+      row.status,
+      row.retryCount
+    ])).toEqual([
+      "Processing",
+      1
+    ]);
+  });
+  globalThis.test("a slice that maps the Clock without a schedule is refused", () => {
+    let refusal;
+    try {
+      AutomationScheduleFixtures$ReventlessLocal.makeUnscheduled();
+      refusal = undefined;
+    } catch (raw_err) {
+      let err = Primitive_exceptions.internalToException(raw_err);
+      if (err.RE_EXN_ID === "JsExn") {
+        refusal = Stdlib_JsExn.message(err._1);
+      } else {
+        throw err;
+      }
+    }
+    globalThis.expect(Stdlib_Option.map(refusal, m => m.includes("maps the Clock source but declares no schedule"))).toEqual(true);
+  });
+});
+
+let Callback;
+
+export {
+  Callback,
+  time,
+  morning,
+  dayItem,
+  commandIds,
+  settle,
+}
+/* morning Not a pure module */

package/tests/components/automationslice/AutomationSliceFixtures.res

@@ -41,6 +41,7 @@ module ShipOrderSpec = {
   let maxRetries = 3
   let heartbeatInterval = 60
   let targetName = "CreateShipment"
+  let schedule = None
 }
 
 module SkipProcessSpec = {
@@ -56,6 +57,7 @@ module SkipProcessSpec = {
   let maxRetries = 0
   let heartbeatInterval = 60
   let targetName = "Noop"
+  let schedule = None
 }
 
 // ─────────────────────────────────────────────────────────────
@@ -84,6 +86,7 @@ module ShipOrderMapping = Reventless.AutomationSlice.Mapping.Make(
       | ShipmentCreated({orderId}) => Some(orderId)
       | OrderPlaced(_) => None
       }
+    let reschedule = _ => []
   },
 )
 
@@ -101,6 +104,7 @@ module SkipProcessMapping = Reventless.AutomationSlice.Mapping.Make(
       | ShipmentCreated({orderId}) => Some(orderId)
       | OrderPlaced(_) => None
       }
+    let reschedule = _ => []
   },
 )
 

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

@@ -77,6 +77,7 @@ let ShipOrderSpec = {
   maxRetries: 3,
   heartbeatInterval: 60,
   targetName: "CreateShipment",
+  schedule: undefined,
   authorizationOf: authorizationOf,
   commandTransition: commandTransition,
   traits: traits
@@ -108,6 +109,7 @@ let SkipProcessSpec = {
   maxRetries: 0,
   heartbeatInterval: 60,
   targetName: "Noop",
+  schedule: undefined,
   authorizationOf: authorizationOf$1,
   commandTransition: commandTransition$1,
   traits: traits$1
@@ -135,13 +137,18 @@ function resolve(event) {
   }
 }
 
+function reschedule(param) {
+  return [];
+}
+
 let ShipOrderMapping = AutomationSlice$Reventless.Mapping.Make({
   Id: Id$Reventless.$$String,
   name: name,
   eventSchema: eventSchema
 })(ShipOrderSpec)({
   collect: collect,
-  resolve: resolve
+  resolve: resolve,
+  reschedule: reschedule
 });
 
 function collect$1(event, param, _ctx) {
@@ -165,13 +172,18 @@ function resolve$1(event) {
   }
 }
 
+function reschedule$1(param) {
+  return [];
+}
+
 let SkipProcessMapping = AutomationSlice$Reventless.Mapping.Make({
   Id: Id$Reventless.$$String,
   name: name$1,
   eventSchema: eventSchema$1
 })(SkipProcessSpec)({
   collect: collect$1,
-  resolve: resolve$1
+  resolve: resolve$1,
+  reschedule: reschedule$1
 });
 
 function process(id, _item, param) {

package/tests/components/automationslice/AutomationSliceSelfDeadlockFixtures.res

@@ -136,6 +136,7 @@ module AutoShipSpec = {
   let maxRetries = 3
   let heartbeatInterval = 60
   let targetName = "Ship"
+  let schedule = None
 }
 
 module FromDcb = AutomationSlice.Mapping.Make(
@@ -152,6 +153,7 @@ module FromDcb = AutomationSlice.Mapping.Make(
       | Shipped({orderId}) => Some(orderId)
       | Placed(_) => None
       }
+    let reschedule = _ => []
   },
 )
 

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

@@ -243,6 +243,7 @@ let AutoShipSpec = {
   maxRetries: 3,
   heartbeatInterval: 60,
   targetName: "Ship",
+  schedule: undefined,
   authorizationOf: authorizationOf$2,
   commandTransition: commandTransition$2,
   traits: traits$2
@@ -269,13 +270,18 @@ function resolve(event) {
   }
 }
 
+function reschedule(param) {
+  return [];
+}
+
 let FromDcb = AutomationSlice$Reventless.Mapping.Make({
   Id: Id$Reventless.$$String,
   name: name$2,
   eventSchema: eventSchema$2
 })(AutoShipSpec)({
   collect: collect,
-  resolve: resolve
+  resolve: resolve,
+  reschedule: reschedule
 });
 
 function process(id, _item, param) {