@reventlessdev/reventless-aws 3.0.0-alpha.381 → 3.0.0-alpha.383

package/src/adapter/Runtime/AutomationSliceEntryPoint_Ops.res.mjs

@@ -7,6 +7,7 @@ import * as Stdlib_JsExn from "@rescript/runtime/lib/es6/Stdlib_JsExn.js";
 import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
 import * as Effect from "effect/Effect";
 import * as Stream$1 from "effect/Stream";
+import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
 import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
 import * as DcbDecode$Reventless from "@reventlessdev/reventless-spec/src/components/DcbDecode.res.mjs";
 import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
@@ -20,11 +21,13 @@ import * as Secrets_Node_Backend$ReventlessCore from "@reventlessdev/reventless-
 import * as Util_DynamoDb_Runtime$ReventlessAws from "../../util/Util_DynamoDb_Runtime.res.mjs";
 import * as Messaging_Log_Backend$ReventlessCore from "@reventlessdev/reventless-core/src/adapter/Messaging/Messaging_Log_Backend.res.mjs";
 import * as AutomationSlice_Callback$ReventlessCore from "@reventlessdev/reventless-core/src/components/AutomationSlice/AutomationSlice_Callback.res.mjs";
+import * as AutomationSlice_Schedules$ReventlessCore from "@reventlessdev/reventless-core/src/components/AutomationSlice/AutomationSlice_Schedules.res.mjs";
 import * as StreamRoutedEntryPoint_Ops$ReventlessAws from "./StreamRoutedEntryPoint_Ops.res.mjs";
 import * as Geocoder_AwsLocation_Backend$ReventlessAws from "../Geocoder/Geocoder_AwsLocation_Backend.res.mjs";
 import * as CommandTopicChannel_SQS_Runtime$ReventlessAws from "../CommandTopic/CommandTopicChannel_SQS_Runtime.res.mjs";
 import * as QueryDbStorage_DynamoDb_Runtime$ReventlessAws from "../QueryDb/QueryDbStorage_DynamoDb_Runtime.res.mjs";
 import * as OutboundTranslationSlice_Callback$ReventlessCore from "@reventlessdev/reventless-core/src/components/OutboundTranslationSlice/OutboundTranslationSlice_Callback.res.mjs";
+import * as ScheduledPublisher_EventBridgeScheduler_Runtime$ReventlessAws from "../ScheduledPublisher/ScheduledPublisher_EventBridgeScheduler_Runtime.res.mjs";
 
 function strOf(obj, key) {
   return Stdlib_Option.flatMap(obj[key], Stdlib_JSON.Decode.string);
@@ -48,7 +51,8 @@ function decodeEntry(json) {
     dcbQueueUrl: Stdlib_Option.getOr(strOf(h, "dcbQueueUrl"), ""),
     commandQueueIsFifo: Stdlib_Option.flatMap(h["commandQueueIsFifo"], Stdlib_JSON.Decode.bool),
     sourceUrn: Stdlib_Option.getOr(strOf(h, "sourceUrn"), ""),
-    context: Stdlib_Option.flatMap(h["context"], decodeContext)
+    context: Stdlib_Option.flatMap(h["context"], decodeContext),
+    schedulesTableName: strOf(h, "schedulesTableName")
   }));
 }
 
@@ -64,7 +68,8 @@ function decodeCompactEntry(modules, sharedQueueUrl, sharedIsFifo, sharedUrns, h
     dcbQueueUrl: Stdlib_Option.getOr(strOf(h, "k"), sharedQueueUrl),
     commandQueueIsFifo: f !== undefined ? f : sharedIsFifo,
     sourceUrn: Stdlib_Option.getOr(urns[0], ""),
-    context: Stdlib_Option.flatMap(m["context"], decodeContext)
+    context: Stdlib_Option.flatMap(m["context"], decodeContext),
+    schedulesTableName: strOf(h, "s")
   };
 }
 
@@ -188,6 +193,74 @@ function makeLoadTodoItems(queryDbTableName, todoItems, rowSchema, comp) {
   };
 }
 
