@reventlessdev/reventless-aws 3.0.0-alpha.264 → 3.0.0-alpha.266

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

@@ -4,14 +4,20 @@ import * as S from "sury/src/S.res.mjs";
 import * as Stream from "@reventlessdev/rescript-effect/src/Stream.res.mjs";
 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 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 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";
 import * as Message$ReventlessCore from "@reventlessdev/reventless-core/src/Message.res.mjs";
+import * as EffectLogger$ReventlessCore from "@reventlessdev/reventless-core/src/util/EffectLogger.res.mjs";
+import * as DynamoDb_Error$ReventlessAws from "../../errors/DynamoDb_Error.res.mjs";
+import * as Util_DynamoDb_Runtime$ReventlessAws from "../../util/Util_DynamoDb_Runtime.res.mjs";
 import * as AutomationSlice_Callback$ReventlessCore from "@reventlessdev/reventless-core/src/components/AutomationSlice/AutomationSlice_Callback.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";
@@ -87,8 +93,71 @@ function makeSyncTodoItems(queryDbTableName, todoItems, rowSchema) {
   };
 }
 
-function makeAutomationJsonEventsHandler(context, callback, publishJsons, syncTodoItems) {
+function makeLoadTodoItems(queryDbTableName, todoItems, rowSchema, comp) {
+  let loaded = {
+    contents: false
+  };
+  return async () => {
+    if (loaded.contents) {
+      return;
+    }
+    loaded.contents = true;
+    let params_ConsistentRead = true;
+    let params_ExpressionAttributeNames = Object.fromEntries([[
+        "#s",
+        "status"
+      ]]);
+    let params_ExpressionAttributeValues = Object.fromEntries([
+      [
+        ":pending",
+        "Pending"
+      ],
+      [
+        ":failed",
+        "Failed"
+      ]
+    ]);
+    let params_FilterExpression = "#s = :pending OR #s = :failed";
+    let params = {
+      TableName: queryDbTableName,
+      ConsistentRead: params_ConsistentRead,
+      ExpressionAttributeNames: params_ExpressionAttributeNames,
+      ExpressionAttributeValues: params_ExpressionAttributeValues,
+      FilterExpression: params_FilterExpression
+    };
+    let restored = await Effect.runPromise(Effect.catchAll(Effect.map(Stream.runCollect(Util_DynamoDb_Runtime$ReventlessAws.scanStream(params)), items => Stdlib_Array.reduce(items, 0, (count, item) => {
+      let json = JSON.parse(Stdlib_Option.getOr(JSON.stringify(item), ""));
+      let id = Stdlib_Option.flatMap(Stdlib_Option.flatMap(Stdlib_JSON.Decode.object(json), d => d["id"]), Stdlib_JSON.Decode.string);
+      if (id === undefined) {
+        return count;
+      }
+      if (!Stdlib_Option.isNone(todoItems[id])) {
+        return count;
+      }
+      let row;
+      try {
+        row = S.parseJsonOrThrow(json, rowSchema);
+      } catch (exn) {
+        return count;
+      }
+      todoItems[id] = row;
+      return count + 1 | 0;
+    })), err => Effect.map(EffectLogger$ReventlessCore.logError(comp, undefined, `restore: couldn't read pending TODO rows from ` + queryDbTableName + `: ` + DynamoDb_Error$ReventlessAws.message(err)), () => 0)));
+    if (restored > 0) {
+      return Effect.runSync(EffectLogger$ReventlessCore.logInfo(comp, undefined, `restore: reloaded ` + restored.toString() + ` unfinished TODO row(s) from ` + queryDbTableName));
+    }
+  };
+}
+
+function capabilities() {
+  return {
+    geocode: text => Geocoder_AwsLocation_Backend$ReventlessAws.search(Stdlib_Option.getOr(process.env["PLACE_INDEX_NAME"], ""), text, undefined)
+  };
+}
+
+function makeAutomationJsonEventsHandler(context, callback, publishJsons, syncTodoItems, loadTodoItems) {
   return stream => Effect.flatMap(Stream.runCollect(stream), jsons => Effect.promise(async () => {
+    await loadTodoItems();
     callback.phase1(jsons, context);
     await syncTodoItems();
     await callback.phase2(publishJsons);
@@ -96,7 +165,7 @@ function makeAutomationJsonEventsHandler(context, callback, publishJsons, syncTo
   }));
 }
 
-function makeOutboundJsonEventsHandler(consumedEventSchema, callback, publishJsons, syncTodoItems) {
+function makeOutboundJsonEventsHandler(consumedEventSchema, callback, publishJsons, syncTodoItems, loadTodoItems) {
   let decoder = DcbDecode$Reventless.makeDecoder(consumedEventSchema);
   return stream => Effect.flatMap(Stream.runCollect(Stream$1.flatMap(Stream$1.mapEffect(stream, json => Effect.sync(() => {
     let envelope = Stdlib_JSON.Decode.object(json);
@@ -113,27 +182,69 @@ function makeOutboundJsonEventsHandler(consumedEventSchema, callback, publishJso
       return [];
     }
   })), events => Stream$1.fromIterable(events))), events => Effect.promise(async () => {
+    await loadTodoItems();
     callback.phase1(events);
     await syncTodoItems();
-    await callback.phase2(publishJsons);
+    await callback.phase2(publishJsons, {
+      geocode: text => Geocoder_AwsLocation_Backend$ReventlessAws.search(Stdlib_Option.getOr(process.env["PLACE_INDEX_NAME"], ""), text, undefined)
+    });
     return await syncTodoItems();
   }));
 }
 
 function makeAutomationRegisteredHandler(entry, sliceName, callback) {
+  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);
   return {
-    handler: StreamRoutedEntryPoint_Ops$ReventlessAws.toStreamHandler(makeAutomationJsonEventsHandler(Stdlib_Option.getOr(entry.context, defaultContext(sliceName)), callback, makePublishJsons(entry.dcbQueueUrl, Stdlib_Option.getOr(entry.commandQueueIsFifo, false)), makeSyncTodoItems(entry.queryDbTableName, callback.todoItems, AutomationSlice_Callback$ReventlessCore.todoRowSchema))),
-    comp: `AutomationSlice(` + sliceName + `)`
+    registered: {
+      handler: StreamRoutedEntryPoint_Ops$ReventlessAws.toStreamHandler(makeAutomationJsonEventsHandler(Stdlib_Option.getOr(entry.context, defaultContext(sliceName)), callback, publishJsons, syncTodoItems, loadTodoItems)),
+      comp: comp
+    },
+    sweep: async () => {
+      await loadTodoItems();
+      await callback.phase2(publishJsons);
+      return await syncTodoItems();
+    },
+    comp: comp
   };
 }
 
 function makeOutboundRegisteredHandler(entry, sliceName, consumedEventSchema, callback) {
+  let comp = `OutboundTranslationSlice(` + sliceName + `)`;
+  let publishJsons = makePublishJsons(entry.dcbQueueUrl, Stdlib_Option.getOr(entry.commandQueueIsFifo, false));
+  let syncTodoItems = makeSyncTodoItems(entry.queryDbTableName, callback.todoItems, OutboundTranslationSlice_Callback$ReventlessCore.todoRowSchema);
+  let loadTodoItems = makeLoadTodoItems(entry.queryDbTableName, callback.todoItems, OutboundTranslationSlice_Callback$ReventlessCore.todoRowSchema, comp);
   return {
-    handler: StreamRoutedEntryPoint_Ops$ReventlessAws.toStreamHandler(makeOutboundJsonEventsHandler(consumedEventSchema, callback, makePublishJsons(entry.dcbQueueUrl, Stdlib_Option.getOr(entry.commandQueueIsFifo, false)), makeSyncTodoItems(entry.queryDbTableName, callback.todoItems, OutboundTranslationSlice_Callback$ReventlessCore.todoRowSchema))),
-    comp: `OutboundTranslationSlice(` + sliceName + `)`
+    registered: {
+      handler: StreamRoutedEntryPoint_Ops$ReventlessAws.toStreamHandler(makeOutboundJsonEventsHandler(consumedEventSchema, callback, publishJsons, syncTodoItems, loadTodoItems)),
+      comp: comp
+    },
+    sweep: async () => {
+      await loadTodoItems();
+      await callback.phase2(publishJsons, {
+        geocode: text => Geocoder_AwsLocation_Backend$ReventlessAws.search(Stdlib_Option.getOr(process.env["PLACE_INDEX_NAME"], ""), text, undefined)
+      });
+      return await syncTodoItems();
+    },
+    comp: comp
   };
 }
 
+async function runSweeps(slices) {
+  for (let i = 0, i_finish = slices.length; i < i_finish; ++i) {
+    let slice = slices[i];
+    try {
+      await slice.sweep();
+    } catch (raw_exn) {
+      let exn = Primitive_exceptions.internalToException(raw_exn);
+      let msg = Stdlib_Option.getOr(Stdlib_Option.flatMap(Stdlib_JsExn.fromException(exn), Stdlib_JsExn.message), "unknown");
+      Effect.runSync(EffectLogger$ReventlessCore.logError(slice.comp, undefined, `sweep failed: ` + msg));
+    }
+  }
+}
+
 export {
   strOf,
   decodeContext,
@@ -143,9 +254,12 @@ export {
   defaultContext,
   makePublishJsons,
   makeSyncTodoItems,
+  makeLoadTodoItems,
+  capabilities,
   makeAutomationJsonEventsHandler,
   makeOutboundJsonEventsHandler,
   makeAutomationRegisteredHandler,
   makeOutboundRegisteredHandler,
+  runSweeps,
 }
 /* S Not a pure module */

package/src/adapter/Runtime/AutomationSliceRuntime_Builder_Single.res

@@ -181,6 +181,121 @@ let forEventCollector: ReventlessCore.Runtime.forEventCollector<
   }
 }
 
+// How often the shared automation Lambda is invoked with no records, to work
+// its slices' TODO backlogs.
+//
+// Without it a backlog only moves when the *next event* arrives, so a slice
+// whose traffic stops holds its failed items indefinitely — and D4's "retried to
+// maxRetries, then swept" is what an outbound slice is chosen for over a
+// hand-rolled Task. Five minutes is short enough that a transient outage clears
+// on its own without anyone watching, and long enough that the invocations are
+// noise against the event traffic (~288/day per deployment, most of them finding
+// an empty backlog and exiting).
+let sweepIntervalMinutes = 5
+
+// The scheduled trigger: a rule, permission for EventBridge to invoke, and a
+// target carrying the constant payload the entry point's shell branches on. The
+// payload is the whole event — a scheduled invocation has no `records`, which is
+// exactly how the shell tells the two apart.
+let makeSweepSchedule = (~runtime: ReventlessCore.Runtime.environment<runtimeParts>, ~opts) => {
+  let name = "AllAutomationSlicesSweep"
+  let customOpts = opts->ReventlessCore.Util.Pulumi.ComponentResourceOptions.toCustomResourceOptions
+
+  let rule = {
+    open PulumiAws.Cloudwatch
+    EventRule.make(
+      ~name=Pulumi.Pulumi.getStackName() ++ ("-" ++ name),
+      ~args={
+        description: "Work the automation/outbound slices' TODO backlogs"->Pulumi.Input.make,
+        scheduleExpression: EventRule.ScheduleExpression.every(sweepIntervalMinutes->Minutes),
+        tags: AWS.Tags.make(
+          ~name=Pulumi.Pulumi.getStackName() ++ ("-" ++ name),
+          ~kind=ReventlessCore.ComponentType.AutomationSlice,
+          ~role=Scheduler,
+          ~component=name,
+        ),
+      },
+      ~opts=customOpts,
+    )
+  }
+
+  // The permission and target need the Lambda's resolved arn/name, so they stay
+  // inside an apply — the same shape the plugin heartbeat's runner uses.
+  let _permissionAndTarget =
+    (
+      runtime.parts.lambda->Pulumi.Output.flatMap(l => l.arn),
+      runtime.parts.lambda->Pulumi.Output.flatMap(l => l.name),
+    )
+    ->Pulumi.Output.all2
+    ->Pulumi.Output.apply(((lambdaArn, lambdaName)) => {
+      let _permission = PulumiAws.Lambda.Permission.make(
+        ~name,
+        ~args={
+          action: "lambda:InvokeFunction",
+          function: lambdaName->Pulumi.Input.make,
+          principal: AWS.CloudwatchEventRule.principal,
+        },
+        ~opts=customOpts,
+      )
+      let _target = {
+        open PulumiAws.Cloudwatch
+        EventTarget.make(
+          ~name,
+          ~args={
+            rule: EventTarget.Rule.ofEventRule(rule),
+            arn: lambdaArn->Pulumi.Input.make,
+            input: `{"reventlessSweep":true}`->Pulumi.Input.make,
+          },
+          ~opts=customOpts,
+        )
+      }
+    })
+}
+
+// Least-privilege `geo:SearchPlaceIndexForText` on the platform's place index,
+// for the slices that call the geocoder through the injected capability.
+//
+// Only attached when the platform actually provisioned an index — that bit is a
+// plain bool and therefore known synchronously, while the index *name* is an
+// Output. Without the split this would either grant on a nonsense ARN or need
+// `option<Pulumi.Output.t<_>>`, which corrupts the Output proxy.
+//
+// The RolePolicy is created at top level with an Output-valued document, not
+// inside an `apply`. A resource created in an apply callback does not reliably
+// register with the engine — the same defect that intermittently left the
+// heartbeat Lambda without its SQS grant.
+let makeGeocoderGrant = (~runtime: ReventlessCore.Runtime.environment<runtimeParts>, ~opts) =>
+  if PluginRuntime_Builder.geocoderProvisioned() {
+    let customOpts =
+      opts->ReventlessCore.Util.Pulumi.ComponentResourceOptions.toCustomResourceOptions
+    let policyJson =
+      PluginRuntime_Builder.geocoderPlaceIndex()->Pulumi.Output.apply(idx => {
+        open PulumiAws.PolicyDocument
+        PulumiAws.PolicyDocument.make(
+          ~id="AllAutomationSlicesGeocode",
+          ~statements=[
+            {
+              sid: "AllowGeocode",
+              effect: Allow,
+              actions: Action("geo:SearchPlaceIndexForText"),
+              // Account/region wildcarded, matching the Function URL handler's
+              // own policy: the index name is what identifies it, and the stack
+              // has no other account to reach.
+              resources: Resource(`arn:aws:geo:*:*:place-index/${idx}`),
+            },
+          ],
+        )->PulumiAws.PolicyDocument.toJsonString
+      })
+    let _ = PulumiAws.IAM.RolePolicy.make(
+      ~name="AllAutomationSlicesGeocode",
+      ~args={
+        policy: policyJson->Pulumi.Output.asInput,
+        role: runtime.parts.lambdaRole.id->Pulumi.Output.asInput,
+      },
+      ~opts=customOpts,
+    )
+  }
+
 let finished = ref(false)
 
 // Legacy finalizer, kept only to satisfy `EventCollectorRuntime_Builder.T`.
@@ -501,6 +616,9 @@ let finishWithDcbEventLog = (dcbEventLog: ReventlessCore.DcbEventLog.component)
           ~runtime,
           ~opts,
         )
