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

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

@@ -1,12 +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";
@@ -14,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"),
@@ -45,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};
@@ -91,6 +127,22 @@ function Make(Spec) {
         todoItems[id] = newrecord;
       }));
     };
+    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);
@@ -106,12 +158,55 @@ function Make(Spec) {
         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)) {
@@ -244,7 +339,10 @@ function Make(Spec) {
       Spec: Spec,
       todoItems: todoItems,
       phase1: phase1,
-      phase2: phase2
+      phase2: phase2,
+      schedules: schedules,
+      takeScheduleChanges: takeScheduleChanges,
+      rebuildSchedules: rebuildSchedules
     };
   };
 }
@@ -253,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))
+    }
+  }

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

@@ -0,0 +1,193 @@
+// 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_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
+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_object from "@rescript/runtime/lib/es6/Primitive_object.js";
+import * as Schedule$Reventless from "@reventlessdev/reventless-spec/src/types/Schedule.res.mjs";
+import * as Util_Sury$Reventless from "@reventlessdev/reventless-spec/src/util/Util_Sury.res.mjs";
+import * as ScheduleTime$ReventlessCore from "../../util/ScheduleTime.res.mjs";
+
+let declared = "declared";
+
+let rowSchema = Sury.$schema(s => ({
+  key: s.m(Sury.string),
+  time: s.m(Sury.$option(Sury.string)),
+  setBy: s.m(Sury.string),
+  setAt: s.m(Sury.string)
+}));
+
+function encodeTime(time) {
+  return JSON.stringify(Util_Sury$Reventless.toJson(time, Schedule$Reventless.timeSchema));
+}
+
+function decodeTime(text) {
+  return Util_Sury$Reventless.fromJson(JSON.parse(text), Schedule$Reventless.timeSchema);
+}
+
+function timeOf(row) {
+  return Stdlib_Option.map(row.time, decodeTime);
+}
+
+function iso(millis) {
+  return new Date(millis).toISOString();
+}
+
+function clearRow(rows, key, setBy, setAt) {
+  if (key === Clock$Reventless.defaultKey) {
+    rows[key] = {
+      key: key,
+      setBy: setBy,
+      setAt: setAt
+    };
+    return;
+  } else {
+    return Stdlib_Dict.$$delete(rows, key);
+  }
+}
+
+function apply(rows, change, setBy, recordedAt) {
+  if (change.TAG === "Set") {
+    let wanted = change.time;
+    let key = change.key;
+    let errs = ScheduleTime$ReventlessCore.errors(wanted);
+    if (errs.length !== 0) {
+      return {
+        TAG: "Error",
+        _0: `schedule ` + key + `: ` + errs.join("; ")
+      };
+    }
+    let resolved = ScheduleTime$ReventlessCore.resolveOnce(wanted, recordedAt);
+    rows[key] = {
+      key: key,
+      time: encodeTime(resolved),
+      setBy: setBy,
+      setAt: new Date(recordedAt).toISOString()
+    };
+    return {
+      TAG: "Ok",
+      _0: {
+        TAG: "Put",
+        key: key,
+        time: resolved
+      }
+    };
+  }
+  let cleared = change.key;
+  clearRow(rows, cleared, setBy, new Date(recordedAt).toISOString());
+  return {
+    TAG: "Ok",
+    _0: {
+      TAG: "Remove",
+      key: cleared
+    }
+  };
+}
+
+function fired(rows, key) {
+  Stdlib_Option.forEach(rows[key], row => {
+    let match = Stdlib_Option.map(row.time, decodeTime);
+    if (match === undefined) {
+      return;
+    }
+    switch (match.TAG) {
+      case "Every" :
+      case "Calendar" :
+        return;
+      case "Once" :
+        return clearRow(rows, key, row.setBy, row.setAt);
+    }
+  });
+}
+
+function declare(rows, declaredTime, now) {
+  let match = rows[Clock$Reventless.defaultKey];
+  if (declaredTime !== undefined) {
+    if (match !== undefined && !(match.setBy === declared && Primitive_object.notequal(match.time, encodeTime(declaredTime)))) {
+      return;
+    } else {
+      rows[Clock$Reventless.defaultKey] = {
+        key: Clock$Reventless.defaultKey,
+        time: encodeTime(declaredTime),
+        setBy: declared,
+        setAt: new Date(now).toISOString()
+      };
+      return;
+    }
+  } else if (match !== undefined && match.setBy === declared) {
+    return Stdlib_Dict.$$delete(rows, Clock$Reventless.defaultKey);
+  } else {
+    return;
+  }
+}
+
+function isPast(time, now) {
+  switch (time.TAG) {
+    case "Every" :
+    case "Calendar" :
+      return false;
+    case "Once" :
+      return Stdlib_Option.isNone(ScheduleTime$ReventlessCore.nextFiring(time, now));
+  }
+}
+
+async function reconcile(rows, platform, declaredTime, now) {
+  declare(rows, declaredTime, now);
+  let live = Stdlib_Array.filterMap(Object.values(rows), row => {
+    let time = Stdlib_Option.map(row.time, decodeTime);
+    if (time !== undefined) {
+      if (isPast(time, now)) {
+        clearRow(rows, row.key, row.setBy, row.setAt);
+        return;
+      } else {
+        return [
+          row,
+          time
+        ];
+      }
+    }
+  });
+  let held = await platform.names();
+  for (let i = 0, i_finish = live.length; i < i_finish; ++i) {
+    let match = live[i];
+    let row = match[0];
+    if (row.setBy === declared || !held.includes(platform.nameOf(row.key))) {
+      await platform.put(row.key, match[1]);
+    }
+  }
+  let wanted = live.map(param => platform.nameOf(param[0].key));
+  let extra = held.filter(name => !wanted.includes(name));
+  for (let i$1 = 0, i_finish$1 = extra.length; i$1 < i_finish$1; ++i$1) {
+    await platform.removeName(extra[i$1]);
+  }
+}
+
+async function tell(platform, changes) {
+  for (let i = 0, i_finish = changes.length; i < i_finish; ++i) {
+    let match = changes[i];
+    if (match.TAG === "Put") {
+      await platform.put(match.key, match.time);
+    } else {
+      await platform.removeName(platform.nameOf(match.key));
+    }
+  }
+}
+
+export {
+  declared,
+  rowSchema,
+  encodeTime,
+  decodeTime,
+  timeOf,
+  iso,
+  clearRow,
+  apply,
+  fired,
+  declare,
+  isPast,
+  reconcile,
+  tell,
+}
+/* rowSchema Not a pure module */