+function scheduleTable(tableName) {
+  return {
+    id: "",
+    name: tableName,
+    arn: "",
+    hashKey: "id"
+  };
+}
+
+function makeScheduleStore(tableName, rows, comp) {
+  let table = scheduleTable(tableName);
+  let save = QueryDbStorage_DynamoDb_Runtime$ReventlessAws.save(table);
+  let $$delete = QueryDbStorage_DynamoDb_Runtime$ReventlessAws.$$delete(table);
+  let stored = {
+    contents: []
+  };
+  let loaded = {
+    contents: false
+  };
+  let load = async () => {
+    if (loaded.contents) {
+      return;
+    }
+    loaded.contents = true;
+    let params_ConsistentRead = true;
+    let params = {
+      TableName: tableName,
+      ConsistentRead: params_ConsistentRead
+    };
+    await Effect.runPromise(Effect.catchAll(Effect.map(Stream.runCollect(Util_DynamoDb_Runtime$ReventlessAws.scanStream(params)), items => {
+      items.forEach(item => {
+        let json = JSON.parse(Stdlib_Option.getOr(JSON.stringify(item), ""));
+        let row;
+        try {
+          row = Util_Sury$Reventless.fromJson(json, AutomationSlice_Schedules$ReventlessCore.rowSchema);
+        } catch (exn) {
+          return;
+        }
+        if (Stdlib_Option.isNone(rows[row.key])) {
+          rows[row.key] = row;
+          return;
+        }
+      });
+    }), err => EffectLogger$ReventlessCore.logError(comp, undefined, `restore: couldn't read the schedules from ` + tableName + `: ` + DynamoDb_Error$ReventlessAws.message(err))));
+    stored.contents = Object.keys(rows);
+  };
+  let sync = async () => {
+    let keys = Object.keys(rows);
+    await Promise.all(Object.entries(rows).map(param => save(param[0], Util_Sury$Reventless.toJson(param[1], AutomationSlice_Schedules$ReventlessCore.rowSchema), "Overwrite", undefined)));
+    await Promise.all(stored.contents.filter(key => !keys.includes(key)).map(key => $$delete(key, undefined)));
+    stored.contents = keys;
+  };
+  return [
+    load,
+    sync
+  ];
+}
+
+function ownArn() {
+  let env = key => Stdlib_Option.getOr(process.env[key], "");
+  let account = Stdlib_Option.getOr(env("SCHEDULER_ROLE_ARN").split(":")[4], "");
+  return `arn:aws:lambda:` + env("AWS_REGION") + `:` + account + `:function:` + env("AWS_LAMBDA_FUNCTION_NAME");
+}
+
+function platformSchedulesOf(slice) {
+  return ScheduledPublisher_EventBridgeScheduler_Runtime$ReventlessAws.platformSchedules(Stdlib_Option.getOr(process.env["SCHEDULER_ROLE_ARN"], ""), ownArn(), slice);
+}
+
 function messagingEmailProvider() {
   let sender = Stdlib_Option.getOr(process.env["MESSAGING_EMAIL_SENDER"], "");
   let match = Stdlib_Option.getOr(process.env["MESSAGING_EMAIL_PROVIDER"], "");
@@ -207,11 +280,31 @@ function capabilities() {
   };
 }
 
-function makeAutomationJsonEventsHandler(context, callback, publishJsons, syncTodoItems, loadTodoItems) {
+async function loadSchedules(step) {
+  if (step !== undefined) {
+    return await step.load();
+  }
+}
+
+async function followSchedules(step, callback) {
+  if (step === undefined) {
+    return;
+  }
+  let changes = callback.takeScheduleChanges();
+  if (changes.length !== 0) {
+    await step.sync();
+    return await AutomationSlice_Schedules$ReventlessCore.tell(step.platform, changes);
+  }
+}
+
+function makeAutomationJsonEventsHandler(context, callback, publishJsons, syncTodoItems, loadTodoItems, schedulesOpt) {
+  let schedules = schedulesOpt !== undefined ? schedulesOpt : () => {};
   return stream => Effect.flatMap(Stream.runCollect(stream), jsons => Effect.promise(async () => {
     await loadTodoItems();
+    await loadSchedules(schedules());
     callback.phase1(jsons, context);
     await syncTodoItems();
+    await followSchedules(schedules(), callback);
     await callback.phase2(publishJsons);
     return await syncTodoItems();
   }));
@@ -242,14 +335,39 @@ function makeOutboundJsonEventsHandler(consumedEventSchema, callback, publishJso
   }));
 }
 