+
+        makeSweepSchedule(~runtime, ~opts)
+        makeGeocoderGrant(~runtime, ~opts)
       | None =>
         log.warn(
           ~comp="AutomationSliceRuntime_Builder_Single",

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

@@ -1,13 +1,22 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
+import * as Aws from "@pulumi/aws";
 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 Output$Pulumi from "@reventlessdev/rescript-pulumi-pulumi/src/Output.res.mjs";
 import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
 import * as Pulumi from "@pulumi/pulumi";
 import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
+import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
+import * as AWS$ReventlessAws from "../AWS.res.mjs";
 import * as Logger$ReventlessCore from "@reventlessdev/reventless-core/src/util/Logger.res.mjs";
+import * as AWS_Tags$ReventlessAws from "../AWS_Tags.res.mjs";
 import * as Component$ReventlessCore from "@reventlessdev/reventless-core/src/components/Component.res.mjs";
+import * as PolicyDocument$PulumiAws from "@reventlessdev/rescript-pulumi-aws/src/IAM/PolicyDocument.res.mjs";
 import * as Util_Bundle$ReventlessAws from "../../util/Util_Bundle.res.mjs";
+import * as Util_Pulumi$ReventlessCore from "@reventlessdev/reventless-core/src/util/Util_Pulumi.res.mjs";
+import * as Cloudwatch_EventRule$PulumiAws from "@reventlessdev/rescript-pulumi-aws/src/Cloudwatch/Cloudwatch_EventRule.res.mjs";
+import * as Cloudwatch_EventTarget$PulumiAws from "@reventlessdev/rescript-pulumi-aws/src/Cloudwatch/Cloudwatch_EventTarget.res.mjs";
 import * as CommandTopicRegistry$ReventlessAws from "../CommandTopic/CommandTopicRegistry.res.mjs";
 import * as PluginRuntime_Builder$ReventlessAws from "../../plugin/runtime/PluginRuntime_Builder.res.mjs";
 import * as RuntimeEnvironment_Lambda$ReventlessAws from "./RuntimeEnvironment_Lambda.res.mjs";
@@ -96,6 +105,51 @@ function forEventCollector(param, eventTopics, resources, memorySizeOpt, timeout
   log.info("AutomationSliceRuntime_Builder_Single", undefined, `registered ` + eventCollectorName + ` for ` + parentName);
 }
 
+function makeSweepSchedule(runtime, opts) {
+  let name = "AllAutomationSlicesSweep";
+  let customOpts = Util_Pulumi$ReventlessCore.ComponentResourceOptions.toCustomResourceOptions(opts);
+  let rule = new (Aws.cloudwatch.EventRule)(Pulumi.getStack() + ("-" + name), {
+    description: "Work the automation/outbound slices' TODO backlogs",
+    scheduleExpression: Primitive_option.some(Cloudwatch_EventRule$PulumiAws.ScheduleExpression.every({
+      TAG: "Minutes",
+      _0: 5
+    })),
+    tags: AWS_Tags$ReventlessAws.make(Pulumi.getStack() + ("-" + name), "AutomationSlice", "Scheduler", undefined, name, undefined, undefined, undefined)
+  }, customOpts);
+  Pulumi.all([
+    Output$Pulumi.flatMap(runtime.parts.lambda, l => l.arn),
+    Output$Pulumi.flatMap(runtime.parts.lambda, l => l.name)
+  ]).apply(param => {
+    new (Aws.lambda.Permission)(name, {
+      action: "lambda:InvokeFunction",
+      function: param[1],
+      principal: AWS$ReventlessAws.CloudwatchEventRule.principal
+    }, customOpts);
+    new (Aws.cloudwatch.EventTarget)(name, {
+      rule: Cloudwatch_EventTarget$PulumiAws.Rule.ofEventRule(rule),
+      arn: param[0],
+      input: `{"reventlessSweep":true}`
+    }, customOpts);
+  });
+}
+
+function makeGeocoderGrant(runtime, opts) {
+  if (!PluginRuntime_Builder$ReventlessAws.geocoderProvisioned()) {
+    return;
+  }
+  let customOpts = Util_Pulumi$ReventlessCore.ComponentResourceOptions.toCustomResourceOptions(opts);
+  let policyJson = PluginRuntime_Builder$ReventlessAws.geocoderPlaceIndex().apply(idx => PolicyDocument$PulumiAws.toJsonString(PolicyDocument$PulumiAws.make(undefined, "AllAutomationSlicesGeocode", [{
+      Sid: "AllowGeocode",
+      Effect: "Allow",
+      Action: "geo:SearchPlaceIndexForText",
+      Resource: `arn:aws:geo:*:*:place-index/` + idx
+    }])));
+  new (Aws.iam.RolePolicy)("AllAutomationSlicesGeocode", {
+    policy: policyJson,
+    role: runtime.parts.lambdaRole.id
+  }, customOpts);
+}
+
 let finished = {
   contents: false
 };
@@ -271,6 +325,8 @@ function finishWithDcbEventLog(dcbEventLog) {
           eventTopics: eventTopics,
           resources: allQueryDbResources
         }], runtime, opts);
