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

package/tests/AutomationSliceEntryPoint_OpsTest.res.mjs

@@ -153,6 +153,8 @@ globalThis.describe("AutomationSliceEntryPoint_Ops.makeAutomationJsonEventsHandl
       sliceName: "S"
     }, callback, noopPublish, async () => {
       steps.push("sync");
+    }, async () => {
+      steps.push("restore");
     });
     let envelope = Object.fromEntries([
       [
@@ -177,6 +179,7 @@ globalThis.describe("AutomationSliceEntryPoint_Ops.makeAutomationJsonEventsHandl
     ]);
     globalThis.expect(Stdlib_Option.map(receivedCtx.contents, c => c.sliceName)).toEqual("S");
     globalThis.expect(steps).toEqual([
+      "restore",
       "phase1",
       "sync",
       "phase2",
@@ -185,6 +188,64 @@ globalThis.describe("AutomationSliceEntryPoint_Ops.makeAutomationJsonEventsHandl
   });
 });
 
+globalThis.describe("AutomationSliceEntryPoint_Ops.runSweeps", () => {
+  let dummyRegistered_handler = (_event, _context) => Effect.succeed();
+  let dummyRegistered = {
+    handler: dummyRegistered_handler
+  };
+  globalThis.test("sweeps every slice", async () => {
+    let swept = [];
+    await AutomationSliceEntryPoint_Ops$ReventlessAws.runSweeps([
+      {
+        registered: dummyRegistered,
+        sweep: async () => {
+          swept.push("a");
+        },
+        comp: "A"
+      },
+      {
+        registered: dummyRegistered,
+        sweep: async () => {
+          swept.push("b");
+        },
+        comp: "B"
+      }
+    ]);
+    globalThis.expect(swept).toEqual([
+      "a",
+      "b"
+    ]);
+  });
+  globalThis.test("a throwing slice does not stop the others", async () => {
+    let swept = [];
+    await AutomationSliceEntryPoint_Ops$ReventlessAws.runSweeps([
+      {
+        registered: dummyRegistered,
+        sweep: async () => {
+          swept.push("a");
+        },
+        comp: "A"
+      },
+      {
+        registered: dummyRegistered,
+        sweep: async () => Stdlib_JsError.throwWithMessage("gateway down"),
+        comp: "Boom"
+      },
+      {
+        registered: dummyRegistered,
+        sweep: async () => {
+          swept.push("c");
+        },
+        comp: "C"
+      }
+    ]);
+    globalThis.expect(swept).toEqual([
+      "a",
+      "c"
+    ]);
+  });
+});
+
 let outboundEventSchema = S.union([
   S.schema(s => ({
     TAG: "OrderPlaced",
@@ -204,7 +265,7 @@ globalThis.describe("AutomationSliceEntryPoint_Ops.makeOutboundJsonEventsHandler
       received.contents = events;
       steps.push("phase1");
     };
-    let callback_phase2 = async _publish => {
+    let callback_phase2 = async (_publish, param) => {
       steps.push("phase2");
     };
     let callback = {
@@ -214,6 +275,8 @@ globalThis.describe("AutomationSliceEntryPoint_Ops.makeOutboundJsonEventsHandler
     };
     let handler = AutomationSliceEntryPoint_Ops$ReventlessAws.makeOutboundJsonEventsHandler(outboundEventSchema, callback, noopPublish, async () => {
       steps.push("sync");
+    }, async () => {
+      steps.push("restore");
     });
     let placed = Object.fromEntries([
       [
@@ -273,6 +336,7 @@ globalThis.describe("AutomationSliceEntryPoint_Ops.makeOutboundJsonEventsHandler
       ]
     ]);
     globalThis.expect(steps).toEqual([
+      "restore",
       "phase1",
       "sync",
       "phase2",

package/tests/Geocoder_AwsLocation_Resolver_OpsTest.res

@@ -0,0 +1,53 @@
+// Guards the geocode resolver handler's contract — the client door of the
+// geocoding capability (D9 half 2), which replaced the Function URL. The Function
+// URL served two callers through one `200`/`502` body-vs-status split; this handler
+// serves only the browser, through GraphQL, so the contract is simpler:
+//
+//   a value returned  — an answer (a possibly-empty candidate list)
+//   a thrown error    — no answer (the resolver's response mapper turns it into a
+//                       GraphQL error, so the client degrades rather than reading
+//                       an empty list as "no such address")
+//
+// The two arms below are the ones reachable without a live AWS Location call: an
+// unset index throws (misconfiguration is not a verdict on the address), and an
+// empty query returns `[]` (nothing was asked). The success path and the thrown
+// service-failure path both need the SDK and stay unasserted here — see the plan's
+// Verification note.
+
+open JestGlobals
+
+let setIndex = v => NodeProcess.env->Dict.set("PLACE_INDEX_NAME", v)
+let clearIndex = () => NodeProcess.env->Dict.delete("PLACE_INDEX_NAME")
+
+describe("Geocoder_AwsLocation_Resolver_Ops.handler contract", () => {
+  test("an unset PLACE_INDEX_NAME throws — a misconfiguration, not a verdict", async () => {
+    clearIndex()
+    let threw = switch await Geocoder_AwsLocation_Resolver_Ops.handler({
+      arguments: {text: "10 Downing Street"},
+    }) {
+    | _ => false
+    | exception _ => true
+    }
+    // Returning `[]` here would tell the browser this address does not exist, when
+    // in fact the deployment has no geocoder — the client must see an error and be
+    // able to distinguish the two, which is the whole point of throwing.
+    expect(threw)->toBe(true)
+    clearIndex()
+  })
+
+  test("an empty query is an answer — nothing was asked, so `[]`", async () => {
+    setIndex("some-index")
+    let results = await Geocoder_AwsLocation_Resolver_Ops.handler({arguments: {text: ""}})
+    // The empty text short-circuits in the shared backend before any SDK call, so
+    // this arm is reachable in a unit test and returns a true, final empty answer.
+    expect(results->Array.length)->toBe(0)
+    clearIndex()
+  })
+
+  test("a missing text argument is treated as an empty query", async () => {
+    setIndex("some-index")
+    let results = await Geocoder_AwsLocation_Resolver_Ops.handler({arguments: {}})
+    expect(results->Array.length)->toBe(0)
+    clearIndex()
+  })
+})

package/tests/Geocoder_AwsLocation_Resolver_OpsTest.res.mjs

@@ -0,0 +1,55 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stdlib_Dict from "@rescript/runtime/lib/es6/Stdlib_Dict.js";
+import * as Geocoder_AwsLocation_Resolver_Ops$ReventlessAws from "../src/adapter/Geocoder/Geocoder_AwsLocation_Resolver_Ops.res.mjs";
+
+function setIndex(v) {
+  process.env["PLACE_INDEX_NAME"] = v;
+}
+
+function clearIndex() {
+  Stdlib_Dict.$$delete(process.env, "PLACE_INDEX_NAME");
+}
+
+globalThis.describe("Geocoder_AwsLocation_Resolver_Ops.handler contract", () => {
+  globalThis.test("an unset PLACE_INDEX_NAME throws — a misconfiguration, not a verdict", async () => {
+    Stdlib_Dict.$$delete(process.env, "PLACE_INDEX_NAME");
+    let threw;
+    try {
+      await Geocoder_AwsLocation_Resolver_Ops$ReventlessAws.handler({
+        arguments: {
+          text: "10 Downing Street"
+        }
+      });
+      threw = false;
+    } catch (exn) {
+      threw = true;
+    }
+    globalThis.expect(threw).toBe(true);
+    return Stdlib_Dict.$$delete(process.env, "PLACE_INDEX_NAME");
+  });
+  globalThis.test("an empty query is an answer — nothing was asked, so `[]`", async () => {
+    setIndex("some-index");
+    let results = await Geocoder_AwsLocation_Resolver_Ops$ReventlessAws.handler({
+      arguments: {
+        text: ""
+      }
+    });
+    globalThis.expect(results.length).toBe(0);
+    return Stdlib_Dict.$$delete(process.env, "PLACE_INDEX_NAME");
+  });
+  globalThis.test("a missing text argument is treated as an empty query", async () => {
+    setIndex("some-index");
+    let results = await Geocoder_AwsLocation_Resolver_Ops$ReventlessAws.handler({
+      arguments: {}
+    });
+    globalThis.expect(results.length).toBe(0);
+    return Stdlib_Dict.$$delete(process.env, "PLACE_INDEX_NAME");
+  });
+});
+
+export {
+  setIndex,
+  clearIndex,
+}
+/*  Not a pure module */

package/src/adapter/Geocoder/Geocoder_AwsLocation.res

@@ -1,166 +0,0 @@
-// AWS Location Service geocoder behind a public Lambda Function URL.
-//
-// 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.
-//
-// 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
-
-type serviceOutputs = {
-  url: Pulumi.Output.t<string>,
-  resources: array<Pulumi.Output.t<string>>,
-}
-
-let make = (
-  ~placeIndexName: Pulumi.Input.t<string>,
-  ~corsOrigins: array<string>=["*"],
-  ~opts=?,
-): serviceOutputs => {
-  let serviceName = "GeocoderService"
-  let opts =
-    opts->Option.map(ReventlessCore.Util.Pulumi.ComponentResourceOptions.toCustomResourceOptions)
-
-  let lambdaRole = IAM.Role.makeWithDefaultPolicy(
-    ~name=serviceName,
-    ~servicePrincipal=AWS.Lambda.principal->Pulumi.Output.make,
-    ~tags=AWS.Tags.make(
-      ~name=serviceName,
-      ~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.
-  let _policy =
-    placeIndexName
-    ->Pulumi.Output.fromInput
-    ->Pulumi.Output.apply(idx => {
-      let arn = `arn:aws:geo:*:*:place-index/${idx}`
-      let _ = IAM.RolePolicy.make(
-        ~name=`${serviceName}Policy`,
-        ~args={
-          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,
-                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_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=serviceName,
-    ~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),
-            Util_LambdaLogging.logLevelEntry(),
-          ]),
-        }: Lambda.Function.functionEnvironment
-      )->Pulumi.Input.make,
-    },
-    ~opts?,
-  )
-
-  Util_LambdaLogging.makeManagedLogGroup(
-    ~name=serviceName,
-    ~lambdaName=lambda.name,
-    ~tags=AWS.Tags.make(
-      ~name=serviceName ++ "LogGroup",
-      ~kind=ReventlessCore.ComponentType.Platform,
-      ~role=Logs,
-      ~scope=Platform,
-    ),
-    ~opts?,
-    (),
-  )
-
-  let functionUrl = FunctionUrl.make(
-    ~name=`${serviceName}Url`,
-    ~args={
-      authorizationType: FunctionUrl.None,
-      functionName: lambda.name->Pulumi.Output.asInput,
-      cors: (
-        {
-          allowMethods: ["GET"]->Array.map(Pulumi.Input.make)->Pulumi.Input.make,
-          allowOrigins: corsOrigins->Array.map(Pulumi.Input.make)->Pulumi.Input.make,
-          allowHeaders: ["*"]->Array.map(Pulumi.Input.make)->Pulumi.Input.make,
-        }: FunctionUrl.cors
-      )->Pulumi.Input.make,
-    },
-    ~opts?,
-  )
-
-  {
-    url: functionUrl.functionUrl,
-    resources: [lambda.arn, functionUrl.functionArn],
-  }
-}

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

@@ -1,105 +0,0 @@
-// Generated by ReScript, PLEASE EDIT WITH CARE
-
-import * as Aws from "@pulumi/aws";
-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";
-import * as Lambda$PulumiAws from "@reventlessdev/rescript-pulumi-aws/src/Lambda/Lambda.res.mjs";
-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 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 Util_LambdaLogging$ReventlessAws from "../../util/Util_LambdaLogging.res.mjs";
-
-function make(placeIndexName, corsOriginsOpt, opts) {
-  let corsOrigins = corsOriginsOpt !== undefined ? corsOriginsOpt : ["*"];
-  let serviceName = "GeocoderService";
-  let opts$1 = Stdlib_Option.map(opts, Util_Pulumi$ReventlessCore.ComponentResourceOptions.toCustomResourceOptions);
-  let lambdaRole = IAM$PulumiAws.Role.makeWithDefaultPolicy(serviceName, Pulumi.output(AWS$ReventlessAws.Lambda.principal), AWS_Tags$ReventlessAws.make(serviceName, "Platform", "Identity", "Platform", undefined, undefined, undefined, undefined), opts$1);
-  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`, [
-        {
-          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 packageDirs = Object.fromEntries([[
-      "@reventlessdev/reventless-aws",
-      Util_Bundle$ReventlessAws.resolvePackageRoot(undefined, "@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
-        ],
-        Util_LambdaLogging$ReventlessAws.logLevelEntry()
-      ])
-    },
-    sourceCodeHash: match.sourceCodeHash
-  }, opts$1 !== undefined ? Primitive_option.valFromOption(opts$1) : undefined);
-  Util_LambdaLogging$ReventlessAws.makeManagedLogGroup(serviceName, lambda.name, AWS_Tags$ReventlessAws.make(serviceName + "LogGroup", "Platform", "Logs", "Platform", undefined, undefined, undefined, undefined), opts$1, undefined);
-  let functionUrl = new (Aws.lambda.FunctionUrl)(serviceName + `Url`, {
-    authorizationType: "NONE",
-    functionName: lambda.name,
-    cors: {
-      allowHeaders: ["*"].map(prim => prim),
-      allowMethods: ["GET"].map(prim => prim),
-      allowOrigins: corsOrigins.map(prim => prim)
-    }
-  }, opts$1 !== undefined ? Primitive_option.valFromOption(opts$1) : undefined);
-  return {
-    url: functionUrl.functionUrl,
-    resources: [
-      lambda.arn,
-      functionUrl.functionArn
-    ]
-  };
-}
-
-export {
-  make,
-}
-/* @pulumi/aws Not a pure module */

package/src/adapter/Geocoder/Geocoder_AwsLocation_Ops.res

@@ -1,144 +0,0 @@
-// 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 lives in the bindings package, shared with the backend geocoder
-// adapter — one place owns the `[lng, lat]` order and the optional `Relevance`.
-module Search = AwsSdk.Location.SearchPlaceIndexForTextCommand
-
-@val external decodeURIComponent: string => string = "decodeURIComponent"
-
-// ── Node bindings (replacing the former `%raw` env helper with a typed one) ──
-
-
-// Read an env var, mapping "" / unset to None.
-let getEnv = (k: string): option<string> =>
-  switch NodeProcess.env->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,
-}
-
-// CORS belongs to the Function URL's own `cors` configuration and to nothing
-// else. AWS injects the allow-origin header itself whenever the request carries
-// an `Origin`, so a handler that also sets one sends the header *twice* — and a
-// browser rejects `Access-Control-Allow-Origin: *, *` outright, failing every
-// cross-origin call while leaving `curl` (which sends no `Origin`, so AWS adds
-// nothing) working perfectly.
-//
-// It is also the only way `~corsOrigins` can mean anything: a hardcoded `*`
-// here would keep answering `*` for a deployment that narrowed the allow-list.
-let jsonHeaders = () => Dict.fromArray([("content-type", "application/json")])
-
-// 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 == "" {
-      // A handler with no place index cannot answer anything, so this is the
-      // service being misconfigured — not a verdict on the address. It has to
-      // read as `502` for the same reason the catch below does: a `200 []` here
-      // tells an unattended caller "no such address", and it would then write
-      // that verdict, unretried, for every address it is handed while the
-      // deployment is broken. The browser is unaffected — it reads the body.
-      Console.error("Geocoder: PLACE_INDEX_NAME is unset")
-      {statusCode: 502, headers: jsonHeaders(), body: "[]"}
-    } else if q == "" {
-      // `200`, unlike the arm above: nothing was asked, so "no results" is a
-      // true and final answer rather than a failure to produce one. A search box
-      // sends this on every cleared input.
-      {statusCode: 200, headers: jsonHeaders(), body: "[]"}
-    } else {
-      let resp = await Search.send(Search.make({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(
-                  Array.concat(
-                    [
-                      ("label", JSON.Encode.string(label)),
-                      ("lat", JSON.Encode.float(lat)),
-                      ("lng", JSON.Encode.float(lng)),
-                    ],
-                    // Additive: the browser client reads the three fields above
-                    // and ignores this one. An unattended caller needs it to
-                    // apply `Geocoding.confidentMatch`, which is what keeps a
-                    // vague match from becoming a confident pin.
-                    switch r.relevance {
-                    | Some(rel) => [("relevance", JSON.Encode.float(rel))]
-                    | None => []
-                    },
-                  ),
-                )->JSON.Encode.object,
-              )
-            | _ => None
-            }
-          | None => None
-          }
-        )
-      {
-        statusCode: 200,
-        headers: jsonHeaders(),
-        body: results->JSON.Encode.array->JSON.stringify,
-      }
-    }
-  } catch {
-  | exn =>
-    Console.error2("Geocoder: search failed", exn)
-    // 502, not 200 — and still `[]`, which is the point. A browser search box
-    // reads the body and degrades to "no results" whether or not it checks the
-    // status, so nothing on that side changes. An unattended caller reads the
-    // status and can tell "the service is down" from "there is no such address",
-    // which is the difference between retrying and writing a verdict into an
-    // event log. One contract serves both because they disagree only about which
-    // half of the response they read.
-    {statusCode: 502, headers: jsonHeaders(), body: "[]"}
-  }
-}