-function makeAutomationRegisteredHandler(entry, sliceName, callback) {
+function makeAutomationRegisteredHandler(entry, sliceName, callback, schedule) {
   let comp = `AutomationSlice(` + sliceName + `)`;
   let publishJsons = makePublishJsons(entry.dcbQueueUrl, Stdlib_Option.getOr(entry.commandQueueIsFifo, false));
   let syncTodoItems = makeSyncTodoItems(entry.queryDbTableName, callback.todoItems, AutomationSlice_Callback$ReventlessCore.todoRowSchema);
   let loadTodoItems = makeLoadTodoItems(entry.queryDbTableName, callback.todoItems, AutomationSlice_Callback$ReventlessCore.todoRowSchema, comp);
+  let context = Stdlib_Option.getOr(entry.context, defaultContext(sliceName));
+  let step = {
+    contents: undefined
+  };
+  let schedules = () => {
+    let match = step.contents;
+    let match$1 = entry.schedulesTableName;
+    if (match !== undefined) {
+      return match;
+    }
+    if (match$1 === undefined) {
+      return;
+    }
+    let match$2 = makeScheduleStore(match$1, callback.schedules, comp);
+    let s_load = match$2[0];
+    let s_sync = match$2[1];
+    let s_platform = platformSchedulesOf(sliceName);
+    let s = {
+      load: s_load,
+      sync: s_sync,
+      platform: s_platform
+    };
+    step.contents = s;
+    return s;
+  };
   return {
     registered: {
-      handler: StreamRoutedEntryPoint_Ops$ReventlessAws.toStreamHandler(makeAutomationJsonEventsHandler(Stdlib_Option.getOr(entry.context, defaultContext(sliceName)), callback, publishJsons, syncTodoItems, loadTodoItems)),
+      handler: StreamRoutedEntryPoint_Ops$ReventlessAws.toStreamHandler(makeAutomationJsonEventsHandler(context, callback, publishJsons, syncTodoItems, loadTodoItems, schedules)),
       comp: comp
     },
     sweep: async () => {
@@ -257,7 +375,33 @@ function makeAutomationRegisteredHandler(entry, sliceName, callback) {
       await callback.phase2(publishJsons);
       return await syncTodoItems();
     },
-    comp: comp
+    comp: comp,
+    name: sliceName,
+    tick: async (key, at) => {
+      await loadTodoItems();
+      await loadSchedules(schedules());
+      callback.phase1([AutomationSlice_Callback$ReventlessCore.tickEvent(key, at)], context);
+      await syncTodoItems();
+      let match = schedules();
+      if (match !== undefined) {
+        await match.sync();
+      }
+      await callback.phase2(publishJsons);
+      return await syncTodoItems();
+    },
+    reconcile: async () => {
+      let match = schedules();
+      if (match !== undefined) {
+        await match.load();
+        await AutomationSlice_Schedules$ReventlessCore.reconcile(callback.schedules, match.platform, schedule, Date.now());
+        return await match.sync();
+      }
+      let platform = platformSchedulesOf(sliceName);
+      let names = await platform.names();
+      for (let i = 0, i_finish = names.length; i < i_finish; ++i) {
+        await platform.removeName(names[i]);
+      }
+    }
   };
 }
 
@@ -276,7 +420,10 @@ function makeOutboundRegisteredHandler(entry, sliceName, consumedEventSchema, ca
       await callback.phase2(publishJsons, capabilities());
       return await syncTodoItems();
     },
-    comp: comp
+    comp: comp,
+    name: sliceName,
+    tick: undefined,
+    reconcile: undefined
   };
 }
 
@@ -293,6 +440,29 @@ async function runSweeps(slices) {
   }
 }
 
