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

package/CHANGELOG.md

@@ -3,6 +3,23 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+# 3.0.0-alpha.266 (2026-08-04)
+
+### Features
+
+* **geocoding:** serve geocoding through the platform GraphQL API (D9 half 2) ([914d3c0](https://github.com/ReventlessDev/reventless-core/commit/914d3c0a99a1b67ffb89e2b8259dd30f67ff9bae))
+
+
+# 3.0.0-alpha.265 (2026-08-04)
+
+### Bug Fixes
+
+* **aws:** make a slice's TODO backlog survive, and actually sweep it ([f35dcbd](https://github.com/ReventlessDev/reventless-core/commit/f35dcbd86374124106c2d1e48d29c6f41fdbec2c))
+### Features
+
+* **outbound:** hand translate its geocoder instead of making it fetch one ([fb18312](https://github.com/ReventlessDev/reventless-core/commit/fb1831216b37c9562868c46e1a09054e69418c67))
+
+
 # 3.0.0-alpha.264 (2026-08-03)
 
 ### Bug Fixes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reventlessdev/reventless-aws",
-  "version": "3.0.0-alpha.264",
+  "version": "3.0.0-alpha.266",
   "description": "AWS adapters for Reventless",
   "license": "Apache-2.0",
   "dependencies": {
@@ -13,16 +13,16 @@
     "uuid": "^13.0.0",
     "@reventlessdev/rescript-aws-sdk": "3.0.0-alpha.3",
     "@reventlessdev/rescript-effect": "0.1.0-alpha.32",
+    "@reventlessdev/rescript-node": "2.0.0-alpha.1",
     "@reventlessdev/rescript-jest": "1.0.0-alpha.10",
     "@reventlessdev/rescript-pulumi-aws": "2.4.0-alpha.65",
-    "@reventlessdev/rescript-node": "2.0.0-alpha.1",
     "@reventlessdev/rescript-pulumi-pulumi": "2.3.0-alpha.18",
     "@reventlessdev/rescript-uuid": "2.0.0-alpha.0",
-    "@reventlessdev/reventless-core": "3.0.0-alpha.209",
-    "@reventlessdev/reventless-infra": "3.0.0-alpha.124",
-    "@reventlessdev/reventless-spec": "3.0.0-alpha.99",
-    "@reventlessdev/reventless-postgres": "3.0.0-alpha.73",
-    "@reventlessdev/reventless-interop": "3.0.0-alpha.30"
+    "@reventlessdev/reventless-core": "3.0.0-alpha.211",
+    "@reventlessdev/reventless-infra": "3.0.0-alpha.126",
+    "@reventlessdev/reventless-spec": "3.0.0-alpha.100",
+    "@reventlessdev/reventless-interop": "3.0.0-alpha.30",
+    "@reventlessdev/reventless-postgres": "3.0.0-alpha.75"
   },
   "devDependencies": {
     "rescript": "12.3.0",

package/src/Platform.res

@@ -82,19 +82,22 @@ let objectStoreEndpointsRef: ref<array<objectStoreEndpoint>> = ref([])
     `getApiConfig` does. */
 let getObjectStoreEndpoints = () => objectStoreEndpointsRef.contents
 
-/** The geocoder endpoint this platform provisioned, for the monolithic case.
+/** The geocoding place index this platform provisioned, for the monolithic case.
 
-    In plugin mode the value crosses to the plugin stack as the `geocoderEndpoint`
+    In plugin mode the value crosses to the plugin stack as the `geocoderPlaceIndex`
     export; when platform and plugin are one program there is no stack to read, so
     `deployPlatform` records it here and `deployPlugin` picks it up — the same two
-    halves `objectStoreEndpointsRef` exists for.
+    halves `objectStoreEndpointsRef` exists for. Slice Lambdas call Amazon Location
+    directly with this index name; the browser reaches the same capability through
+    the platform API's `Query.geocode` resolver (D9 half 2), so there is no endpoint
+    to carry beside it.
 
     A plain Output with `""` as the "no geocoder" sentinel, never
     `option<Pulumi.Output.t<_>>`: any generic `Option.*` over an Output runs
     `valFromOption`, whose nested-option probe hits the Output proxy — where every
     property access returns a truthy Output — and corrupts it. Same reasoning, and
     the same sentinel, as `PluginRuntime_Builder.inboundSliceReg.auditTableName`. */
-let geocoderEndpointRef: ref<Pulumi.Output.t<string>> = ref(Pulumi.Output.make(""))
+let geocoderPlaceIndexRef: ref<Pulumi.Output.t<string>> = ref(Pulumi.Output.make(""))
 
 module MakeWithConfig = (
   Config: {
@@ -242,9 +245,15 @@ module MakeWithConfig = (
   // unified mode carries the admin base here instead; it declares no stores in practice,
   // so the upload resolvers below are never created there.)
   let domainBaseFragment = ReventlessCore.GraphQL_Stitcher.encode({
-    types: ReventlessCore.Platform_AdminApi.uploadTypes,
+    types: Array.concat(
+      ReventlessCore.Platform_AdminApi.uploadTypes,
+      ReventlessCore.Platform_AdminApi.geocodeTypes,
+    ),
     mutations: ReventlessCore.Platform_AdminApi.uploadMutationFields,
-    queries: ["  Platform_ping: String"],
+    queries: Array.concat(
+      ["  Platform_ping: String"],
+      ReventlessCore.Platform_AdminApi.geocodeQueryFields,
+    ),
     subscriptions: [],
     subscriptionSources: [],
   })
@@ -1146,10 +1155,10 @@ module MakeWithConfig = (
     // unchanged. Single-mode shape: one origin-relative file per deployment.
     uiHintsFile?: string,
     // Optional geocoding place index, as returned by
-    // `Capability_Geocoding_AwsLocation.make`. When set, the deploy provisions a
-    // public geocoder Lambda Function URL (Geocoder_AwsLocation) and threads its
-    // URL into config.json as `geocoderEndpoint`. Unset ⇒ no service, field
-    // omitted (byte-identical config.json).
+    // `Capability_Geocoding_AwsLocation.make`. When set, the deploy provisions the
+    // capability's client door — a Cognito-authenticated `Query.geocode` resolver
+    // on the domain API (`Geocoder_AwsLocation_Resolver`, split mode) — and exports
+    // the index name for the unattended slice path. Unset ⇒ no resolver, no export.
     geocoderPlaceIndex?: ReventlessInfra.Platform.geocoderIndex,
     // Optional object store for direct-to-S3 uploads, as returned by
     // `Capability_ObjectStore_S3.make`. When set, the deploy registers it with
@@ -2060,28 +2069,38 @@ module MakeWithConfig = (
       | None => Pulumi.Output.make(None)
       }
 
-      // Optional public geocoder Function URL. Provisioned only when a place
-      // index is configured; its resolved URL becomes config.json's
-      // `geocoderEndpoint`. Unset ⇒ Output<None> ⇒ field omitted below.
-      let geocoderEndpointOutput: Pulumi.Output.t<option<string>> = switch cfg.geocoderPlaceIndex {
-      | Some(index) =>
-        Geocoder_AwsLocation.make(
+      // The geocoding capability's client door (D9 half 2): a `Query.geocode`
+      // resolver on the domain API, provisioned only when a place index is
+      // configured. Authenticated by the API's Cognito authorizer, so it replaces
+      // the public unauthenticated Function URL the browser used to call — after
+      // which that endpoint has no callers at all (the unattended slice path reaches
+      // the same index through the SDK, via `geocoderPlaceIndex` below).
+      //
+      // Split-API only, for the same reason the upload resolvers are: `geocode`
+      // lives on the domain base document (`domainBaseFragment`), which a
+      // unified-mode deployment's single API does not carry.
+      switch cfg.geocoderPlaceIndex {
+      | Some(index) if Config.splitApi =>
+        let _geocodeService = Geocoder_AwsLocation_Resolver.make(
+          ~api=domainApi,
           ~placeIndexName=index.indexName,
-        ).url->Pulumi.Output.apply(u => Some(u))
-      | None => Pulumi.Output.make(None)
+          ~opts={},
+        )
+      | _ => ()
       }
 
-      // Exported as well as written into config.json, because the browser is no
-      // longer the only caller: a plugin stack's slice Lambdas geocode too, and a
-      // plugin stack has no other way to see a value computed in this one.
-      //
-      // `""` when unset rather than a missing output, so the read side has one
-      // shape to handle instead of two — and "" is already what a client reads as
-      // "no geocoder configured".
-      let geocoderEndpointFlat =
-        geocoderEndpointOutput->Pulumi.Output.apply(o => o->Option.getOr(""))
-      Pulumi.Pulumi.export("geocoderEndpoint", geocoderEndpointFlat)
-      geocoderEndpointRef := geocoderEndpointFlat
+      // The place index itself, exported so the unattended slice path can reach the
+      // capability: a slice's Lambda signs an SDK call directly and needs the index
+      // name, not an endpoint (no proxy hop, no dependence on a public URL). The
+      // browser reaches the same capability through the `Query.geocode` resolver
+      // above. `""` when unset, so a plugin stack reading this output has one shape
+      // to handle rather than two.
+      let geocoderPlaceIndexFlat = switch cfg.geocoderPlaceIndex {
+      | Some(index) => index.indexName->Pulumi.Output.fromInput
+      | None => Pulumi.Output.make("")
+      }
+      Pulumi.Pulumi.export("geocoderPlaceIndex", geocoderPlaceIndexFlat)
+      geocoderPlaceIndexRef := geocoderPlaceIndexFlat
 
       // Presign endpoints are no longer written to config.json: under route B the
       // client calls the platform API's `Upload_Presign` mutation (reachable from
@@ -2097,14 +2116,9 @@ module MakeWithConfig = (
             cognitoPool.clientId,
           )->Pulumi.Output.all4,
           domainEventsEndpointOutput,
-          geocoderEndpointOutput,
         )
-        ->Pulumi.Output.all3
-        ->Pulumi.Output.apply(((
-          (domainEp, platformEp, poolId, clientId),
-          eventsEpOpt,
-          geocoderEpOpt,
-        )) => {
+        ->Pulumi.Output.all2
+        ->Pulumi.Output.apply((((domainEp, platformEp, poolId, clientId), eventsEpOpt)) => {
           let computed = [
             ("apiEndpoint", JSON.Encode.string(domainEp)),
             ("platformApiEndpoint", JSON.Encode.string(platformEp)),
@@ -2132,12 +2146,12 @@ module MakeWithConfig = (
             )
           | None => computed
           }
-          let withGeocoder = switch geocoderEpOpt {
-          | Some(ep) => Array.concat(withEvents, [("geocoderEndpoint", JSON.Encode.string(ep))])
-          | None => withEvents
-          }
+          // `geocoderEndpoint` is no longer written: the browser reaches geocoding
+          // through the platform API's `Query.geocode` resolver (D9 half 2), the
+          // same way uploads moved off a per-store URL onto `Upload_Presign`. The
+          // public Function URL and its config key are both gone.
           Util_ShellConfig.fields(
-            ~computed=withGeocoder,
+            ~computed=withEvents,
             ~viewModes=?cfg.viewModes,
             ~shellConfig=?cfg.shellConfig,
           )
@@ -2251,15 +2265,22 @@ module MakeWithConfig = (
     // is a modelled outcome, which is the point of the empty string: a plugin
     // deployed against a platform without the capability degrades rather than
     // failing to deploy.
-    let geocoderEndpoint: Pulumi.Output.t<string> = switch platformStackRef {
+    // The place index, not the Function URL. A slice's Lambda reaches Amazon
+    // Location through the SDK now, so what it needs is the index's name — and
+    // the grant that goes with it, which is why this is also handed to
+    // `registerGeocoderPlaceIndex` rather than only to the environment. The
+    // browser keeps using the Function URL until the platform API carries a
+    // geocode field; the two doors are independent.
+    let geocoderPlaceIndex: Pulumi.Output.t<string> = switch platformStackRef {
     | Some(stackRef) =>
       (
-        stackRef->Pulumi.StackReference.getOutput("geocoderEndpoint"):
+        stackRef->Pulumi.StackReference.getOutput("geocoderPlaceIndex"):
           Pulumi.Output.t<option<string>>
       )->Pulumi.Output.apply(o => o->Option.getOr(""))
-    | None => geocoderEndpointRef.contents
+    | None => geocoderPlaceIndexRef.contents
     }
-    PluginRuntime_Builder.registerCapabilityEnv("GEOCODER_ENDPOINT", geocoderEndpoint)
+    PluginRuntime_Builder.registerCapabilityEnv("PLACE_INDEX_NAME", geocoderPlaceIndex)
+    PluginRuntime_Builder.registerGeocoderPlaceIndex(geocoderPlaceIndex)
 
     module P = unpack(plugin)
     let pluginComponent = P.make()

package/src/Platform.res.mjs

@@ -59,7 +59,6 @@ import * as AppSync_SdlDecorate$ReventlessAws from "./components/Api/AppSync_Sdl
 import * as UiFragmentRegistry$ReventlessCore from "@reventlessdev/reventless-core/src/admin/UiFragmentRegistry/StateChangeSlice/UiFragmentRegistry.res.mjs";
 import * as Util_ResourceNaming$ReventlessAws from "./util/Util_ResourceNaming.res.mjs";
 import * as ClonerRunner_Fargate$ReventlessAws from "./plugin/cloner/ClonerRunner_Fargate.res.mjs";
-import * as Geocoder_AwsLocation$ReventlessAws from "./adapter/Geocoder/Geocoder_AwsLocation.res.mjs";
 import * as QueryEngine_DynamoDb$ReventlessAws from "./adapter/QueryEngine/QueryEngine_DynamoDb.res.mjs";
 import * as PluginRuntime_Builder$ReventlessAws from "./plugin/runtime/PluginRuntime_Builder.res.mjs";
 import * as PluginsReadModelSpec$ReventlessCore from "@reventlessdev/reventless-core/src/plugin/lifecycle/PluginsReadModelSpec.res.mjs";
@@ -85,6 +84,7 @@ import * as CommandTopicChannel_SQS_Sync$ReventlessAws from "./adapter/CommandTo
 import * as EventLogSubscription_AppSync$ReventlessAws from "./adapter/EventLogSubscription/EventLogSubscription_AppSync.res.mjs";
 import * as UiFragmentRegistry_Behavior$ReventlessCore from "@reventlessdev/reventless-core/src/admin/UiFragmentRegistry/StateChangeSlice/UiFragmentRegistry_Behavior.res.mjs";
 import * as CommandTopicChannel_SQS_Async$ReventlessAws from "./adapter/CommandTopic/CommandTopicChannel_SQS_Async.res.mjs";
+import * as Geocoder_AwsLocation_Resolver$ReventlessAws from "./adapter/Geocoder/Geocoder_AwsLocation_Resolver.res.mjs";
 import * as Plugin_ExtensionPoint_Builder$ReventlessAws from "./plugin/stack/Plugin_ExtensionPoint_Builder.res.mjs";
 import * as QueryDbStorage_DynamoDbStream$ReventlessAws from "./adapter/QueryDb/QueryDbStorage_DynamoDbStream.res.mjs";
 import * as StateViewSlice_Builder_Stream$ReventlessAws from "./components/StateViewSlice_Builder_Stream.res.mjs";
@@ -130,7 +130,7 @@ function getObjectStoreEndpoints() {
   return objectStoreEndpointsRef.contents;
 }
 
-let geocoderEndpointRef = {
+let geocoderPlaceIndexRef = {
   contents: Pulumi.output("")
 };
 
@@ -189,9 +189,9 @@ function MakeWithConfig(Config) {
     }
   };
   let domainBaseFragment = GraphQL_Stitcher$ReventlessCore.encode({
-    types: Platform_AdminApi$ReventlessCore.uploadTypes,
+    types: Platform_AdminApi$ReventlessCore.uploadTypes.concat(Platform_AdminApi$ReventlessCore.geocodeTypes),
     mutations: Platform_AdminApi$ReventlessCore.uploadMutationFields,
-    queries: ["  Platform_ping: String"],
+    queries: ["  Platform_ping: String"].concat(Platform_AdminApi$ReventlessCore.geocodeQueryFields),
     subscriptions: [],
     subscriptionSources: []
   });
@@ -1127,10 +1127,13 @@ function MakeWithConfig(Config) {
       let cognitoPool = Platform_Stack$ReventlessAws.resolveCognitoUserPool();
       let domainEventsEndpointOutput = domainEventsApiOpt !== undefined ? AppSync_EventsApi$ReventlessAws.httpEndpoint(domainEventsApiOpt).apply(ep => ep + "/event") : Pulumi.output(undefined);
       let index = hostUiBundle.geocoderPlaceIndex;
-      let geocoderEndpointOutput = index !== undefined ? Geocoder_AwsLocation$ReventlessAws.make(index.indexName, undefined, undefined).url.apply(u => u) : Pulumi.output(undefined);
-      let geocoderEndpointFlat = geocoderEndpointOutput.apply(o => Stdlib_Option.getOr(o, ""));
-      Pulumi$Pulumi.$$export("geocoderEndpoint", geocoderEndpointFlat);
-      geocoderEndpointRef.contents = geocoderEndpointFlat;
+      if (index !== undefined && Config.splitApi) {
+        Geocoder_AwsLocation_Resolver$ReventlessAws.make(domainApi, index.indexName, undefined, {});
+      }
+      let index$1 = hostUiBundle.geocoderPlaceIndex;
+      let geocoderPlaceIndexFlat = index$1 !== undefined ? index$1.indexName : Pulumi.output("");
+      Pulumi$Pulumi.$$export("geocoderPlaceIndex", geocoderPlaceIndexFlat);
+      geocoderPlaceIndexRef.contents = geocoderPlaceIndexFlat;
       let configJsonContent = Pulumi.all([
         Pulumi.all([
           resolvedDomainApiEndpoint,
@@ -1138,10 +1141,8 @@ function MakeWithConfig(Config) {
           cognitoPool.poolId,
           cognitoPool.clientId
         ]),
-        domainEventsEndpointOutput,
-        geocoderEndpointOutput
+        domainEventsEndpointOutput
       ]).apply(param => {
-        let geocoderEpOpt = param[2];
         let eventsEpOpt = param[1];
         let match = param[0];
         let computed = [
@@ -1188,11 +1189,7 @@ function MakeWithConfig(Config) {
               AppSync_EventsApi$ReventlessAws.clientNamespaceName
             ]
           ]) : computed;
-        let withGeocoder = geocoderEpOpt !== undefined ? withEvents.concat([[
-              "geocoderEndpoint",
-              geocoderEpOpt
-            ]]) : withEvents;
-        return JSON.stringify(Util_ShellConfig$ReventlessAws.fields(withGeocoder, hostUiBundle.viewModes, hostUiBundle.shellConfig));
+        return JSON.stringify(Util_ShellConfig$ReventlessAws.fields(withEvents, hostUiBundle.viewModes, hostUiBundle.shellConfig));
       });
       new (Aws.s3.BucketObject)("host-ui-config-json", {
         bucket: bucketName,
@@ -1247,8 +1244,9 @@ function MakeWithConfig(Config) {
         bytes: bytes.length
       };
     });
-    let geocoderEndpoint = platformStackRef !== undefined ? Primitive_option.valFromOption(platformStackRef).getOutput("geocoderEndpoint").apply(o => Stdlib_Option.getOr(o, "")) : geocoderEndpointRef.contents;
-    PluginRuntime_Builder$ReventlessAws.registerCapabilityEnv("GEOCODER_ENDPOINT", geocoderEndpoint);
+    let geocoderPlaceIndex = platformStackRef !== undefined ? Primitive_option.valFromOption(platformStackRef).getOutput("geocoderPlaceIndex").apply(o => Stdlib_Option.getOr(o, "")) : geocoderPlaceIndexRef.contents;
+    PluginRuntime_Builder$ReventlessAws.registerCapabilityEnv("PLACE_INDEX_NAME", geocoderPlaceIndex);
+    PluginRuntime_Builder$ReventlessAws.registerGeocoderPlaceIndex(geocoderPlaceIndex);
     let pluginComponent = plugin.make();
     Plugin_Helpers$ReventlessCore.clearOffload();
     currentDeployTarget.contents = "Domain";
@@ -1443,9 +1441,9 @@ function Make($star) {
     }
   };
   let domainBaseFragment = GraphQL_Stitcher$ReventlessCore.encode({
-    types: Platform_AdminApi$ReventlessCore.uploadTypes,
+    types: Platform_AdminApi$ReventlessCore.uploadTypes.concat(Platform_AdminApi$ReventlessCore.geocodeTypes),
     mutations: Platform_AdminApi$ReventlessCore.uploadMutationFields,
-    queries: ["  Platform_ping: String"],
+    queries: ["  Platform_ping: String"].concat(Platform_AdminApi$ReventlessCore.geocodeQueryFields),
     subscriptions: [],
     subscriptionSources: []
   });
@@ -2358,10 +2356,13 @@ function Make($star) {
       let cognitoPool = Platform_Stack$ReventlessAws.resolveCognitoUserPool();
       let domainEventsEndpointOutput = domainEventsApiOpt !== undefined ? AppSync_EventsApi$ReventlessAws.httpEndpoint(domainEventsApiOpt).apply(ep => ep + "/event") : Pulumi.output(undefined);
       let index = hostUiBundle.geocoderPlaceIndex;
-      let geocoderEndpointOutput = index !== undefined ? Geocoder_AwsLocation$ReventlessAws.make(index.indexName, undefined, undefined).url.apply(u => u) : Pulumi.output(undefined);
-      let geocoderEndpointFlat = geocoderEndpointOutput.apply(o => Stdlib_Option.getOr(o, ""));
-      Pulumi$Pulumi.$$export("geocoderEndpoint", geocoderEndpointFlat);
-      geocoderEndpointRef.contents = geocoderEndpointFlat;
+      if (index !== undefined) {
+        Geocoder_AwsLocation_Resolver$ReventlessAws.make(domainApi, index.indexName, undefined, {});
+      }
+      let index$1 = hostUiBundle.geocoderPlaceIndex;
+      let geocoderPlaceIndexFlat = index$1 !== undefined ? index$1.indexName : Pulumi.output("");
+      Pulumi$Pulumi.$$export("geocoderPlaceIndex", geocoderPlaceIndexFlat);
+      geocoderPlaceIndexRef.contents = geocoderPlaceIndexFlat;
       let configJsonContent = Pulumi.all([
         Pulumi.all([
           resolvedDomainApiEndpoint,
@@ -2369,10 +2370,8 @@ function Make($star) {
           cognitoPool.poolId,
           cognitoPool.clientId
         ]),
-        domainEventsEndpointOutput,
-        geocoderEndpointOutput
+        domainEventsEndpointOutput
       ]).apply(param => {
-        let geocoderEpOpt = param[2];
         let eventsEpOpt = param[1];
         let match = param[0];
         let computed = [
@@ -2419,11 +2418,7 @@ function Make($star) {
               AppSync_EventsApi$ReventlessAws.clientNamespaceName
             ]
           ]) : computed;
-        let withGeocoder = geocoderEpOpt !== undefined ? withEvents.concat([[
-              "geocoderEndpoint",
-              geocoderEpOpt
-            ]]) : withEvents;
-        return JSON.stringify(Util_ShellConfig$ReventlessAws.fields(withGeocoder, hostUiBundle.viewModes, hostUiBundle.shellConfig));
+        return JSON.stringify(Util_ShellConfig$ReventlessAws.fields(withEvents, hostUiBundle.viewModes, hostUiBundle.shellConfig));
       });
       new (Aws.s3.BucketObject)("host-ui-config-json", {
         bucket: bucketName,
@@ -2478,8 +2473,9 @@ function Make($star) {
         bytes: bytes.length
       };
     });
-    let geocoderEndpoint = platformStackRef !== undefined ? Primitive_option.valFromOption(platformStackRef).getOutput("geocoderEndpoint").apply(o => Stdlib_Option.getOr(o, "")) : geocoderEndpointRef.contents;
-    PluginRuntime_Builder$ReventlessAws.registerCapabilityEnv("GEOCODER_ENDPOINT", geocoderEndpoint);
+    let geocoderPlaceIndex = platformStackRef !== undefined ? Primitive_option.valFromOption(platformStackRef).getOutput("geocoderPlaceIndex").apply(o => Stdlib_Option.getOr(o, "")) : geocoderPlaceIndexRef.contents;
+    PluginRuntime_Builder$ReventlessAws.registerCapabilityEnv("PLACE_INDEX_NAME", geocoderPlaceIndex);
+    PluginRuntime_Builder$ReventlessAws.registerGeocoderPlaceIndex(geocoderPlaceIndex);
     let pluginComponent = plugin.make();
     Plugin_Helpers$ReventlessCore.clearOffload();
     currentDeployTarget.contents = "Domain";
@@ -2631,7 +2627,7 @@ export {
   getSplitApiOutputs,
   objectStoreEndpointsRef,
   getObjectStoreEndpoints,
-  geocoderEndpointRef,
+  geocoderPlaceIndexRef,
   MakeWithConfig,
   Make,
 }

package/src/adapter/Geocoder/Geocoder_AwsLocation_Resolver.res

@@ -0,0 +1,227 @@
+// AWS Location Service geocoder, mounted on the platform GraphQL API.
+//
+// Deploy-time only: `make` provisions one compiled-EntryPoint Lambda (a plain
+// `Lambda.Function` whose code archive re-exports `handler` from the compiled,
+// type-checked runtime module `Geocoder_AwsLocation_Resolver_Ops` and ships the
+// shared ESM resolve-hook loader), an IAM execution role scoped to CloudWatch Logs
+// + `geo:SearchPlaceIndexForText` on the target place index, an AppSync Lambda data
+// source, and one resolver — `Query.geocode` — on the platform API.
+//
+// There is no Function URL and no anonymous surface: authentication is the platform
+// API's Cognito authorizer. This is the *client* door of the geocoding capability
+// (D9 half 2), replacing the public Function URL the browser used to call. The
+// unattended slice path reaches the same place index through the SDK directly
+// (`Geocoder_AwsLocation_Backend`), so one capability, two doors — the same shape
+// the object store already has with `Upload_Presign` and `Offload.resolve`.
+//
+// Why an EntryPoint and not a Pulumi `CallbackFunction`: same SDK-skew reason as the
+// upload service — a serialized closure bakes the deploy machine's version-specific
+// AWS SDK internals into the archive but then resolves `@smithy/*`/`@aws-sdk/*`
+// transitives from independently-versioned layer/runtime sources that disagree at
+// cold start. Shipping the compiled `_Ops` module with bare `@aws-sdk/*` imports,
+// resolved through the resolve-hook, loads one internally consistent SDK. The
+// runtime logic lives in [Geocoder_AwsLocation_Resolver_Ops.res].
+
+open PulumiAws
+
+type serviceOutputs = {resources: array<Pulumi.Output.t<string>>}
+
+// JS resolver code (APPSYNC_JS runtime): forward the caller's arguments to the
+// Lambda. CORS and auth belong to the API, not to this code. No identity is
+// forwarded — geocoding is not scoped per caller (any authenticated user may
+// resolve any address), unlike the upload service which namespaces objects by the
+// verified `sub`.
+let invokeCode: Pulumi.Input.t<string> =
+  `import { util } from '@aws-appsync/utils';
+export function request(ctx) {
+  return { operation: 'Invoke', payload: { arguments: ctx.args } };
+}
+export function response(ctx) {
+  if (ctx.error) util.error(ctx.error.message, ctx.error.type);
+  return ctx.result;
+}
+`->Pulumi.Input.make
+
+let make = (
+  ~api: Pulumi.Output.t<AppSync.GraphQLApi.t>,
+  ~placeIndexName: Pulumi.Input.t<string>,
+  ~name: string="GeocodeService",
+  ~opts: Pulumi.ComponentResource.options,
+): serviceOutputs => {
+  let opts = opts->ReventlessCore.Util.Pulumi.ComponentResourceOptions.toCustomResourceOptions
+
+  let lambdaRole = IAM.Role.makeWithDefaultPolicy(
+    ~name=name ++ "Lambda",
+    ~servicePrincipal=AWS.Lambda.principal->Pulumi.Output.make,
+    ~tags=AWS.Tags.make(
+      ~name=name ++ "Lambda",
+      ~kind=ReventlessCore.ComponentType.Platform,
+      ~role=Identity,
+      ~scope=Platform,
+    ),
+    ~opts,
+  )
+
+  // CloudWatch Logs (so failures are observable) plus least-privilege
+  // `geo:SearchPlaceIndexForText` on the one place index — the same grant the
+  // Function URL flavour carried, now on a resolver-invoked Lambda.
+  let _policy =
+    placeIndexName
+    ->Pulumi.Output.fromInput
+    ->Pulumi.Output.apply(idx => {
+      let arn = `arn:aws:geo:*:*:place-index/${idx}`
+      let _ = IAM.RolePolicy.make(
+        ~name=name ++ "LambdaPolicy",
+        ~args={
+          policy: PolicyDocument.make(
+            ~id=name ++ "LambdaPolicy",
+            ~statements=[
+              {
+                sid: "AllowLambdaLogging",
+                effect: Allow,
+                actions: Actions(["logs:CreateLogGroup", "logs:CreateLogStream", "logs:PutLogEvents"]),
+                resources: Resource("arn:aws:logs:*:*:*"),
+              },
+              {
+                sid: "AllowGeocode",
+                effect: Allow,
+                actions: Action("geo:SearchPlaceIndexForText"),
+                resources: Resource(arn),
+              },
+            ],
+          )
+          ->PolicyDocument.toJsonString
+          ->Pulumi.Input.make,
+          role: lambdaRole.id->Pulumi.Output.asInput,
+        },
+        ~opts,
+      )
+    })
+
+  // Bundle reventless-aws (the compiled `_Ops` handler lives inside it) and
+  // re-export its `handler`; buildCodeArchive also ships the ESM resolve-hook.
+  let packageDirs = Dict.fromArray([
+    (
+      "@reventlessdev/reventless-aws",
+      Util_Bundle.resolvePackageRoot("@reventlessdev/reventless-aws"),
+    ),
+  ])
+  let {code, sourceCodeHash} = Util_Bundle.buildCodeArchive(
+    ~entryPointModule="@reventlessdev/reventless-aws/src/adapter/Geocoder/Geocoder_AwsLocation_Resolver_Ops.res.mjs",
+    ~packageDirs,
+  )
+
+  let layers =
+    Lambda.reventlessLayerArn
+    ->Option.map(arn => [arn->Pulumi.Input.make])
+    ->Option.getOr([])
+    ->Pulumi.Input.make
+
+  let lambda = Lambda.Function.make(
+    ~name=name ++ "Lambda",
+    ~args={
+      handler: "index.handler"->Pulumi.Input.make,
+      runtime: "nodejs22.x"->Pulumi.Input.make,
+      code: code->Pulumi.Input.make,
+      sourceCodeHash: sourceCodeHash->Pulumi.Input.make,
+      role: lambdaRole.arn->Pulumi.Output.asInput,
+      memorySize: 256->Pulumi.Input.make,
+      timeout: 30->Pulumi.Input.make,
+      layers,
+      tags: AWS.Tags.make(
+        ~name=name ++ "Lambda",
+        ~kind=ReventlessCore.ComponentType.Platform,
+        ~role=Runtime,
+        ~scope=Platform,
+      ),
+      environment: (
+        {
+          Lambda.Function.variables: Dict.fromArray([
+            ("Environment", Pulumi.Pulumi.getStackName()->Pulumi.Input.make),
+            ("PLACE_INDEX_NAME", placeIndexName),
+            ("NODE_OPTIONS", Util_Bundle.esmLoaderNodeOptions->Pulumi.Input.make),
+            ("ESM_FALLBACK_DIRS", Util_Bundle.esmFallbackDirs->Pulumi.Input.make),
+            Util_LambdaLogging.logLevelEntry(),
+          ]),
+        }: Lambda.Function.functionEnvironment
+      )->Pulumi.Input.make,
+    },
+    ~opts,
+  )
+
+  Util_LambdaLogging.makeManagedLogGroup(
+    ~name=name ++ "Lambda",
+    ~lambdaName=lambda.name,
+    ~tags=AWS.Tags.make(
+      ~name=name ++ "LambdaLogGroup",
+      ~kind=ReventlessCore.ComponentType.Platform,
+      ~role=Logs,
+      ~scope=Platform,
+    ),
+    ~opts,
+    (),
+  )
+
+  let dataSourceRole = IAM.Role.makeWithDefaultPolicy(
+    ~name=name ++ "DataSource",
+    ~servicePrincipal=AWS.AppSync.principal->Pulumi.Output.make,
+    ~tags=AWS.Tags.make(
+      ~name=name ++ "DataSource",
+      ~kind=ReventlessCore.ComponentType.Platform,
+      ~role=Identity,
+      ~scope=Platform,
+    ),
+    ~opts,
+  )
+
+  let _ =
+    (lambda.arn, dataSourceRole.id)
+    ->Pulumi.Output.all2
+    ->Pulumi.Output.apply(((lambdaArn, dataSourceRoleId)) => {
+      let _attach = IAM.RolePolicy.make(
+        ~name=name ++ "DataSource",
+        ~args={
+          policy: PolicyDocument.make(
+            ~id=name ++ "DataSourcePolicy",
+            ~statements=[
+              {
+                sid: "AllowDataSourceInvokeLambda",
+                effect: Allow,
+                actions: Action("lambda:InvokeFunction"),
+                resources: Resource(lambdaArn),
+              },
+            ],
+          )
+          ->PolicyDocument.toJsonString
+          ->Pulumi.Input.make,
+          role: dataSourceRoleId->Pulumi.Input.make,
+        },
+        ~opts,
+      )
+    })
+
+  let dataSource = AppSync.DataSource.make(
+    ~name=name ++ "DataSource",
+    ~args={
+      type_: AWS_LAMBDA,
+      apiId: api->Pulumi.Output.flatMap(api => api.id)->Pulumi.Output.asInput,
+      lambdaConfig: {
+        AppSync.DataSource.functionArn: lambda.arn->Pulumi.Output.asInput,
+      }->Pulumi.Input.make,
+      serviceRoleArn: dataSourceRole.arn->Pulumi.Output.asInput,
+    },
+    ~opts=Some(opts),
+  )
+
+  let _geocodeResolver = AppSync_Resolver_Native.makeUnitJsResolver(
+    ~name=name ++ "Geocode",
+    ~api,
+    ~dataSourceName=dataSource.name->Pulumi.Output.asInput,
+    ~type_="Query"->Pulumi.Input.make,
+    ~field="geocode"->Pulumi.Input.make,
+    ~code=invokeCode,
+    ~opts,
+  )
+
+  {resources: [lambda.arn]}
+}