@reventlessdev/reventless-aws 3.0.0-alpha.263 → 3.0.0-alpha.265

package/src/adapter/Runtime/AutomationSliceRuntime_Builder_Single.res

@@ -38,12 +38,44 @@ type sliceInfo = {
   // slice that declares no sources (the default) and for any that names the log
   // explicitly, which is why it is not derivable from `sourceTopics` being empty.
   consumesDcbLog: bool,
+  // Which component's CommandTopic this slice publishes its inbound command to.
+  // `None` keeps the plugin's DCB queue — right for a slice targeting a DCB
+  // StateChangeSlice, and what the shared Lambda used unconditionally before an
+  // outbound slice could target an Aggregate, whose commands a different Lambda
+  // consumes.
+  //
+  // Resolved in the finalizer rather than here: an Aggregate's CommandTopic is
+  // 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>,
 }
 
 let bundledInfos: dict<sliceInfo> = Dict.make()
 
 let dcbQueueUrlRef: ref<option<Pulumi.Output.t<string>>> = ref(None)
-let setDcbQueueUrl = url => dcbQueueUrlRef := Some(url)
+// The DCB command topic's own flavor, for the slices that publish to it. Set
+// beside the URL rather than assumed: the runtime publisher used to hardcode
+// FIFO, and these queues are standard, which SQS rejects.
+let dcbQueueIsFifo = ref(false)
+// The DCB command topic queues as deploy-time resources, so the finalizer can
+// put them on the channel spec and `connectLambda`'s `sqs:SendMessage` grant
+// covers the slices that publish to the DCB fallback. Accumulated rather than
+// kept singular: the hook fires once per DCB command topic (sync, and async
+// when async StateChangeSlices exist), and granting on both is correct.
+let dcbQueueResources: array<ReventlessInfra.Adapter.resource> = []
+// First call wins for the URL and flavor. The hook fires once per DCB command
+// topic and a plugin with async StateChangeSlices fires it twice; the sync topic
+// is created first and is the one a slice's command belongs on, so letting the
+// async FIFO topic overwrite would send slice commands to a FIFO queue with no
+// MessageGroupId — which SQS rejects. The resources keep accumulating: the grant
+// is wanted on every DCB command topic.
+let setDcbQueueUrl = (~isFifo=false, ~resource=?, url) => {
+  if dcbQueueUrlRef.contents->Option.isNone {
+    dcbQueueUrlRef := Some(url)
+    dcbQueueIsFifo := isFifo
+  }
+  resource->Option.forEach(r => dcbQueueResources->Array.push(r)->ignore)
+}
 // The admin/plugin DCB command-topic FIFO URL captured by the
 // onDcbCommandTopicCreated hook. Read by the admin EventCollector's reactive
 // ApiFragmentRegistry push (2e) to dispatch RecordApiFragmentPush.
@@ -62,6 +94,7 @@ let registerAutomationSlice = (
   ~context=?,
   ~sourceTopics=Dict.make(),
   ~consumesDcbLog=true,
+  ~commandTargetName=?,
 ) =>
   bundledInfos->Dict.set(
     name,
@@ -74,6 +107,7 @@ let registerAutomationSlice = (
       context,
       sourceTopics,
       consumesDcbLog,
+      commandTargetName,
     },
   )
 