+async function runTick(slices, invocation) {
+  let tick = Stdlib_Option.flatMap(slices.find(s => s.name === invocation.slice), s => s.tick);
+  if (tick === undefined) {
+    return Stdlib_JsError.throwWithMessage(`tick for ` + invocation.slice + `: no automation of that name here`);
+  }
+  let at = new Date(invocation.at).getTime();
+  if (Number.isNaN(at)) {
+    Stdlib_JsError.throwWithMessage(`tick for ` + invocation.slice + `: "` + invocation.at + `" is not a time`);
+  }
+  return await tick(invocation.key, at);
+}
+
+async function reconcileSchedules(slices) {
+  if (Stdlib_Option.getOr(process.env["SCHEDULER_ROLE_ARN"], "") === "") {
+    Stdlib_JsError.throwWithMessage(`reconcile: SCHEDULER_ROLE_ARN is not set`);
+  }
+  let reconciles = Stdlib_Array.filterMap(slices, s => s.reconcile);
+  for (let i = 0, i_finish = reconciles.length; i < i_finish; ++i) {
+    await reconciles[i]();
+  }
+  return Effect.runSync(EffectLogger$ReventlessCore.logInfo("AutomationSliceRuntime", undefined, `reconcile: the schedules of ` + reconciles.length.toString() + ` automation(s) are in line`));
+}
+
 export {
   strOf,
   decodeContext,
@@ -305,12 +475,20 @@ export {
   makePublishJsons,
   makeSyncTodoItems,
   makeLoadTodoItems,
+  scheduleTable,
+  makeScheduleStore,
+  ownArn,
+  platformSchedulesOf,
   messagingEmailProvider,
   capabilities,
+  loadSchedules,
+  followSchedules,
   makeAutomationJsonEventsHandler,
   makeOutboundJsonEventsHandler,
   makeAutomationRegisteredHandler,
   makeOutboundRegisteredHandler,
   runSweeps,
+  runTick,
+  reconcileSchedules,
 }
 /* Stream Not a pure module */

package/src/adapter/Runtime/AutomationSliceRuntime_Builder_Single.res

@@ -48,6 +48,12 @@ type sliceInfo = {
   // created *after* the slices that target it, so a lookup at registration time
   // finds nothing. Only the name is knowable this early.
   commandTargetName: option<string>,
+  // The automation's declared time; what the deploy's reconcile puts on the
+  // platform, and what re-runs it when it changes.
+  schedule: option<Reventless.Schedule.time>,
+  // The schedules store's table, empty for a slice that maps no `Clock`. Granted to
+  // the Lambda with the to-do tables, and named in the slice's handler config.
+  schedulesResources: array<ReventlessInfra.Adapter.resource>,
 }
 
 let bundledInfos: dict<sliceInfo> = Dict.make()
@@ -95,6 +101,8 @@ let registerAutomationSlice = (
   ~sourceTopics=Dict.make(),
   ~consumesDcbLog=true,
   ~commandTargetName=?,
+  ~schedule=?,
+  ~schedulesResources=[],
 ) =>
   bundledInfos->Dict.set(
     name,
@@ -108,6 +116,8 @@ let registerAutomationSlice = (
       sourceTopics,
       consumesDcbLog,
       commandTargetName,
+      schedule,
+      schedulesResources,
     },
   )
 
@@ -319,6 +329,128 @@ let makeMessagingGrant = (~runtime: ReventlessCore.Runtime.environment<runtimePa
     )
   }
 
