@reventlessdev/reventless-aws 3.0.0-alpha.229 → 3.0.0-alpha.231

package/CHANGELOG.md

@@ -3,6 +3,21 @@
 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.231 (2026-07-27)
+
+### Bug Fixes
+
+* **aws:** route InboundTranslationSlice mutations in the deployed DCB Lambda ([feb129c](https://github.com/ReventlessDev/reventless-core/commit/feb129caf291395e7d35bb953030a1e3efa06e1a))
+
+
+# 3.0.0-alpha.230 (2026-07-27)
+
+### Bug Fixes
+
+* **aws:** convert AWS Location geocoder to a compiled EntryPoint Lambda ([6bf9b7c](https://github.com/ReventlessDev/reventless-core/commit/6bf9b7c6b230857d8dda730fa08c3d0090081c96))
+* **aws:** convert upload presign to a compiled EntryPoint Lambda ([39134f2](https://github.com/ReventlessDev/reventless-core/commit/39134f2f8e8236f043aae6ef410fa719624e625e))
+
+
 # 3.0.0-alpha.229 (2026-07-26)
 
 **Note:** Version bump only for package @reventlessdev/reventless-aws

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reventlessdev/reventless-aws",
-  "version": "3.0.0-alpha.229",
+  "version": "3.0.0-alpha.231",
   "description": "AWS adapters for Reventless",
   "license": "Apache-2.0",
   "dependencies": {
@@ -13,15 +13,15 @@
     "uuid": "^13.0.0",
     "@reventlessdev/rescript-aws-sdk": "2.2.0-alpha.24",
     "@reventlessdev/rescript-effect": "0.1.0-alpha.31",
+    "@reventlessdev/rescript-jest": "1.0.0-alpha.9",
     "@reventlessdev/rescript-pulumi-aws": "2.4.0-alpha.60",
     "@reventlessdev/rescript-pulumi-pulumi": "2.3.0-alpha.17",
-    "@reventlessdev/rescript-jest": "1.0.0-alpha.9",
     "@reventlessdev/rescript-uuid": "1.1.0-alpha.17",
-    "@reventlessdev/reventless-core": "3.0.0-alpha.182",
-    "@reventlessdev/reventless-interop": "3.0.0-alpha.29",
     "@reventlessdev/reventless-infra": "3.0.0-alpha.105",
+    "@reventlessdev/reventless-interop": "3.0.0-alpha.29",
+    "@reventlessdev/reventless-spec": "3.0.0-alpha.81",
     "@reventlessdev/reventless-postgres": "3.0.0-alpha.46",
-    "@reventlessdev/reventless-spec": "3.0.0-alpha.81"
+    "@reventlessdev/reventless-core": "3.0.0-alpha.182"
   },
   "devDependencies": {
     "rescript": "12.3.0",

package/src/adapter/Geocoder/Geocoder_AwsLocation.res

@@ -1,138 +1,23 @@
 // AWS Location Service geocoder behind a public Lambda Function URL.
 //
-// Deploy-time: `make` provisions a CallbackFunction (its handler closure is
-// serialized by Pulumi), an IAM execution role scoped to
+// Deploy-time only: `make` provisions a compiled-EntryPoint Lambda (a plain
+// `Lambda.Function` whose code archive re-exports `handler` from the compiled,
+// type-checked runtime module `Geocoder_AwsLocation_Ops` and ships the shared
+// ESM resolve-hook loader), an IAM execution role scoped to CloudWatch Logs +
 // `geo:SearchPlaceIndexForText` on the target place index, and a Function URL
 // (no auth) so a browser can geocode directly.
 //
-// Runtime: `handleGeocode` reads a `q` query-string param from the Function URL
-// event, calls SearchPlaceIndexForText against the place index named in
-// `PLACE_INDEX_NAME`, and returns `[{label, lat, lng}]` as JSON. Any failure
-// degrades to an empty array so the caller never sees a hard error.
+// Why an EntryPoint and not a Pulumi `CallbackFunction`: 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 can disagree at cold start (the exact
+// skew that crashed the upload presign service). 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_Ops.res].
 
 open PulumiAws
 
-// ── AWS Location SDK bindings (AWS SDK v3, client.send(new Command(...))) ────
-
-type locationClient
-
-type searchPlaceIndexForTextInput = {
-  @as("IndexName") indexName: string,
-  @as("Text") text: string,
-  @as("MaxResults") maxResults?: int,
-}
-// GeoJSON order: [lng, lat].
-type point = array<float>
-type geometry = {@as("Point") point?: point}
-type place = {@as("Label") label?: string, @as("Geometry") geometry?: geometry}
-type searchResult = {@as("Place") place?: place}
-type searchResponse = {@as("Results") results?: array<searchResult>}
-type searchCommand
-
-@module("@aws-sdk/client-location") @new
-external makeLocationClient: unit => locationClient = "LocationClient"
-
-@module("@aws-sdk/client-location") @new
-external makeSearchPlaceIndexForTextCommand: searchPlaceIndexForTextInput => searchCommand =
-  "SearchPlaceIndexForTextCommand"
-
-@send external send: (locationClient, searchCommand) => promise<searchResponse> = "send"
-
-@val external decodeURIComponent: string => string = "decodeURIComponent"
-
-// ── Function URL event / response shapes (payload format 2.0) ────────────────
-
-type functionUrlEvent = {
-  rawQueryString?: string,
-  queryStringParameters?: dict<string>,
-}
-
-type response = {
-  statusCode: int,
-  headers?: dict<string>,
-  body: string,
-}
-
-// Read an env var at runtime, mapping "" / unset to None.
-let getEnv: string => option<string> = %raw(`
-  function(k) { var v = process.env[k]; return (v === undefined || v === null || v === "") ? undefined : v; }
-`)
-
-// Permissive CORS so the browser demo can call the endpoint from any origin.
-let corsHeaders = () =>
-  Dict.fromArray([
-    ("content-type", "application/json"),
-    ("access-control-allow-origin", "*"),
-    ("access-control-allow-methods", "GET,OPTIONS"),
-    ("access-control-allow-headers", "*"),
-  ])
-
-// Pull `q` from the parsed query-string params, falling back to the raw string.
-let readQueryParam = (event: functionUrlEvent): option<string> =>
-  switch event.queryStringParameters->Option.flatMap(p => p->Dict.get("q")) {
-  | Some(q) => Some(q)
-  | None =>
-    event.rawQueryString->Option.flatMap(raw =>
-      raw
-      ->String.split("&")
-      ->Array.findMap(pair =>
-        switch pair->String.split("=") {
-        | [k, v] if k == "q" => Some(v->decodeURIComponent)
-        | _ => None
-        }
-      )
-    )
-  }
-
-// ── Runtime handler ─────────────────────────────────────────────────────────
-
-let handleGeocode = async (event: functionUrlEvent, _context: Lambda.context): response => {
-  try {
-    let indexName = getEnv("PLACE_INDEX_NAME")->Option.getOr("")
-    let q = readQueryParam(event)->Option.getOr("")
-    if indexName == "" || q == "" {
-      {statusCode: 200, headers: corsHeaders(), body: "[]"}
-    } else {
-      let client = makeLocationClient()
-      let resp = await client->send(
-        makeSearchPlaceIndexForTextCommand({indexName, text: q, maxResults: 5}),
-      )
-      let results =
-        resp.results
-        ->Option.getOr([])
-        ->Array.filterMap(r =>
-          switch r.place {
-          | Some(place) =>
-            let label = place.label->Option.getOr("")
-            switch place.geometry->Option.flatMap(g => g.point) {
-            | Some(pt) if pt->Array.length >= 2 =>
-              let lng = pt->Array.getUnsafe(0)
-              let lat = pt->Array.getUnsafe(1)
-              Some(
-                Dict.fromArray([
-                  ("label", JSON.Encode.string(label)),
-                  ("lat", JSON.Encode.float(lat)),
-                  ("lng", JSON.Encode.float(lng)),
-                ])->JSON.Encode.object,
-              )
-            | _ => None
-            }
-          | None => None
-          }
-        )
-      {
-        statusCode: 200,
-        headers: corsHeaders(),
-        body: results->JSON.Encode.array->JSON.stringify,
-      }
-    }
-  } catch {
-  | _ => {statusCode: 200, headers: corsHeaders(), body: "[]"}
-  }
-}
-
-// ── Deploy-time factory ─────────────────────────────────────────────────────
-
 type serviceOutputs = {
   url: Pulumi.Output.t<string>,
   resources: array<Pulumi.Output.t<string>>,
@@ -159,7 +44,8 @@ let make = (
     ~opts?,
   )
 
-  // Least-privilege: SearchPlaceIndexForText on the one place index.
+  // CloudWatch Logs (so failures are observable) plus least-privilege
+  // `geo:SearchPlaceIndexForText` on the one place index.
   let _policy =
     placeIndexName
     ->Pulumi.Output.fromInput
@@ -171,6 +57,12 @@ let make = (
           policy: PolicyDocument.make(
             ~id=`${serviceName}Policy`,
             ~statements=[
+              {
+                sid: "AllowLambdaLogging",
+                effect: Allow,
+                actions: Actions(["logs:CreateLogGroup", "logs:CreateLogStream", "logs:PutLogEvents"]),
+                resources: Resource("arn:aws:logs:*:*:*"),
+              },
               {
                 sid: "AllowGeocode",
                 effect: Allow,
@@ -187,26 +79,53 @@ let make = (
       )
     })
 
-  let environment: Lambda.CallbackFunction.Args.functionEnvironment = {
-    // CallbackFunction under-types env values as `dict<string>`; Pulumi resolves
-    // Output-valued variables at deploy time, so bridge the Input here.
-    variables: Dict.fromArray([("PLACE_INDEX_NAME", placeIndexName)])->Obj.magic,
-  }
+  // 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_Ops.res.mjs",
+    ~packageDirs,
+  )
 
-  let lambda = Lambda.CallbackFunction.make(
+  let layers =
+    Lambda.reventlessLayerArn
+    ->Option.map(arn => [arn->Pulumi.Input.make])
+    ->Option.getOr([])
+    ->Pulumi.Input.make
+
+  let lambda = Lambda.Function.make(
     ~name=serviceName,
-    ~args=Lambda.CallbackFunction.Args.make(
-      ~callback=handleGeocode,
-      ~role=lambdaRole,
-      ~environment,
-      ~timeout=30->Pulumi.Input.make,
-      ~tags=AWS.Tags.make(
+    ~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=serviceName,
         ~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),
+          ]),
+        }: Lambda.Function.functionEnvironment
+      )->Pulumi.Input.make,
+    },
     ~opts?,
   )
 

package/src/adapter/Geocoder/Geocoder_AwsLocation.res.mjs

@@ -1,7 +1,6 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
 import * as Aws from "@pulumi/aws";
-import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
 import * as IAM$PulumiAws from "@reventlessdev/rescript-pulumi-aws/src/IAM/IAM.res.mjs";
 import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
 import * as Pulumi from "@pulumi/pulumi";
@@ -9,113 +8,10 @@ import * as Lambda$PulumiAws from "@reventlessdev/rescript-pulumi-aws/src/Lambda
 import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
 import * as AWS$ReventlessAws from "../AWS.res.mjs";
 import * as AWS_Tags$ReventlessAws from "../AWS_Tags.res.mjs";
-import * as ClientLocation from "@aws-sdk/client-location";
 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";
 
-let getEnv = (function(k) { var v = process.env[k]; return (v === undefined || v === null || v === "") ? undefined : v; });
-
-function corsHeaders() {
-  return Object.fromEntries([
-    [
-      "content-type",
-      "application/json"
-    ],
-    [
-      "access-control-allow-origin",
-      "*"
-    ],
-    [
-      "access-control-allow-methods",
-      "GET,OPTIONS"
-    ],
-    [
-      "access-control-allow-headers",
-      "*"
-    ]
-  ]);
-}
-
-function readQueryParam(event) {
-  let q = Stdlib_Option.flatMap(event.queryStringParameters, p => p["q"]);
-  if (q !== undefined) {
-    return q;
-  } else {
-    return Stdlib_Option.flatMap(event.rawQueryString, raw => Stdlib_Array.findMap(raw.split("&"), pair => {
-      let match = pair.split("=");
-      if (match.length !== 2) {
-        return;
-      }
-      let k = match[0];
-      let v = match[1];
-      if (k === "q") {
-        return decodeURIComponent(v);
-      }
-    }));
-  }
-}
-
-async function handleGeocode(event, _context) {
-  try {
-    let indexName = Stdlib_Option.getOr(getEnv("PLACE_INDEX_NAME"), "");
-    let q = Stdlib_Option.getOr(readQueryParam(event), "");
-    if (indexName === "" || q === "") {
-      return {
-        statusCode: 200,
-        headers: corsHeaders(),
-        body: "[]"
-      };
-    }
-    let client = new ClientLocation.LocationClient();
-    let resp = await client.send(new ClientLocation.SearchPlaceIndexForTextCommand({
-      IndexName: indexName,
-      Text: q,
-      MaxResults: 5
-    }));
-    let results = Stdlib_Array.filterMap(Stdlib_Option.getOr(resp.Results, []), r => {
-      let place = r.Place;
-      if (place === undefined) {
-        return;
-      }
-      let label = Stdlib_Option.getOr(place.Label, "");
-      let pt = Stdlib_Option.flatMap(place.Geometry, g => g.Point);
-      if (pt === undefined) {
-        return;
-      }
-      if (pt.length < 2) {
-        return;
-      }
-      let lng = pt[0];
-      let lat = pt[1];
-      return Object.fromEntries([
-        [
-          "label",
-          label
-        ],
-        [
-          "lat",
-          lat
-        ],
-        [
-          "lng",
-          lng
-        ]
-      ]);
-    });
-    return {
-      statusCode: 200,
-      headers: corsHeaders(),
-      body: JSON.stringify(results)
-    };
-  } catch (exn) {
-    return {
-      statusCode: 200,
-      headers: corsHeaders(),
-      body: "[]"
-    };
-  }
-}
-
 function make(placeIndexName, corsOriginsOpt, opts) {
   let corsOrigins = corsOriginsOpt !== undefined ? corsOriginsOpt : ["*"];
   let serviceName = "GeocoderService";
@@ -124,22 +20,64 @@ function make(placeIndexName, corsOriginsOpt, opts) {
   placeIndexName.apply(idx => {
     let arn = `arn:aws:geo:*:*:place-index/` + idx;
     new (Aws.iam.RolePolicy)(serviceName + `Policy`, {
-      policy: PolicyDocument$PulumiAws.toJsonString(PolicyDocument$PulumiAws.make(undefined, serviceName + `Policy`, [{
+      policy: PolicyDocument$PulumiAws.toJsonString(PolicyDocument$PulumiAws.make(undefined, serviceName + `Policy`, [
+        {
+          Sid: "AllowLambdaLogging",
+          Effect: "Allow",
+          Action: [
+            "logs:CreateLogGroup",
+            "logs:CreateLogStream",
+            "logs:PutLogEvents"
+          ],
+          Resource: "arn:aws:logs:*:*:*"
+        },
+        {
           Sid: "AllowGeocode",
           Effect: "Allow",
           Action: "geo:SearchPlaceIndexForText",
           Resource: arn
-        }])),
+        }
+      ])),
       role: lambdaRole.id
     }, opts$1 !== undefined ? Primitive_option.valFromOption(opts$1) : undefined);
   });
-  let environment = {
-    variables: Object.fromEntries([[
-        "PLACE_INDEX_NAME",
-        placeIndexName
-      ]])
-  };
-  let lambda = new (Aws.lambda.CallbackFunction)(serviceName, Lambda$PulumiAws.CallbackFunction.Args.make(handleGeocode, lambdaRole, undefined, undefined, undefined, undefined, 30, undefined, undefined, undefined, AWS_Tags$ReventlessAws.make(serviceName, "Platform", "Runtime", "Platform", undefined, undefined, undefined, undefined), environment), opts$1 !== undefined ? Primitive_option.valFromOption(opts$1) : undefined);
+  let packageDirs = Object.fromEntries([[
+      "@reventlessdev/reventless-aws",
+      Util_Bundle$ReventlessAws.resolvePackageRoot("@reventlessdev/reventless-aws")
+    ]]);
+  let match = Util_Bundle$ReventlessAws.buildCodeArchive("@reventlessdev/reventless-aws/src/adapter/Geocoder/Geocoder_AwsLocation_Ops.res.mjs", packageDirs, undefined);
+  let layers = Stdlib_Option.getOr(Stdlib_Option.map(Lambda$PulumiAws.reventlessLayerArn, arn => [arn]), []);
+  let lambda = new (Aws.lambda.Function)(serviceName, {
+    handler: "index.handler",
+    runtime: "nodejs22.x",
+    code: match.code,
+    role: lambdaRole.arn,
+    memorySize: 256,
+    timeout: 30,
+    layers: layers,
+    tags: AWS_Tags$ReventlessAws.make(serviceName, "Platform", "Runtime", "Platform", undefined, undefined, undefined, undefined),
+    environment: {
+      variables: Object.fromEntries([
+        [
+          "Environment",
+          Pulumi.getStack()
+        ],
+        [
+          "PLACE_INDEX_NAME",
+          placeIndexName
+        ],
+        [
+          "NODE_OPTIONS",
+          Util_Bundle$ReventlessAws.esmLoaderNodeOptions
+        ],
+        [
+          "ESM_FALLBACK_DIRS",
+          Util_Bundle$ReventlessAws.esmFallbackDirs
+        ]
+      ])
+    },
+    sourceCodeHash: match.sourceCodeHash
+  }, opts$1 !== undefined ? Primitive_option.valFromOption(opts$1) : undefined);
   let functionUrl = new (Aws.lambda.FunctionUrl)(serviceName + `Url`, {
     authorizationType: "NONE",
     functionName: lambda.name,
@@ -159,10 +97,6 @@ function make(placeIndexName, corsOriginsOpt, opts) {
 }
 
 export {
-  getEnv,
-  corsHeaders,
-  readQueryParam,
-  handleGeocode,
   make,
 }
 /* @pulumi/aws Not a pure module */

package/src/adapter/Geocoder/Geocoder_AwsLocation_Ops.res

@@ -0,0 +1,137 @@
+// Runtime handler for the AWS Location geocoder — compiled, type-checked, and
+// Pulumi-free so it can be shipped as an EntryPoint module (`Geocoder_AwsLocation`
+// bundles it and re-exports `handler` from the code archive). Keeping it out of
+// the deploy-time module avoids both the serialized-closure SDK skew and a
+// deploy-time Pulumi import leaking into the Lambda's cold-start graph.
+//
+// Reads a `q` query-string param from the Function URL event, calls
+// SearchPlaceIndexForText against `PLACE_INDEX_NAME`, and returns
+// `[{label, lat, lng}]` as JSON. Any failure degrades to an empty array so the
+// caller never sees a hard error.
+
+// ── AWS Location SDK bindings (AWS SDK v3, client.send(new Command(...))) ────
+
+type locationClient
+
+type searchPlaceIndexForTextInput = {
+  @as("IndexName") indexName: string,
+  @as("Text") text: string,
+  @as("MaxResults") maxResults?: int,
+}
+// GeoJSON order: [lng, lat].
+type point = array<float>
+type geometry = {@as("Point") point?: point}
+type place = {@as("Label") label?: string, @as("Geometry") geometry?: geometry}
+type searchResult = {@as("Place") place?: place}
+type searchResponse = {@as("Results") results?: array<searchResult>}
+type searchCommand
+
+@module("@aws-sdk/client-location") @new
+external makeLocationClient: unit => locationClient = "LocationClient"
+
+@module("@aws-sdk/client-location") @new
+external makeSearchPlaceIndexForTextCommand: searchPlaceIndexForTextInput => searchCommand =
+  "SearchPlaceIndexForTextCommand"
+
+@send external send: (locationClient, searchCommand) => promise<searchResponse> = "send"
+
+@val external decodeURIComponent: string => string = "decodeURIComponent"
+
+// ── Node bindings (replacing the former `%raw` env helper with a typed one) ──
+
+@val @scope("process") external processEnv: dict<string> = "env"
+
+// Read an env var, mapping "" / unset to None.
+let getEnv = (k: string): option<string> =>
+  switch processEnv->Dict.get(k) {
+  | Some("") | None => None
+  | Some(v) => Some(v)
+  }
+
+// ── Function URL event / response shapes (payload format 2.0) ────────────────
+
+type functionUrlEvent = {
+  rawQueryString?: string,
+  queryStringParameters?: dict<string>,
+}
+
+type response = {
+  statusCode: int,
+  headers?: dict<string>,
+  body: string,
+}
+
+// Permissive CORS so the browser demo can call the endpoint from any origin.
+let corsHeaders = () =>
+  Dict.fromArray([
+    ("content-type", "application/json"),
+    ("access-control-allow-origin", "*"),
+    ("access-control-allow-methods", "GET,OPTIONS"),
+    ("access-control-allow-headers", "*"),
+  ])
+
+// Pull `q` from the parsed query-string params, falling back to the raw string.
+let readQueryParam = (event: functionUrlEvent): option<string> =>
+  switch event.queryStringParameters->Option.flatMap(p => p->Dict.get("q")) {
+  | Some(q) => Some(q)
+  | None =>
+    event.rawQueryString->Option.flatMap(raw =>
+      raw
+      ->String.split("&")
+      ->Array.findMap(pair =>
+        switch pair->String.split("=") {
+        | [k, v] if k == "q" => Some(v->decodeURIComponent)
+        | _ => None
+        }
+      )
+    )
+  }
+
+// ── Runtime handler ─────────────────────────────────────────────────────────
+
+let handler = async (event: functionUrlEvent): response => {
+  try {
+    let indexName = getEnv("PLACE_INDEX_NAME")->Option.getOr("")
+    let q = readQueryParam(event)->Option.getOr("")
+    if indexName == "" || q == "" {
+      {statusCode: 200, headers: corsHeaders(), body: "[]"}
+    } else {
+      let client = makeLocationClient()
+      let resp = await client->send(
+        makeSearchPlaceIndexForTextCommand({indexName, text: q, maxResults: 5}),
+      )
+      let results =
+        resp.results
+        ->Option.getOr([])
+        ->Array.filterMap(r =>
+          switch r.place {
+          | Some(place) =>
+            let label = place.label->Option.getOr("")
+            switch place.geometry->Option.flatMap(g => g.point) {
+            | Some(pt) if pt->Array.length >= 2 =>
+              let lng = pt->Array.getUnsafe(0)
+              let lat = pt->Array.getUnsafe(1)
+              Some(
+                Dict.fromArray([
+                  ("label", JSON.Encode.string(label)),
+                  ("lat", JSON.Encode.float(lat)),
+                  ("lng", JSON.Encode.float(lng)),
+                ])->JSON.Encode.object,
+              )
+            | _ => None
+            }
+          | None => None
+          }
+        )
+      {
+        statusCode: 200,
+        headers: corsHeaders(),
+        body: results->JSON.Encode.array->JSON.stringify,
+      }
+    }
+  } catch {
+  | exn =>
+    Console.error2("Geocoder: search failed", exn)
+    {statusCode: 200, headers: corsHeaders(), body: "[]"}
+  }
+}