+      makeSweepSchedule(runtime, opts);
+      makeGeocoderGrant(runtime, opts);
     } else {
       log.warn("AutomationSliceRuntime_Builder_Single", undefined, "finishWithDcbEventLog: DCB EventLog has no parent");
     }
@@ -282,6 +338,8 @@ let EventCollectorChannel;
 
 let RuntimeEnvironment;
 
+let sweepIntervalMinutes = 5;
+
 export {
   EventCollectorChannel,
   RuntimeEnvironment,
@@ -296,6 +354,9 @@ export {
   storedSpecs,
   grandParent,
   forEventCollector,
+  sweepIntervalMinutes,
+  makeSweepSchedule,
+  makeGeocoderGrant,
   finished,
   finish,
   finishWithDcbEventLog,

package/src/components/OutboundTranslationSlice_Builder.res

@@ -14,6 +14,20 @@ module EventCollectorRuntimeBuilder = {
   let finish = Inner.finish
 }
 
+// On AWS the core builder's in-process handler is never the thing that runs a
+// translation: `forEventCollector` registers module paths, and the shared
+// `AllAutomationSlices` Lambda rebuilds the callback from them and drives phase 2
+// itself. So the capabilities that matter are the ones
+// `AutomationSliceEntryPoint_Ops.capabilities` builds at runtime, from the
+// Lambda's environment — where the place index name actually is.
+//
+// This deploy-time value therefore has no caller. `none` rather than a real
+// geocoder because inventing one here would suggest a path that does not exist,
+// and because a deploy-time module has no environment to read anyway.
+module DeployTimeCapabilities = {
+  let capabilities = () => Reventless.Capabilities.none
+}
+
 module Make = (Api: {
   let api: unit => Types.AppSync.api
   let apiRole: unit => Types.AppSync.role
@@ -25,6 +39,7 @@ module Make = (Api: {
     EventCollectorChannel,
     EventCollectorRuntimeBuilder,
     Api,
+    DeployTimeCapabilities,
   )
 
   module Make = (

package/src/components/OutboundTranslationSlice_Builder.res.mjs

@@ -1,6 +1,7 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
 import * as Belt_SetString from "@rescript/runtime/lib/es6/Belt_SetString.js";
+import * as Capabilities$Reventless from "@reventlessdev/reventless-spec/src/semantic/Capabilities.res.mjs";
 import * as Component$ReventlessCore from "@reventlessdev/reventless-core/src/components/Component.res.mjs";
 import * as EventTopic$ReventlessCore from "@reventlessdev/reventless-core/src/components/EventTopic/EventTopic.res.mjs";
 import * as Util_Bundle$ReventlessAws from "../util/Util_Bundle.res.mjs";
@@ -18,6 +19,14 @@ let EventCollectorRuntimeBuilder = {
   finish: AutomationSliceRuntime_Builder_Single$ReventlessAws.finish
 };
 
+function capabilities() {
+  return Capabilities$Reventless.none;
+}
+
+let DeployTimeCapabilities = {
+  capabilities: capabilities
+};
+
 function Make(Api) {
   let Inner = OutboundTranslationSlice_Builder$ReventlessCore.Make({
     make: RuntimeEnvironment_Lambda$ReventlessAws.make,
@@ -42,7 +51,7 @@ function Make(Api) {
     },
     forEventCollector: AutomationSliceRuntime_Builder_Single$ReventlessAws.forEventCollector,
     finish: AutomationSliceRuntime_Builder_Single$ReventlessAws.finish
-  })(Api);
+  })(Api)(DeployTimeCapabilities);
   let Make$1 = Spec => (Translation => {
     let InnerMake = Inner.Make(Spec)(Translation);
     let make = (dcbEventLog, allEventTopicsOpt, publishJsons, runtime, opts) => {
@@ -80,6 +89,7 @@ export {
   EventCollectorChannel,
   RuntimeEnvironment,
   EventCollectorRuntimeBuilder,
+  DeployTimeCapabilities,
   Make,
 }
 /* Component-ReventlessCore Not a pure module */

package/src/plugin/runtime/PluginRuntime_Builder.res

@@ -51,6 +51,32 @@ let registerCapabilityEnv = (name: string, value: Pulumi.Output.t<string>) =>
     capability, so this returns `[]` rather than throwing. */
 let capabilityEnv = () => capabilityEnvRef->Dict.toArray
 
+/**
+The geocoding place index, when the platform provisioned one.
+
+Separate from `capabilityEnv` because an env dict cannot express a *grant*: a
+slice Lambda calling Amazon Location needs `geo:SearchPlaceIndexForText` on this
+index, and its role is created later, in the slice runtime's finalizer. So the
+name travels twice — once as a variable the runtime reads, once as the resource
+its role must be allowed to touch.
+
+A plain Output with `""` for "not provisioned", plus a separate bool for "was it
+registered at all", rather than `ref<option<Pulumi.Output.t<_>>>`: that shape
+compiles to `Option.getOr`, whose nested-option probe corrupts the Output proxy.
+The bool is an ordinary value and is known synchronously, which is what the
+finalizer needs in order to decide whether to attach a policy at all.
+*/
+let geocoderPlaceIndexRef: ref<Pulumi.Output.t<string>> = ref(Pulumi.Output.make(""))
+let geocoderProvisionedRef = ref(false)
+
+let registerGeocoderPlaceIndex = (indexName: Pulumi.Output.t<string>) => {
+  geocoderPlaceIndexRef := indexName
+  geocoderProvisionedRef := true
+}
+
+let geocoderPlaceIndex = () => geocoderPlaceIndexRef.contents
+let geocoderProvisioned = () => geocoderProvisionedRef.contents
+
 type sliceModulePaths = {
   specPath: string,
   behaviorPath: string,

package/src/plugin/runtime/PluginRuntime_Builder.res.mjs

@@ -44,6 +44,27 @@ function capabilityEnv() {
   return Object.entries(capabilityEnvRef);
 }
 
+let geocoderPlaceIndexRef = {
+  contents: Pulumi.output("")
+};
+
+let geocoderProvisionedRef = {
+  contents: false
+};
+
+function registerGeocoderPlaceIndex(indexName) {
+  geocoderPlaceIndexRef.contents = indexName;
+  geocoderProvisionedRef.contents = true;
+}
+
+function geocoderPlaceIndex() {
+  return geocoderPlaceIndexRef.contents;
+}
+
+function geocoderProvisioned() {
+  return geocoderProvisionedRef.contents;
+}
+
 let dcbConfigRef = {
   contents: {
     pluginName: "",
@@ -506,6 +527,11 @@ export {
   capabilityEnvRef,
   registerCapabilityEnv,
   capabilityEnv,
+  geocoderPlaceIndexRef,
+  geocoderProvisionedRef,
+  registerGeocoderPlaceIndex,
+  geocoderPlaceIndex,
+  geocoderProvisioned,
   dcbConfigRef,
   registeredSliceModulePaths,
   registerStateChangeSliceSpec,

package/tests/AutomationSliceEntryPoint_OpsTest.res

@@ -112,6 +112,7 @@ describe("AutomationSliceEntryPoint_Ops.makeAutomationJsonEventsHandler", () =>
       ~callback,
       ~publishJsons=noopPublish,
       ~syncTodoItems=async () => steps->Array.push("sync"),
+      ~loadTodoItems=async () => steps->Array.push("restore"),
     )
     let envelope = obj([("meta", obj([("service", str("Order"))])), ("event", str("Placed"))])
     await Stream.fromIterable([envelope, str("bare")])->handler->Effect.runPromise
@@ -120,7 +121,43 @@ describe("AutomationSliceEntryPoint_Ops.makeAutomationJsonEventsHandler", () =>
     expect(receivedCtx.contents->Option.map(c => c.Reventless.AutomationSlice.sliceName))->toEqual(
       Some("S"),
     )
-    expect(steps)->toEqual(["phase1", "sync", "phase2", "sync"])
+    // `restore` first: rehydrating the TODO list after phase 1 would let a stored
+    // row overwrite one this batch just collected, and after phase 2 would leave
+    // the reloaded backlog unprocessed until another invocation.
+    expect(steps)->toEqual(["restore", "phase1", "sync", "phase2", "sync"])
+  })
+})
+
+describe("AutomationSliceEntryPoint_Ops.runSweeps", () => {
+  let dummyRegistered: StreamRoutedEntryPoint_Ops.registeredHandler = {
+    handler: (_event, _context) => Effect.succeed(),
+  }
+  let sliceThat = (~comp, ~run): AutomationSliceEntryPoint_Ops.builtSlice => {
+    registered: dummyRegistered,
+    sweep: run,
+    comp,
+  }
+
+  test("sweeps every slice", async () => {
+    let swept = []
+    await AutomationSliceEntryPoint_Ops.runSweeps([
+      sliceThat(~comp="A", ~run=async () => swept->Array.push("a")),
+      sliceThat(~comp="B", ~run=async () => swept->Array.push("b")),
+    ])
+    expect(swept)->toEqual(["a", "b"])
+  })
+
+  // A sweep exists to recover from a failing external call, so one slice whose
+  // geocoder is still down must not cost every other slice on the Lambda its
+  // turn — that would be a worse version of the problem being fixed.
+  test("a throwing slice does not stop the others", async () => {
+    let swept = []
+    await AutomationSliceEntryPoint_Ops.runSweeps([
+      sliceThat(~comp="A", ~run=async () => swept->Array.push("a")),
+      sliceThat(~comp="Boom", ~run=async () => JsError.throwWithMessage("gateway down")),
+      sliceThat(~comp="C", ~run=async () => swept->Array.push("c")),
+    ])
+    expect(swept)->toEqual(["a", "c"])
   })
 })
 
@@ -142,13 +179,14 @@ describe("AutomationSliceEntryPoint_Ops.makeOutboundJsonEventsHandler", () => {
         received := events
         steps->Array.push("phase1")
       },
-      phase2: async _publish => steps->Array.push("phase2"),
+      phase2: async (_publish, ~capabilities as _) => steps->Array.push("phase2"),
     }
     let handler = AutomationSliceEntryPoint_Ops.makeOutboundJsonEventsHandler(
       ~consumedEventSchema=outboundEventSchema,
       ~callback,
       ~publishJsons=noopPublish,
       ~syncTodoItems=async () => steps->Array.push("sync"),
+      ~loadTodoItems=async () => steps->Array.push("restore"),
     )
     // `id` is the envelope's subject — the entity the event was published for.
     // An Aggregate's event payload does not repeat it, so this is the only place
@@ -170,6 +208,9 @@ describe("AutomationSliceEntryPoint_Ops.makeOutboundJsonEventsHandler", () => {
       ("ord-1", OrderPlaced({orderId: "ord-1"})),
       ("", OrderArchived),
     ])
-    expect(steps)->toEqual(["phase1", "sync", "phase2", "sync"])
+    // `restore` first: rehydrating the TODO list after phase 1 would let a stored
+    // row overwrite one this batch just collected, and after phase 2 would leave
+    // the reloaded backlog unprocessed until another invocation.
+    expect(steps)->toEqual(["restore", "phase1", "sync", "phase2", "sync"])
   })
 })