+// The automations' schedules. The Lambda may manage the schedules in the stack's
+// scheduler group and pass the scheduler role to them; the scheduler role may invoke
+// the Lambda; and each deploy invokes the Lambda to reconcile the declared schedules
+// (`<slice>.default`), so a schedule the platform refuses fails the deploy. The
+// declared times and the code's hash are the invocation's input, so a changed time
+// or a new build re-runs it.
+let makeAutomationSchedules = (
+  ~runtime: ReventlessCore.Runtime.environment<runtimeParts>,
+  ~schedulerRoleArn: Pulumi.Output.t<string>,
+  ~sourceCodeHash: string,
+  ~opts,
+) => {
+  let name = "AllAutomationSlices"
+  let customOpts = opts->ReventlessCore.Util.Pulumi.ComponentResourceOptions.toCustomResourceOptions
+  let lambdaArn = runtime.parts.lambda->Pulumi.Output.flatMap(l => l.arn)
+
+  let manage = {
+    open PulumiAws.PolicyDocument
+    PulumiAws.IAM.RolePolicy.make(
+      ~name=`${name}SchedulerPolicy`,
+      ~args={
+        policy: schedulerRoleArn
+        ->Pulumi.Output.apply(arn =>
+          PulumiAws.PolicyDocument.make(
+            ~id=`${name}SchedulerPolicy`,
+            ~statements=[
+              {
+                sid: "AllowManageSchedules",
+                effect: Allow,
+                actions: Actions(ScheduledPublisher_EventBridgeScheduler_Runtime.manageActions),
+                resources: Resource(
+                  arn->ScheduledPublisher_EventBridgeScheduler_Runtime.schedulesOfRoleArn,
+                ),
+              },
+              {
+                sid: "AllowPassSchedulerRole",
+                effect: Allow,
+                actions: Action("iam:PassRole"),
+                resources: Resource(arn),
+              },
+              {
+                sid: "AllowListSchedules",
+                effect: Allow,
+                actions: Actions(ScheduledPublisher_EventBridgeScheduler_Runtime.listActions),
+                resources: AllResources,
+              },
+            ],
+          )->PulumiAws.PolicyDocument.toJsonString
+        )
+        ->Pulumi.Output.asInput,
+        role: runtime.parts.lambdaRole.id->Pulumi.Output.asInput,
+      },
+      ~opts=customOpts,
+    )
+  }
+
+  // The group is named after the scheduler role, so its last ARN segment is the role's name.
+  let invoke = {
+    open PulumiAws.PolicyDocument
+    PulumiAws.IAM.RolePolicy.make(
+      ~name=`${name}SchedulerInvokePolicy`,
+      ~args={
+        policy: lambdaArn
+        ->Pulumi.Output.apply(arn =>
+          PulumiAws.PolicyDocument.make(
+            ~id=`${name}SchedulerInvokePolicy`,
+            ~statements=[
+              {
+                sid: "AllowSchedulerToInvokeAutomations",
+                effect: Allow,
+                actions: Action("lambda:InvokeFunction"),
+                resources: Resource(arn),
+              },
+            ],
+          )->PulumiAws.PolicyDocument.toJsonString
+        )
+        ->Pulumi.Output.asInput,
+        role: schedulerRoleArn
+        ->Pulumi.Output.apply(ScheduledPublisher_EventBridgeScheduler_Runtime.groupOfRoleArn)
+        ->Pulumi.Output.asInput,
+      },
+      ~opts=customOpts,
+    )
+  }
+
+  let declared =
+    bundledInfos
+    ->Dict.toArray
+    ->Array.filterMap(((slice, info)) =>
+      info.schedule->Option.map(time => (
+        slice,
+        time->Reventless.Util_Sury.toJson(Reventless.Schedule.timeSchema),
+      ))
+    )
+    ->Array.toSorted(((a, _), (b, _)) => String.compare(a, b))
+    ->Dict.fromArray
+    ->JSON.Encode.object
+  let input =
+    Dict.fromArray([
+      ("reventlessReconcile", JSON.Encode.bool(true)),
+      ("declared", declared),
+      ("code", sourceCodeHash->JSON.Encode.string),
+    ])
+    ->JSON.Encode.object
+    ->JSON.stringify
+
+  let _reconcile = PulumiAws.Lambda.Invocation.make(
+    ~name=`${name}ReconcileSchedules`,
+    ~args={
+      functionName: runtime.parts.lambda->Pulumi.Output.flatMap(l => l.name)->Pulumi.Output.asInput,
+      input: input->Pulumi.Input.make,
+    },
+    ~opts={
+      ...customOpts,
+      dependsOn: [
+        manage->Pulumi.Resource.makeFromJs,
+        invoke->Pulumi.Resource.makeFromJs,
+      ]->Pulumi.Input.make,
+    },
+  )
+}
+
 let finished = ref(false)
 
 // Legacy finalizer, kept only to satisfy `EventCollectorRuntime_Builder.T`.
