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

package/CHANGELOG.md

@@ -3,6 +3,13 @@
 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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reventlessdev/reventless-aws",
-  "version": "3.0.0-alpha.265",
+  "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.210",
-    "@reventlessdev/reventless-infra": "3.0.0-alpha.125",
-    "@reventlessdev/reventless-postgres": "3.0.0-alpha.74",
+    "@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-interop": "3.0.0-alpha.30",
+    "@reventlessdev/reventless-postgres": "3.0.0-alpha.75"
   },
   "devDependencies": {
     "rescript": "12.3.0",

package/src/Platform.res

@@ -82,24 +82,21 @@ 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(""))
-
-/** The geocoding place index, for the monolithic case — the SDK-side half of the
-    same capability, carried for exactly the reasons above and with the same `""`
-    sentinel. Slice Lambdas call Amazon Location directly with this; only the
-    browser needs the Function URL. */
 let geocoderPlaceIndexRef: ref<Pulumi.Output.t<string>> = ref(Pulumi.Output.make(""))
 
 module MakeWithConfig = (
@@ -248,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: [],
   })
@@ -1152,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
@@ -2066,35 +2069,32 @@ 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 beside the Function URL because the two
-      // callers need different things from the same capability. A browser cannot
-      // sign an SDK call and gets the URL; a slice's Lambda can, and gets the
-      // index name — no proxy hop, and no dependence on a public unauthenticated
-      // endpoint for an unattended path. `""` when unset, for the same
-      // one-shape-to-handle reason as the endpoint above.
+      // 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("")
@@ -2116,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)),
@@ -2151,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,
           )

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,10 +130,6 @@ function getObjectStoreEndpoints() {
   return objectStoreEndpointsRef.contents;
 }
 
-let geocoderEndpointRef = {
-  contents: Pulumi.output("")
-};
-
 let geocoderPlaceIndexRef = {
   contents: Pulumi.output("")
 };
@@ -193,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: []
   });
@@ -1131,10 +1127,9 @@ 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);
@@ -1146,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 = [
@@ -1196,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,
@@ -1452,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: []
   });
@@ -2367,10 +2356,9 @@ 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);
@@ -2382,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 = [
@@ -2432,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,
@@ -2645,7 +2627,6 @@ 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]}
+}