@reventlessdev/reventless-core 3.0.0-alpha.294 → 3.0.0-alpha.296

package/src/components/AutomationSlice/AutomationSlice_Callback.res

@@ -93,8 +93,35 @@ type runtime = {
   todoItems: Dict.t<todoRow>,
   phase1: phase1,
   phase2: phase2,
+  /** The slice's schedules, by key: what its schedules store holds. */
+  schedules: Dict.t<AutomationSlice_Schedules.row>,
+  /** What phase 1 changed in `schedules` since the last call, for the platform to
+      follow once the rows are stored. */
+  takeScheduleChanges: unit => array<AutomationSlice_Schedules.platformChange>,
+  /** Folds the given events' `reschedule` into empty rows, in order: a rebuild. */
+  rebuildSchedules: array<JSON.t> => unit,
 }
 
+/** A tick as the runtime receives an event: an envelope from the `Clock`
+    source, recorded at the scheduled time. */
+let tickEvent = (~key, ~at) =>
+  JSON.Encode.object(
+    Dict.fromArray([
+      ("id", key->JSON.Encode.string),
+      (
+        "meta",
+        {
+          ...Message.generateMeta(~service=Reventless.Clock.name),
+          time: at->Date.fromTime->Date.toISOString,
+        }->Reventless.Util_Sury.toJson(Reventless.Message.metaSchema),
+      ),
+      (
+        "event",
+        Reventless.Clock.Tick({key, at})->Reventless.Util_Sury.toJson(Reventless.Clock.eventSchema),
+      ),
+    ]),
+  )
+
 module type T = {
   module Spec: Reventless.AutomationSlice.Spec
   module Automation: Reventless.AutomationSlice.Automation with module Spec := Spec
@@ -108,6 +135,10 @@ module type T = {
 
   /** Phase 2: process all pending items, publishing commands via publishJsons. */
   let phase2: phase2
+
+  let schedules: Dict.t<AutomationSlice_Schedules.row>
+  let takeScheduleChanges: unit => array<AutomationSlice_Schedules.platformChange>
+  let rebuildSchedules: array<JSON.t> => unit
 }
 
 module Make = (
@@ -118,6 +149,20 @@ module Make = (
   module Automation = Automation
 
   let todoItems: Dict.t<todoRow> = Dict.make()
+  let schedules: Dict.t<AutomationSlice_Schedules.row> = Dict.make()
+  let scheduleChanges: ref<array<AutomationSlice_Schedules.platformChange>> = ref([])
+
+  let takeScheduleChanges = () => {
+    let changes = scheduleChanges.contents
+    scheduleChanges := []
+    changes
+  }
+
+  // Only a slice that maps the Clock can receive the ticks a schedule sends.
+  let readsClock =
+    Automation.mappings->Array.some((module(M: Automation.Mapping)) =>
+      M.sourceName == Reventless.Clock.name
+    )
 
   let now = () => Date.make()->Date.toISOString
 
@@ -133,6 +178,10 @@ module Make = (
   // the slice here makes the target's own events unmatchable, silently.
   let makeMeta = (): Reventless.Message.meta => Message.generateMeta(~service=Spec.targetName)
 
+  /** How long a row may stay `Processing` before its command is sent again. */
+  let processingTimeoutMs =
+    15. *. 60. *. 1000.
+
   /** Record a failed attempt. The row is marked `Abandoned` at the moment the
       budget runs out rather than being left to fall out of the next pass's
       filter, so a reader never has to compare `retryCount` against a constant
@@ -168,6 +217,13 @@ module Make = (
 
   module Route = AutomationSlice_Route.Make(Spec, Automation)
 
+  // An event's recorded time, from its envelope's ISO `meta.time`.
+  let recordedAtOf = time =>
+    switch Date.fromString(time)->Date.getTime {
+    | millis if Float.isNaN(millis) => None
+    | millis => Some(millis)
+    }
+
   let apply = ({collected, resolved}: AutomationSlice_Route.routed<Spec.todoItem>) => {
     // Collect — append new items keyed by ID; first writer wins (idempotent).
     collected->Array.forEach(((id, item)) => {
@@ -194,9 +250,39 @@ module Make = (
     )
   }
 
-  let phase1 = (events: array<JSON.t>, ctx: Reventless.AutomationSlice.context) => {
+  let reschedule = (
+    routed: array<AutomationSlice_Route.routed<Spec.todoItem>>,
+    ~setBy,
+    ~recordedAt,
+  ) =>
+    routed->Array.forEach(r =>
+      r.rescheduled->Array.forEach(change =>
+        if !readsClock {
+          EffectLogger.logError(
+            ~comp=`AutomationSlice(${Spec.name})`,
+            `a mapping changed a schedule, but no mapping reads the Clock, so no tick would reach the slice; the change is skipped`,
+          )->Effect.runSync
+        } else {
+          switch schedules->AutomationSlice_Schedules.apply(change, ~setBy, ~recordedAt) {
+          | Ok(platformChange) =>
+            scheduleChanges := scheduleChanges.contents->Array.concat([platformChange])
+          | Error(message) =>
+            EffectLogger.logError(
+              ~comp=`AutomationSlice(${Spec.name})`,
+              `${message}; the change is skipped`,
+            )->Effect.runSync
+          }
+        }
+      )
+    )
+
+  let phase1 = (events: array<JSON.t>, sliceCtx: Reventless.AutomationSlice.context) => {
     events->Array.forEach(json => {
       let context = json->Message.decode(Reventless.Message.contextSchema)
+      let ctx = switch recordedAtOf(context.meta.time) {
+      | Some(recordedAt) => {...sliceCtx, recordedAt}
+      | None => sliceCtx
+      }
       let sourceName = context.meta.service
       // Events arrive as `{id, meta, event}` envelopes (see Message.composeEventJson').
       // Per-mapping decoders work on the inner `event` payload (TAG + fields at
@@ -206,16 +292,63 @@ module Make = (
       | None => json
       }
       // Multiple mappings can share a sourceName; all matching dispatches run.
-      Route.route(eventPayload, ~sourceName, ~sourceId=context.id, ctx)->Array.forEach(apply)
+      let routed = Route.route(eventPayload, ~sourceName, ~sourceId=context.id, ctx)
+      routed->Array.forEach(apply)
+      reschedule(
+        routed,
+        ~setBy=context.meta.msgId,
+        ~recordedAt=ctx.recordedAt->Option.getOr(Date.now()),
+      )
+
+      // A tick's envelope is addressed by its key.
+      if sourceName == Reventless.Clock.name {
+        schedules->AutomationSlice_Schedules.fired(~key=context.id)
+      }
     })
   }
 
+  let rebuildSchedules = (events: array<JSON.t>) => {
+    schedules->Dict.keysToArray->Array.forEach(key => schedules->Dict.delete(key))
+    events->Array.forEach(json => {
+      let context = json->Message.decode(Reventless.Message.contextSchema)
+      let eventPayload = switch json->JSON.Decode.object {
+      | Some(dict) => dict->Dict.get("event")->Option.getOr(json)
+      | None => json
+      }
+      let recordedAt = recordedAtOf(context.meta.time)->Option.getOr(Date.now())
+      Route.route(
+        eventPayload,
+        ~sourceName=context.meta.service,
+        ~sourceId=context.id,
+        {environment: "", platformName: "", pluginName: "", sliceName: Spec.name, recordedAt},
+      )->reschedule(~setBy=context.meta.msgId, ~recordedAt)
+    })
+    scheduleChanges := []
+  }
+
   let phase2 = async (publishJsons: ReventlessInfra.CommandTopic.publishJsons) => {
+    let currentTime = await Clock.currentTimeMillis->Effect.runPromise
     // A `Failed` row at or past the ceiling is one an older build left stranded,
     // or one whose Spec lowered `maxRetries` under it. Either way it is abandoned
     // in fact, so say so rather than letting it sit in a status that promises a
     // retry no pass will make.
     let newlyAbandoned: array<string> = []
+    // A command published but never answered leaves its row `Processing`. After
+    // the timeout that counts as a failed attempt, so this pass sends it again
+    // while the budget lasts.
+    todoItems
+    ->Dict.toArray
+    ->Array.forEach(((id, row)) =>
+      switch (row.status, row.processedAt->Option.map(t => Date.fromString(t)->Date.getTime)) {
+      | (Processing, Some(processedAt)) if currentTime -. processedAt >= processingTimeoutMs =>
+        let updated = row->afterFailedAttempt
+        todoItems->Dict.set(id, updated)
+        if updated.status == Abandoned {
+          newlyAbandoned->Array.push(id)
+        }
+      | _ => ()
+      }
+    )
     todoItems
     ->Dict.toArray
     ->Array.forEach(((id, row)) =>
@@ -247,7 +380,7 @@ module Make = (
       }
 
       item->Option.forEach(item => {
-        switch Automation.process(id, item) {
+        switch Automation.process(id, item, ~now=currentTime) {
         | Some((targetId, command)) =>
           todoItems->Dict.set(id, {...row, status: Processing, processedAt: now()})
           let commandJson = try command

package/src/components/AutomationSlice/AutomationSlice_Callback.res.mjs

@@ -1,11 +1,14 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
 import * as Sury from "sury";
+import * as Stdlib_Dict from "@rescript/runtime/lib/es6/Stdlib_Dict.js";
 import * as Stdlib_JSON from "@rescript/runtime/lib/es6/Stdlib_JSON.js";
 import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
 import * as Stdlib_JsExn from "@rescript/runtime/lib/es6/Stdlib_JsExn.js";
+import * as Clock from "effect/Clock";
 import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
 import * as Effect from "effect/Effect";
+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 Message$Reventless from "@reventlessdev/reventless-spec/src/types/Message.res.mjs";
 import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
@@ -13,6 +16,7 @@ import * as Util_Sury$Reventless from "@reventlessdev/reventless-spec/src/util/U
 import * as Message$ReventlessCore from "../../Message.res.mjs";
 import * as EffectLogger$ReventlessCore from "../../util/EffectLogger.res.mjs";
 import * as AutomationSlice_Route$ReventlessCore from "./AutomationSlice_Route.res.mjs";
+import * as AutomationSlice_Schedules$ReventlessCore from "./AutomationSlice_Schedules.res.mjs";
 
 let todoStatusSchema = Sury.union([
   Sury.literal("Pending"),
@@ -44,10 +48,43 @@ function todoRowSchemaFor(itemSchema) {
   }));
 }
 
+function tickEvent(key, at) {
+  let newrecord = {...Message$ReventlessCore.generateMeta(Clock$Reventless.name, undefined, undefined, undefined, undefined, undefined, undefined, undefined)};
+  return Object.fromEntries([
+    [
+      "id",
+      key
+    ],
+    [
+      "meta",
+      Util_Sury$Reventless.toJson((newrecord.time = new Date(at).toISOString(), newrecord), Message$Reventless.metaSchema)
+    ],
+    [
+      "event",
+      Util_Sury$Reventless.toJson({
+        TAG: "Tick",
+        key: key,
+        at: at
+      }, Clock$Reventless.eventSchema)
+    ]
+  ]);
+}
+
 function Make(Spec) {
   return Automation => {
     let todoItems = {};
+    let schedules = {};
+    let scheduleChanges = {
+      contents: []
+    };
+    let takeScheduleChanges = () => {
+      let changes = scheduleChanges.contents;
+      scheduleChanges.contents = [];
+      return changes;
+    };
+    let readsClock = Automation.mappings.some(M => M.sourceName === Clock$Reventless.name);
     let makeMeta = () => Message$ReventlessCore.generateMeta(Spec.targetName, undefined, undefined, undefined, undefined, undefined, undefined, undefined);
+    let processingTimeoutMs = 15 * 60 * 1000;
     let afterFailedAttempt = row => {
       let retryCount = row.retryCount + 1 | 0;
       let newrecord = {...row};
@@ -56,6 +93,14 @@ function Make(Spec) {
       return newrecord;
     };
     let Route = AutomationSlice_Route$ReventlessCore.Make(Spec)(Automation);
+    let recordedAtOf = time => {
+      let millis = new Date(time).getTime();
+      if (Number.isNaN(millis)) {
+        return;
+      } else {
+        return millis;
+      }
+    };
     let apply = param => {
       param.collected.forEach(param => {
         let id = param[0];
@@ -82,17 +127,86 @@ function Make(Spec) {
         todoItems[id] = newrecord;
       }));
     };
-    let phase1 = (events, ctx) => {
+    let reschedule = (routed, setBy, recordedAt) => {
+      routed.forEach(r => {
+        r.rescheduled.forEach(change => {
+          if (!readsClock) {
+            return Effect.runSync(EffectLogger$ReventlessCore.logError(`AutomationSlice(` + Spec.name + `)`, undefined, `a mapping changed a schedule, but no mapping reads the Clock, so no tick would reach the slice; the change is skipped`));
+          }
+          let platformChange = AutomationSlice_Schedules$ReventlessCore.apply(schedules, change, setBy, recordedAt);
+          if (platformChange.TAG === "Ok") {
+            scheduleChanges.contents = scheduleChanges.contents.concat([platformChange._0]);
+            return;
+          } else {
+            return Effect.runSync(EffectLogger$ReventlessCore.logError(`AutomationSlice(` + Spec.name + `)`, undefined, platformChange._0 + `; the change is skipped`));
+          }
+        });
+      });
+    };
+    let phase1 = (events, sliceCtx) => {
       events.forEach(json => {
         let context = Message$ReventlessCore.decode(json, Message$Reventless.contextSchema);
+        let recordedAt = recordedAtOf(context.meta.time);
+        let ctx;
+        if (recordedAt !== undefined) {
+          let newrecord = {...sliceCtx};
+          newrecord.recordedAt = recordedAt;
+          ctx = newrecord;
+        } else {
+          ctx = sliceCtx;
+        }
         let sourceName = context.meta.service;
         let dict = Stdlib_JSON.Decode.object(json);
         let eventPayload = dict !== undefined ? Stdlib_Option.getOr(dict["event"], json) : json;
-        Route.route(eventPayload, sourceName, context.id, ctx).forEach(apply);
+        let routed = Route.route(eventPayload, sourceName, context.id, ctx);
+        routed.forEach(apply);
+        reschedule(routed, context.meta.msgId, Stdlib_Option.getOr(ctx.recordedAt, Date.now()));
+        if (sourceName === Clock$Reventless.name) {
+          return AutomationSlice_Schedules$ReventlessCore.fired(schedules, context.id);
+        }
+      });
+    };
+    let rebuildSchedules = events => {
+      Object.keys(schedules).forEach(key => Stdlib_Dict.$$delete(schedules, key));
+      events.forEach(json => {
+        let context = Message$ReventlessCore.decode(json, Message$Reventless.contextSchema);
+        let dict = Stdlib_JSON.Decode.object(json);
+        let eventPayload = dict !== undefined ? Stdlib_Option.getOr(dict["event"], json) : json;
+        let recordedAt = Stdlib_Option.getOr(recordedAtOf(context.meta.time), Date.now());
+        reschedule(Route.route(eventPayload, context.meta.service, context.id, {
+          environment: "",
+          platformName: "",
+          pluginName: "",
+          sliceName: Spec.name,
+          recordedAt: recordedAt
+        }), context.meta.msgId, recordedAt);
       });
+      scheduleChanges.contents = [];
     };
     let phase2 = async publishJsons => {
+      let currentTime = await Effect.runPromise(Clock.currentTimeMillis);
       let newlyAbandoned = [];
+      Object.entries(todoItems).forEach(param => {
+        let row = param[1];
+        let id = param[0];
+        let match = row.status;
+        let match$1 = Stdlib_Option.map(row.processedAt, t => new Date(t).getTime());
+        if (match !== "Processing") {
+          return;
+        }
+        if (match$1 === undefined) {
+          return;
+        }
+        if (currentTime - match$1 < processingTimeoutMs) {
+          return;
+        }
+        let updated = afterFailedAttempt(row);
+        todoItems[id] = updated;
+        if (updated.status === "Abandoned") {
+          newlyAbandoned.push(id);
+          return;
+        }
+      });
       Object.entries(todoItems).forEach(param => {
         let row = param[1];
         if (!(row.status === "Failed" && row.retryCount >= Spec.maxRetries)) {
@@ -128,7 +242,7 @@ function Make(Spec) {
           item = undefined;
         }
         Stdlib_Option.forEach(item, item => {
-          let match = Automation.process(id, item);
+          let match = Automation.process(id, item, currentTime);
           if (match === undefined) {
             return;
           }
@@ -225,7 +339,10 @@ function Make(Spec) {
       Spec: Spec,
       todoItems: todoItems,
       phase1: phase1,
-      phase2: phase2
+      phase2: phase2,
+      schedules: schedules,
+      takeScheduleChanges: takeScheduleChanges,
+      rebuildSchedules: rebuildSchedules
     };
   };
 }
@@ -234,6 +351,7 @@ export {
   todoStatusSchema,
   todoRowSchema,
   todoRowSchemaFor,
+  tickEvent,
   Make,
 }
 /* todoStatusSchema Not a pure module */

package/src/components/AutomationSlice/AutomationSlice_Route.res

@@ -1,4 +1,4 @@
-// Decode one source event and run its mappings' `collect`/`resolve`, with no
+// Decode one source event and run its mappings' `collect`/`resolve`/`reschedule`, with no
 // side effects. Shared by the runtime callback, which applies the result to its
 // to-do list, and by the GWT sweep, which must route exactly as the runtime does.
 
@@ -6,6 +6,7 @@
 type routed<'item> = {
   collected: array<(string, 'item)>,
   resolved: option<string>,
+  rescheduled: array<Reventless.AutomationSlice.scheduleChange>,
 }
 
 module Make = (
@@ -31,6 +32,7 @@ module Make = (
       decoder.decode(~eventType, ~data=dataDict)->Option.map(event => {
         collected: M.collect(event, ~sourceId, ctx),
         resolved: M.resolve(event),
+        rescheduled: M.reschedule(event),
       })
     }
     {sourceName: M.sourceName, handle}

package/src/components/AutomationSlice/AutomationSlice_Route.res.mjs

@@ -13,7 +13,8 @@ function Make(Spec) {
         let match = Message$ReventlessCore.splitMessage(json);
         return Stdlib_Option.map(decoder.decode(match[0], match[1]), event => ({
           collected: M.collect(event, sourceId, ctx),
-          resolved: M.resolve(event)
+          resolved: M.resolve(event),
+          rescheduled: M.reschedule(event)
         }));
       };
       return {

package/src/components/AutomationSlice/AutomationSlice_Schedules.res

@@ -0,0 +1,149 @@
+// The schedules of one automation slice: a row per key, kept in the slice's schedules
+// store. The rows are the truth and the platform's schedules follow them. Shared by
+// the runtime and the GWT DSL, so a scenario folds `reschedule` as the runtime does.
+
+/** The `setBy` of the row a spec's declared `schedule` writes. */
+let declared = "declared"
+
+@schema
+type row = {
+  key: string,
+  /** The time as the JSON text of `Reventless.Schedule.timeSchema`, an `After` set by an event
+      already counted from when the event was recorded. Absent when an event cleared
+      the slice-wide key, so a deploy does not put the declared time back. */
+  time?: string,
+  /** The id of the event that set or cleared it, or `declared`. */
+  setBy: string,
+  setAt: string,
+}
+
+/** What the platform is told after a row changed. */
+type platformChange =
+  | Put({key: string, time: Reventless.Schedule.time})
+  | Remove({key: string})
+
+let encodeTime = (time: Reventless.Schedule.time) =>
+  time->Reventless.Util_Sury.toJson(Reventless.Schedule.timeSchema)->JSON.stringify
+let decodeTime = (text: string): Reventless.Schedule.time =>
+  text->JSON.parseOrThrow->Reventless.Util_Sury.fromJson(Reventless.Schedule.timeSchema)
+let timeOf = (row: row) => row.time->Option.map(decodeTime)
+
+let iso = millis => millis->Date.fromTime->Date.toISOString
+
+// The slice-wide key keeps a row saying it was cleared; any other key's row goes.
+let clearRow = (rows: dict<row>, ~key, ~setBy, ~setAt) =>
+  if key == Reventless.Clock.defaultKey {
+    rows->Dict.set(key, {key, setBy, setAt})
+  } else {
+    rows->Dict.delete(key)
+  }
+
+/**
+Applies one change an event made, recorded at `recordedAt`, and returns what the
+platform is told. A time that cannot fire is refused with every problem it has, and
+changes nothing.
+*/
+let apply = (
+  rows: dict<row>,
+  change: Reventless.AutomationSlice.scheduleChange,
+  ~setBy,
+  ~recordedAt,
+): result<platformChange, string> =>
+  switch change {
+  | Set({key, time: wanted}) =>
+    switch ScheduleTime.errors(wanted) {
+    | [] =>
+      let resolved = wanted->ScheduleTime.resolveOnce(~from=recordedAt)
+      rows->Dict.set(key, {key, time: encodeTime(resolved), setBy, setAt: iso(recordedAt)})
+      Ok(Put({key, time: resolved}))
+    | errs => Error(`schedule ${key}: ${errs->Array.join("; ")}`)
+    }
+  | Clear({key: cleared}) =>
+    clearRow(rows, ~key=cleared, ~setBy, ~setAt=iso(recordedAt))
+    Ok(Remove({key: cleared}))
+  }
+
+/** A tick of `key` arrived: a once-only schedule has fired, so its row goes. */
+let fired = (rows: dict<row>, ~key) =>
+  rows
+  ->Dict.get(key)
+  ->Option.forEach(row =>
+    switch row->timeOf {
+    | Some(Once(_)) => clearRow(rows, ~key, ~setBy=row.setBy, ~setAt=row.setAt)
+    | _ => ()
+    }
+  )
+
+/**
+Brings the spec's declared time into the rows under `Reventless.Clock.defaultKey`: written when
+no event has set or cleared that key, replaced when the declaration changed, and
+removed when the spec no longer declares one.
+*/
+let declare = (rows: dict<row>, declaredTime: option<Reventless.Schedule.time>, ~now) => {
+  let key = Reventless.Clock.defaultKey
+  let write = time =>
+    rows->Dict.set(key, {key, time: encodeTime(time), setBy: declared, setAt: iso(now)})
+  switch (declaredTime, rows->Dict.get(key)) {
+  | (Some(time), None) => write(time)
+  | (Some(time), Some(row)) if row.setBy == declared && row.time != Some(encodeTime(time)) =>
+    write(time)
+  | (None, Some(row)) if row.setBy == declared => rows->Dict.delete(key)
+  | _ => ()
+  }
+}
+
+// A once-only time already past fires no more.
+let isPast = (time: Reventless.Schedule.time, ~now) =>
+  switch time {
+  | Once(_) => time->ScheduleTime.nextFiring(~after=now)->Option.isNone
+  | _ => false
+  }
+
+/**
+Brings the platform in line with the rows, after the declared time is brought in: a
+schedule missing from the platform is put, the declared one is put again in case its
+time changed, and one the rows do not hold is removed. A once-only time already past
+is not put again, and its row goes. A row an event changed reached the platform when
+it changed, so it is not put again.
+*/
+let reconcile = async (
+  rows: dict<row>,
+  platform: ReventlessInfra.AutomationSlice.platformSchedules,
+  ~declaredTime,
+  ~now,
+) => {
+  declare(rows, declaredTime, ~now)
+  let live =
+    rows
+    ->Dict.valuesToArray
+    ->Array.filterMap(row =>
+      switch row->timeOf {
+      | Some(time) if isPast(time, ~now) =>
+        clearRow(rows, ~key=row.key, ~setBy=row.setBy, ~setAt=row.setAt)
+        None
+      | Some(time) => Some((row, time))
+      | None => None
+      }
+    )
+  let held = await platform.names()
+  for i in 0 to live->Array.length - 1 {
+    let (row, time) = live->Array.getUnsafe(i)
+    if row.setBy == declared || !(held->Array.includes(platform.nameOf(row.key))) {
+      await platform.put(~key=row.key, time)
+    }
+  }
+  let wanted = live->Array.map(((row, _)) => platform.nameOf(row.key))
+  let extra = held->Array.filter(name => !(wanted->Array.includes(name)))
+  for i in 0 to extra->Array.length - 1 {
+    await platform.removeName(extra->Array.getUnsafe(i))
+  }
+}
+
+/** Tells the platform what the rows' changes were, in order. */
+let tell = async (platform: ReventlessInfra.AutomationSlice.platformSchedules, changes) =>
+  for i in 0 to changes->Array.length - 1 {
+    switch changes->Array.getUnsafe(i) {
+    | Put({key, time}) => await platform.put(~key, time)
+    | Remove({key}) => await platform.removeName(platform.nameOf(key))
+    }
+  }