@@ -445,7 +577,10 @@ let finish = () =>
 // stream — the sole source for automation/outbound slices, which dispatch by
 // `meta.service` inside the callback. `dcbEventLog` is passed so the parent and
 // the stream URN are available synchronously here.
-let finishWithDcbEventLog = (dcbEventLog: ReventlessCore.DcbEventLog.component) =>
+let finishWithDcbEventLog = (
+  ~schedulerRoleArn: Pulumi.Output.t<string>,
+  dcbEventLog: ReventlessCore.DcbEventLog.component,
+) =>
   if !finished.contents {
     if bundledInfos->Dict.keysToArray->Array.length > 0 {
       let dcbResource = dcbEventLog->ReventlessCore.Component.toPulumiResource
@@ -538,6 +673,7 @@ let finishWithDcbEventLog = (dcbEventLog: ReventlessCore.DcbEventLog.component)
 
         bundledInfos->Dict.forEachWithKey((info, name) => {
           info.queryDbResources->Array.forEach(r => allQueryDbResources->Array.push(r)->ignore)
+          info.schedulesResources->Array.forEach(r => allQueryDbResources->Array.push(r)->ignore)
           // The queue this slice publishes its command to. An Aggregate registers
           // its CommandTopic while plugin construction is still synchronous —
           // before DCB construction registers the slices targeting it — so a
@@ -589,11 +725,16 @@ let finishWithDcbEventLog = (dcbEventLog: ReventlessCore.DcbEventLog.component)
           // exactly — so it emits neither and inherits both.
           let hasOwnUrns =
             !info.consumesDcbLog || info.sourceTopics->Dict.keysToArray->Array.length > 0
-          let handlerJson = Pulumi.Output.all3((
+          let schedulesTableName = switch info.schedulesResources->Array.get(0) {
+          | Some(resource) => resource.name
+          | None => Pulumi.Output.make("")
+          }
+          let handlerJson = Pulumi.Output.all4((
             info.queryDbTableName,
             commandQueueUrl,
             sourceUrnsFor(info),
-          ))->Pulumi.Output.apply(((tableName, queueUrl, urns)) => {
+            schedulesTableName,
+          ))->Pulumi.Output.apply(((tableName, queueUrl, urns, schedulesTable)) => {
             let urnsFragment = hasOwnUrns
               ? `,"u":${urns->Array.map(JSON.Encode.string)->JSON.Encode.array->JSON.stringify}`
               : ""
@@ -601,7 +742,8 @@ let finishWithDcbEventLog = (dcbEventLog: ReventlessCore.DcbEventLog.component)
             | Some(_) => `,"k":"${queueUrl}","f":${commandQueueIsFifo ? "true" : "false"}`
             | None => ""
             }
-            `{"n":${nameJson},"q":"${tableName}"${urnsFragment}${queueFragment}}`
+            let schedulesFragment = schedulesTable == "" ? "" : `,"s":"${schedulesTable}"`
+            `{"n":${nameJson},"q":"${tableName}"${urnsFragment}${queueFragment}${schedulesFragment}}`
           })
           let _ = handlerOutputs->Array.push(handlerJson)
         })
@@ -645,6 +787,9 @@ let finishWithDcbEventLog = (dcbEventLog: ReventlessCore.DcbEventLog.component)
         PluginRuntime_Builder.capabilityEnv()->Array.forEach(((name, value)) =>
           envVars->Dict.set(name, value->Pulumi.Output.asInput)
         )
+        // The stack's scheduler role, which also names its group: where the
+        // automations' schedules go.
+        envVars->Dict.set("SCHEDULER_ROLE_ARN", schedulerRoleArn->Pulumi.Output.asInput)
 
         // Carries no Pulumi Output, so the archive is still built synchronously —
         // the table names and urns that do are what stays in HANDLER_CONFIG.
@@ -680,6 +825,7 @@ let finishWithDcbEventLog = (dcbEventLog: ReventlessCore.DcbEventLog.component)
         )
 
         makeSweepSchedule(~runtime, ~opts)
+        makeAutomationSchedules(~runtime, ~schedulerRoleArn, ~sourceCodeHash, ~opts)
         makeGeocoderGrant(~runtime, ~opts)
         makeMessagingGrant(~runtime, ~opts)
       | None =>