package/src/components/Dcb/Dcb_Builder.res

@@ -188,11 +188,13 @@ module Make = (
           // its own `sourceEventSchema`. Validation contributes one entry per
           // (slice, source) pair so unknown variants surface against the right
           // mapping context.
+          // The Clock's ticks come from the slice's schedules, not from a slice.
           automationSlices->Array.flatMap((module(A: AutomationSlice.T)) =>
-            A.Automation.mappings->Array.map((module(M: A.Automation.Mapping)) => (
-              A.Spec.name,
-              M.sourceEventSchema->S.castToUnknown,
-            ))
+            A.Automation.mappings->Array.filterMap((module(M: A.Automation.Mapping)) =>
+              M.sourceName == Reventless.Clock.name
+                ? None
+                : Some((A.Spec.name, M.sourceEventSchema->S.castToUnknown))
+            )
           ),
         )
         ->Array.concat(
@@ -664,6 +666,12 @@ module Make = (
       automationSlices->Array.forEach((module(A: AutomationSlice.T)) => {
         let qn = Api_Naming.queryFieldNamesForSliceQueryDb(~plugin=name, ~queryDbName=A.queryDbName)
         Plugin_Helpers.queryFieldNamesRegistry->Dict.set(A.queryDbName, qn)
+        A.schedulesDbName->Option.forEach(queryDbName =>
+          Plugin_Helpers.queryFieldNamesRegistry->Dict.set(
+            queryDbName,
+            Api_Naming.queryFieldNamesForSliceQueryDb(~plugin=name, ~queryDbName),
+          )
+        )
       })
 
       outboundTranslationSlices->Array.forEach((module(O: OutboundTranslationSlice.T)) => {
@@ -1144,6 +1152,21 @@ module Make = (
         }
       })
 
+      // A scheduled slice's schedules: when it runs, and who set it.
+      let scheduleEntries = automationSlices->Array.filterMap((module(A: AutomationSlice.T)) =>
+        A.schedulesDbName->Option.map(queryDbName => {
+          let qn = Api_Naming.queryFieldNamesForSliceQueryDb(~plugin=name, ~queryDbName)
+          {
+            ReventlessInfra.Api.singleFieldName: qn.singleFieldName,
+            listFieldName: qn.listFieldName,
+            returnTypeName: qn.returnTypeName,
+            stateSchema: AutomationSlice_Schedules.rowSchema->S.castToUnknown,
+            authorization: None,
+            connectionSpec: true,
+          }
+        })
+      )
+
       let outboundEntries =
         outboundTranslationSlices->Array.map((module(O: OutboundTranslationSlice.T)) => {
           let qn = Api_Naming.queryFieldNamesForSliceQueryDb(
@@ -1234,6 +1257,7 @@ module Make = (
         mutationEntries: Array.concat(mutationEntriesFromSlices, mutationEntriesFromInboundSlices),
         queryEntries: stateViewEntries
         ->Array.concat(automationEntries)
+        ->Array.concat(scheduleEntries)
         ->Array.concat(outboundEntries)
         ->Array.concat(inboundEntries),
         eventLogEntries: if allProducedSchemas->Array.length > 0 {

package/src/components/Dcb/Dcb_Builder.res.mjs

@@ -8,6 +8,7 @@ import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
 import * as Effect from "effect/Effect";
 import * as Pulumi from "@pulumi/pulumi";
 import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
+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 Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
 import * as DcbTag$Reventless from "@reventlessdev/reventless-spec/src/components/DcbTag.res.mjs";
@@ -25,6 +26,7 @@ import * as Plugin_Structure$ReventlessCore from "../../plugin/component/Plugin_
 import * as DcbEventLog_Builder$ReventlessCore from "../DcbEventLog/DcbEventLog_Builder.res.mjs";
 import * as CommandTopic_Builder$ReventlessCore from "../CommandTopic/CommandTopic_Builder.res.mjs";
 import * as AutomationSlice_Callback$ReventlessCore from "../AutomationSlice/AutomationSlice_Callback.res.mjs";
+import * as AutomationSlice_Schedules$ReventlessCore from "../AutomationSlice/AutomationSlice_Schedules.res.mjs";
 import * as CommandGenerator_Callback$ReventlessCore from "../CommandGenerator/CommandGenerator_Callback.res.mjs";
 import * as InboundTranslationSlice_Callback$ReventlessCore from "../InboundTranslationSlice/InboundTranslationSlice_Callback.res.mjs";
 import * as OutboundTranslationSlice_Callback$ReventlessCore from "../OutboundTranslationSlice/OutboundTranslationSlice_Callback.res.mjs";
@@ -150,10 +152,16 @@ function Make(DcbEventLogStorage) {
       ]).concat(stateViewSlices.map(V => [
         V.Spec.name,
         V.Spec.consumedEventSchema
-      ])).concat(automationSlices.flatMap(A => A.Automation.mappings.map(M => [
-        A.Spec.name,
-        M.sourceEventSchema
-      ]))).concat(outboundTranslationSlices.map(O => [
+      ])).concat(automationSlices.flatMap(A => Stdlib_Array.filterMap(A.Automation.mappings, M => {
+        if (M.sourceName === Clock$Reventless.name) {
+          return;
+        } else {
+          return [
+            A.Spec.name,
+            M.sourceEventSchema
+          ];
+        }
+      }))).concat(outboundTranslationSlices.map(O => [
         O.Spec.name,
         O.Spec.consumedEventSchema
       ]));
@@ -352,6 +360,9 @@ function Make(DcbEventLogStorage) {
       automationSlices.forEach(A => {
         let qn = Api_Naming$ReventlessCore.queryFieldNamesForSliceQueryDb(name, A.queryDbName, undefined);
         Plugin_Helpers$ReventlessCore.queryFieldNamesRegistry[A.queryDbName] = qn;
+        Stdlib_Option.forEach(A.schedulesDbName, queryDbName => {
+          Plugin_Helpers$ReventlessCore.queryFieldNamesRegistry[queryDbName] = Api_Naming$ReventlessCore.queryFieldNamesForSliceQueryDb(name, queryDbName, undefined);
+        });
       });
       outboundTranslationSlices.forEach(O => {
         let qn = Api_Naming$ReventlessCore.queryFieldNamesForSliceQueryDb(name, O.queryDbName, undefined);
@@ -612,6 +623,17 @@ function Make(DcbEventLogStorage) {
           connectionSpec: true
         };
       });
+      let scheduleEntries = Stdlib_Array.filterMap(automationSlices, A => Stdlib_Option.map(A.schedulesDbName, queryDbName => {
+        let qn = Api_Naming$ReventlessCore.queryFieldNamesForSliceQueryDb(name, queryDbName, undefined);
+        return {
+          singleFieldName: qn.singleFieldName,
+          listFieldName: qn.listFieldName,
+          returnTypeName: qn.returnTypeName,
+          stateSchema: AutomationSlice_Schedules$ReventlessCore.rowSchema,
+          authorization: undefined,
+          connectionSpec: true
+        };
+      }));
       let outboundEntries = outboundTranslationSlices.map(O => {
         let qn = Api_Naming$ReventlessCore.queryFieldNamesForSliceQueryDb(name, O.queryDbName, undefined);
         return {
@@ -655,7 +677,7 @@ function Make(DcbEventLogStorage) {
         dcbPublishJsons: publishJsons,
         dcbCommandTopicQueueUrl: dcbCommandTopicQueueUrl,
         mutationEntries: mutationEntriesFromSlices.concat(mutationEntriesFromInboundSlices),
-        queryEntries: stateViewEntries.concat(automationEntries).concat(outboundEntries).concat(inboundEntries),
+        queryEntries: stateViewEntries.concat(automationEntries).concat(scheduleEntries).concat(outboundEntries).concat(inboundEntries),
         eventLogEntries: allProducedSchemas.length !== 0 ? [{
               busKey: name + "DcbEventLog",
               displayName: name,