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

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: "[]"}
-  }
-}

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

@@ -1,137 +0,0 @@
-// Generated by ReScript, PLEASE EDIT WITH CARE
-
-import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
-import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
-import * as Location$AwsSdk from "@reventlessdev/rescript-aws-sdk/src/Location.res.mjs";
-import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
-import * as ClientLocation from "@aws-sdk/client-location";
-
-function getEnv(k) {
-  let v = process.env[k];
-  if (v !== undefined && v !== "") {
-    return v;
-  }
-}
-
-function jsonHeaders() {
-  return Object.fromEntries([[
-      "content-type",
-      "application/json"
-    ]]);
-}
-
-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 handler(event) {
-  try {
-    let indexName = Stdlib_Option.getOr(getEnv("PLACE_INDEX_NAME"), "");
-    let q = Stdlib_Option.getOr(readQueryParam(event), "");
-    if (indexName === "") {
-      console.error("Geocoder: PLACE_INDEX_NAME is unset");
-      return {
-        statusCode: 502,
-        headers: Object.fromEntries([[
-            "content-type",
-            "application/json"
-          ]]),
-        body: "[]"
-      };
-    }
-    if (q === "") {
-      return {
-        statusCode: 200,
-        headers: Object.fromEntries([[
-            "content-type",
-            "application/json"
-          ]]),
-        body: "[]"
-      };
-    }
-    let resp = await Location$AwsSdk.SearchPlaceIndexForTextCommand.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];
-      let rel = r.Relevance;
-      return Object.fromEntries([
-        [
-          "label",
-          label
-        ],
-        [
-          "lat",
-          lat
-        ],
-        [
-          "lng",
-          lng
-        ]
-      ].concat(rel !== undefined ? [[
-            "relevance",
-            rel
-          ]] : []));
-    });
-    return {
-      statusCode: 200,
-      headers: Object.fromEntries([[
-          "content-type",
-          "application/json"
-        ]]),
-      body: JSON.stringify(results)
-    };
-  } catch (raw_exn) {
-    let exn = Primitive_exceptions.internalToException(raw_exn);
-    console.error("Geocoder: search failed", exn);
-    return {
-      statusCode: 502,
-      headers: Object.fromEntries([[
-          "content-type",
-          "application/json"
-        ]]),
-      body: "[]"
-    };
-  }
-}
-
-let Search;
-
-export {
-  Search,
-  getEnv,
-  jsonHeaders,
-  readQueryParam,
-  handler,
-}
-/* Location-AwsSdk Not a pure module */

package/tests/Geocoder_AwsLocation_OpsTest.res

@@ -1,78 +0,0 @@
-// Guards the geocoder Function URL's *status* contract, which is the whole
-// reason one endpoint can serve two callers that want opposite things from it.
-//
-// A browser search box reads the body and must degrade quietly: never an error,
-// just no results. An unattended translator reads the status, because it has to
-// tell "there is no such address" (write a verdict, do not retry) from "the
-// service cannot answer" (retry). The two only ever disagree about which half of
-// the response they read, so:
-//
-//   200 + a possibly-empty array  — an answer
-//   anything else                 — no answer
-//
-// The arms below are the ones reachable without a live AWS Location call. The
-// success path and the thrown-error 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_Ops.handler status contract", () => {
-  test("an unset PLACE_INDEX_NAME is a service failure, not a verdict", async () => {
-    clearIndex()
-    let resp = await Geocoder_AwsLocation_Ops.handler({
-      queryStringParameters: Dict.fromArray([("q", "10 Downing Street")]),
-    })
-    // The arm that matters most: `200 []` here would tell a translator this
-    // address does not exist, and it would record that permanently — for every
-    // address handed to it while the deployment stayed misconfigured.
-    expect(resp.statusCode)->toBe(502)
-    expect(resp.body)->toBe("[]")
-  })
-
-  test("an empty query is an answer — nothing was asked", async () => {
-    setIndex("some-index")
-    let resp = await Geocoder_AwsLocation_Ops.handler({
-      queryStringParameters: Dict.fromArray([("q", "")]),
-    })
-    // 200, unlike the case above: "no results for nothing" is true and final,
-    // and a search box sends exactly this on every cleared input.
-    expect(resp.statusCode)->toBe(200)
-    expect(resp.body)->toBe("[]")
-    clearIndex()
-  })
-
-  test("a missing q param is treated as an empty one", async () => {
-    setIndex("some-index")
-    let resp = await Geocoder_AwsLocation_Ops.handler({})
-    expect(resp.statusCode)->toBe(200)
-    clearIndex()
-  })
-})
-
-describe("Geocoder_AwsLocation_Ops.readQueryParam", () => {
-  testSync("prefers the parsed params", () => {
-    expect(
-      Geocoder_AwsLocation_Ops.readQueryParam({
-        queryStringParameters: Dict.fromArray([("q", "Berlin")]),
-      }),
-    )->toEqual(Some("Berlin"))
-  })
-
-  testSync("falls back to the raw query string, percent-decoded", () => {
-    // Payload format 2.0 populates both fields, but a caller that builds its own
-    // URL is the reason the fallback exists — and the encoding is where a plain
-    // `split("=")` would hand back `10%20Downing%20Street`.
-    expect(
-      Geocoder_AwsLocation_Ops.readQueryParam({
-        rawQueryString: "lang=en&q=10%20Downing%20Street",
-      }),
-    )->toEqual(Some("10 Downing Street"))
-  })
-
-  testSync("no q anywhere is None", () => {
-    expect(Geocoder_AwsLocation_Ops.readQueryParam({rawQueryString: "lang=en"}))->toEqual(None)
-  })
-})