@@ -147,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`.
@@ -358,9 +507,25 @@ let finishWithDcbEventLog = (dcbEventLog: ReventlessCore.DcbEventLog.component)
         let handlerOutputs: array<Pulumi.Output.t<string>> = []
         let packageDirs: dict<string> = Dict.make()
         let allQueryDbResources: array<ReventlessInfra.Adapter.resource> = []
+        // Whether any slice publishes to the DCB fallback rather than a target
+        // aggregate's own topic — if so, that queue needs the SendMessage grant
+        // too, once, below the loop.
+        let anyDcbFallback = ref(false)
 
         bundledInfos->Dict.forEachWithKey((info, _name) => {
           info.queryDbResources->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
+          // named target resolves here; anything else keeps the DCB fallback.
+          let target = info.commandTargetName->Option.flatMap(CommandTopicRegistry.get)
+          switch target {
+          | Some({resource}) =>
+            // The target CommandTopic joins the channel's resources so
+            // `connectLambda`'s existing `sqs:SendMessage` grant covers it.
+            allQueryDbResources->Array.push(resource)->ignore
+          | None => anyDcbFallback := true
+          }
           let pkg = Util_Bundle.extractPackageName(info.specModulePath)
           packageDirs->Dict.set(pkg, Util_Bundle.resolvePackageRoot(pkg))
           // Usually the same package as the spec, but bundle it explicitly —
@@ -380,8 +545,16 @@ let finishWithDcbEventLog = (dcbEventLog: ReventlessCore.DcbEventLog.component)
           | None => ""
           }
 
+          // Per slice, not plugin-wide: an outbound slice targeting an Aggregate
+          // publishes to that aggregate's CommandTopic. Everything else keeps the
+          // DCB topic, which is what the field has always meant — and with it the
+          // DCB queue's own flavor.
+          let (commandQueueUrl, commandQueueIsFifo) = switch target {
+          | Some({queueUrl, isFifo}) => (queueUrl, isFifo)
+          | None => (dcbQueueUrl, dcbQueueIsFifo.contents)
+          }
           let handlerJson =
-            Pulumi.Output.all3((info.queryDbTableName, dcbQueueUrl, sourceUrnsFor(info)))
+            Pulumi.Output.all3((info.queryDbTableName, commandQueueUrl, sourceUrnsFor(info)))
             ->Pulumi.Output.apply(((tableName, queueUrl, urns)) => {
               let urnsJson =
                 urns->Array.map(JSON.Encode.string)->JSON.Encode.array->JSON.stringify
@@ -389,11 +562,20 @@ let finishWithDcbEventLog = (dcbEventLog: ReventlessCore.DcbEventLog.component)
               // an entry point that predates multi-source still routes its first
               // stream rather than none.
               let firstUrn = urns->Array.get(0)->Option.getOr("")
-              `{"specModule":${specModule},"bodyModule":${bodyModule},"callbackType":${callbackType},"queryDbTableName":"${tableName}","dcbQueueUrl":"${queueUrl}","sourceUrn":"${firstUrn}","sourceUrns":${urnsJson}${contextFragment}}`
+              let fifoJson = commandQueueIsFifo ? "true" : "false"
+              `{"specModule":${specModule},"bodyModule":${bodyModule},"callbackType":${callbackType},"queryDbTableName":"${tableName}","dcbQueueUrl":"${queueUrl}","commandQueueIsFifo":${fifoJson},"sourceUrn":"${firstUrn}","sourceUrns":${urnsJson}${contextFragment}}`
             })
           let _ = handlerOutputs->Array.push(handlerJson)
         })
 
+        // The fallback publishers' grant. Every slice that resolved no target
+        // publishes to the plugin's DCB command topic, whose queue was captured
+        // by `setDcbQueueUrl` — without this the role has no `sqs:SendMessage`
+        // there and every such publish is rejected.
+        if anyDcbFallback.contents {
+          dcbQueueResources->Array.forEach(r => allQueryDbResources->Array.push(r)->ignore)
+        }
+
         let handlerConfigOutput =
           Pulumi.Output.all(handlerOutputs)
           ->Pulumi.Output.apply(handlers => `{"handlers":[${handlers->Array.join(",")}]}`)
@@ -434,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,23 @@
 // 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";
 import * as EventCollectorChannel_DynamoDbStream$ReventlessAws from "../EventCollector/EventCollectorChannel_DynamoDbStream.res.mjs";
@@ -20,15 +30,28 @@ let dcbQueueUrlRef = {
   contents: undefined
 };
 
-function setDcbQueueUrl(url) {
-  dcbQueueUrlRef.contents = url;
+let dcbQueueIsFifo = {
+  contents: false
+};
+
+let dcbQueueResources = [];
+
+function setDcbQueueUrl(isFifoOpt, resource, url) {
+  let isFifo = isFifoOpt !== undefined ? isFifoOpt : false;
+  if (Stdlib_Option.isNone(dcbQueueUrlRef.contents)) {
+    dcbQueueUrlRef.contents = url;
+    dcbQueueIsFifo.contents = isFifo;
+  }
+  Stdlib_Option.forEach(resource, r => {
+    dcbQueueResources.push(r);
+  });
 }
 
 function getDcbQueueUrl() {
   return dcbQueueUrlRef.contents;
 }
 
-function registerAutomationSlice(name, specModulePath, bodyModulePath, callbackTypeOpt, queryDbTableName, queryDbResourcesOpt, context, sourceTopicsOpt, consumesDcbLogOpt) {
+function registerAutomationSlice(name, specModulePath, bodyModulePath, callbackTypeOpt, queryDbTableName, queryDbResourcesOpt, context, sourceTopicsOpt, consumesDcbLogOpt, commandTargetName) {
   let callbackType = callbackTypeOpt !== undefined ? callbackTypeOpt : "automation";
   let queryDbResources = queryDbResourcesOpt !== undefined ? queryDbResourcesOpt : [];
   let sourceTopics = sourceTopicsOpt !== undefined ? sourceTopicsOpt : ({});
@@ -41,7 +64,8 @@ function registerAutomationSlice(name, specModulePath, bodyModulePath, callbackT
     queryDbResources: queryDbResources,
     context: context,
     sourceTopics: sourceTopics,
-    consumesDcbLog: consumesDcbLog
+    consumesDcbLog: consumesDcbLog,
+    commandTargetName: commandTargetName
   };
 }
 
@@ -81,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
 };
@@ -195,10 +264,19 @@ function finishWithDcbEventLog(dcbEventLog) {
       let handlerOutputs = [];
       let packageDirs = {};
       let allQueryDbResources = [];
+      let anyDcbFallback = {
+        contents: false
+      };
       Stdlib_Dict.forEachWithKey(bundledInfos, (info, _name) => {
         info.queryDbResources.forEach(r => {
           allQueryDbResources.push(r);
         });
+        let target = Stdlib_Option.flatMap(info.commandTargetName, CommandTopicRegistry$ReventlessAws.get);
+        if (target !== undefined) {
+          allQueryDbResources.push(target.resource);
+        } else {
+          anyDcbFallback.contents = true;
+        }
         let pkg = Util_Bundle$ReventlessAws.extractPackageName(info.specModulePath);
         packageDirs[pkg] = Util_Bundle$ReventlessAws.resolvePackageRoot(undefined, pkg);
         let bodyPkg = Util_Bundle$ReventlessAws.extractPackageName(info.bodyModulePath);
@@ -208,18 +286,32 @@ function finishWithDcbEventLog(dcbEventLog) {
         let callbackType = Stdlib_Option.getOr(JSON.stringify(info.callbackType), `""`);
         let context = info.context;
         let contextFragment = context !== undefined ? Stdlib_Option.getOr(Stdlib_Option.map(JSON.stringify(context), json => `,"context":` + json), "") : "";
+        let match = target !== undefined ? [
+            target.queueUrl,
+            target.isFifo
+          ] : [
+            dcbQueueUrl,
+            dcbQueueIsFifo.contents
+          ];
+        let commandQueueIsFifo = match[1];
         let handlerJson = Pulumi.all([
           info.queryDbTableName,
-          dcbQueueUrl,
+          match[0],
           sourceUrnsFor(info)
         ]).apply(param => {
           let urns = param[2];
           let urnsJson = JSON.stringify(urns.map(prim => prim));
           let firstUrn = Stdlib_Option.getOr(urns[0], "");
-          return `{"specModule":` + specModule + `,"bodyModule":` + bodyModule + `,"callbackType":` + callbackType + `,"queryDbTableName":"` + param[0] + `","dcbQueueUrl":"` + param[1] + `","sourceUrn":"` + firstUrn + `","sourceUrns":` + urnsJson + contextFragment + `}`;
+          let fifoJson = commandQueueIsFifo ? "true" : "false";
+          return `{"specModule":` + specModule + `,"bodyModule":` + bodyModule + `,"callbackType":` + callbackType + `,"queryDbTableName":"` + param[0] + `","dcbQueueUrl":"` + param[1] + `","commandQueueIsFifo":` + fifoJson + `,"sourceUrn":"` + firstUrn + `","sourceUrns":` + urnsJson + contextFragment + `}`;
         });
         handlerOutputs.push(handlerJson);
       });
+      if (anyDcbFallback.contents) {
+        dcbQueueResources.forEach(r => {
+          allQueryDbResources.push(r);
+        });
+      }
       let handlerConfigOutput = Pulumi.all(handlerOutputs).apply(handlers => `{"handlers":[` + handlers.join(",") + `]}`);
       let envVars = {};
       envVars["HANDLER_CONFIG"] = handlerConfigOutput;
@@ -233,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");
     }
@@ -244,18 +338,25 @@ let EventCollectorChannel;
 
 let RuntimeEnvironment;
 
+let sweepIntervalMinutes = 5;
+
 export {
   EventCollectorChannel,
   RuntimeEnvironment,
   log,
   bundledInfos,
   dcbQueueUrlRef,
+  dcbQueueIsFifo,
+  dcbQueueResources,
   setDcbQueueUrl,
   getDcbQueueUrl,
   registerAutomationSlice,
   storedSpecs,
   grandParent,
   forEventCollector,
+  sweepIntervalMinutes,
+  makeSweepSchedule,
+  makeGeocoderGrant,
   finished,
   finish,
   finishWithDcbEventLog,

package/src/components/AutomationSlice_Builder.res.mjs

@@ -46,7 +46,7 @@ function Make(Api) {
       let queryDbTableName = tableResource.name;
       let sourceTopics = EventTopic$ReventlessCore.filter(allEventTopics, Belt_SetString.fromArray(sourceNames));
       let consumesDcbLog = sourceNames.length === 0 || sourceNames.some(name => !(name in allEventTopics));
-      AutomationSliceRuntime_Builder_Single$ReventlessAws.registerAutomationSlice(Spec.name, Util_Bundle$ReventlessAws.getModuleSpecifier(Spec.moduleUrl), Util_Bundle$ReventlessAws.getModuleSpecifier(Automation.moduleUrl), "automation", queryDbTableName, queryDbOutputs.resources, context, sourceTopics, consumesDcbLog);
+      AutomationSliceRuntime_Builder_Single$ReventlessAws.registerAutomationSlice(Spec.name, Util_Bundle$ReventlessAws.getModuleSpecifier(Spec.moduleUrl), Util_Bundle$ReventlessAws.getModuleSpecifier(Automation.moduleUrl), "automation", queryDbTableName, queryDbOutputs.resources, context, sourceTopics, consumesDcbLog, undefined);
       return as_;
     };
     return {

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 = (
@@ -65,9 +80,14 @@ module Make = (Api: {
         ~bodyModulePath=Util_Bundle.getModuleSpecifier(Translation.moduleUrl),
         ~callbackType="outbound",
         ~queryDbTableName,
+        // The target queue rides along so `connectLambda`'s existing
+        // `sqs:SendMessage` grant covers it. Without it the role can publish
+        // nowhere, and the command is lost after the geocoder has been paid for.
         ~queryDbResources=queryDbOutputs.resources,
         ~sourceTopics,
         ~consumesDcbLog,
+        // Only the name: the target Aggregate's CommandTopic does not exist yet.
+        ~commandTargetName=?Spec.targetName,
       )
 
       ots

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) => {
@@ -54,7 +63,7 @@ function Make(Api) {
       let declaredSources = Spec.sourceNames;
       let sourceTopics = EventTopic$ReventlessCore.filter(allEventTopics, Belt_SetString.fromArray(declaredSources));
       let consumesDcbLog = declaredSources.length === 0 || declaredSources.some(name => !(name in allEventTopics));
-      AutomationSliceRuntime_Builder_Single$ReventlessAws.registerAutomationSlice(Spec.name, Util_Bundle$ReventlessAws.getModuleSpecifier(Spec.moduleUrl), Util_Bundle$ReventlessAws.getModuleSpecifier(Translation.moduleUrl), "outbound", queryDbTableName, queryDbOutputs.resources, undefined, sourceTopics, consumesDcbLog);
+      AutomationSliceRuntime_Builder_Single$ReventlessAws.registerAutomationSlice(Spec.name, Util_Bundle$ReventlessAws.getModuleSpecifier(Spec.moduleUrl), Util_Bundle$ReventlessAws.getModuleSpecifier(Translation.moduleUrl), "outbound", queryDbTableName, queryDbOutputs.resources, undefined, sourceTopics, consumesDcbLog, Spec.targetName);
       return ots;
     };
     return {
@@ -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,