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

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]}
+}

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

@@ -0,0 +1,127 @@
+// 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 Output$Pulumi from "@reventlessdev/rescript-pulumi-pulumi/src/Output.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 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";
+import * as AppSync_Resolver_Native$ReventlessAws from "../Api/AppSync_Resolver_Native.res.mjs";
+
+let invokeCode = `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;
+}
+`;
+
+function make(api, placeIndexName, nameOpt, opts) {
+  let name = nameOpt !== undefined ? nameOpt : "GeocodeService";
+  let opts$1 = Util_Pulumi$ReventlessCore.ComponentResourceOptions.toCustomResourceOptions(opts);
+  let lambdaRole = IAM$PulumiAws.Role.makeWithDefaultPolicy(name + "Lambda", Pulumi.output(AWS$ReventlessAws.Lambda.principal), AWS_Tags$ReventlessAws.make(name + "Lambda", "Platform", "Identity", "Platform", undefined, undefined, undefined, undefined), opts$1);
+  placeIndexName.apply(idx => {
+    let arn = `arn:aws:geo:*:*:place-index/` + idx;
+    new (Aws.iam.RolePolicy)(name + "LambdaPolicy", {
+      policy: PolicyDocument$PulumiAws.toJsonString(PolicyDocument$PulumiAws.make(undefined, name + "LambdaPolicy", [
+        {
+          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);
+  });
+  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_Resolver_Ops.res.mjs", packageDirs, undefined);
+  let layers = Stdlib_Option.getOr(Stdlib_Option.map(Lambda$PulumiAws.reventlessLayerArn, arn => [arn]), []);
+  let lambda = new (Aws.lambda.Function)(name + "Lambda", {
+    handler: "index.handler",
+    runtime: "nodejs22.x",
+    code: match.code,
+    role: lambdaRole.arn,
+    memorySize: 256,
+    timeout: 30,
+    layers: layers,
+    tags: AWS_Tags$ReventlessAws.make(name + "Lambda", "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);
+  Util_LambdaLogging$ReventlessAws.makeManagedLogGroup(name + "Lambda", lambda.name, AWS_Tags$ReventlessAws.make(name + "LambdaLogGroup", "Platform", "Logs", "Platform", undefined, undefined, undefined, undefined), opts$1, undefined);
+  let dataSourceRole = IAM$PulumiAws.Role.makeWithDefaultPolicy(name + "DataSource", Pulumi.output(AWS$ReventlessAws.AppSync.principal), AWS_Tags$ReventlessAws.make(name + "DataSource", "Platform", "Identity", "Platform", undefined, undefined, undefined, undefined), opts$1);
+  Pulumi.all([
+    lambda.arn,
+    dataSourceRole.id
+  ]).apply(param => {
+    new (Aws.iam.RolePolicy)(name + "DataSource", {
+      policy: PolicyDocument$PulumiAws.toJsonString(PolicyDocument$PulumiAws.make(undefined, name + "DataSourcePolicy", [{
+          Sid: "AllowDataSourceInvokeLambda",
+          Effect: "Allow",
+          Action: "lambda:InvokeFunction",
+          Resource: param[0]
+        }])),
+      role: param[1]
+    }, opts$1);
+  });
+  let dataSource = new (Aws.appsync.DataSource)(name + "DataSource", {
+    type: "AWS_LAMBDA",
+    apiId: Output$Pulumi.flatMap(api, api => api.id),
+    lambdaConfig: {
+      functionArn: lambda.arn
+    },
+    serviceRoleArn: dataSourceRole.arn
+  }, opts$1);
+  AppSync_Resolver_Native$ReventlessAws.makeUnitJsResolver(name + "Geocode", api, dataSource.name, "Query", "geocode", invokeCode, opts$1);
+  return {
+    resources: [lambda.arn]
+  };
+}
+
+export {
+  invokeCode,
+  make,
+}
+/* @pulumi/aws Not a pure module */

package/src/adapter/Geocoder/Geocoder_AwsLocation_Resolver_Ops.res

@@ -0,0 +1,55 @@
+// Runtime handler for the geocoder's client door — compiled, type-checked, and
+// Pulumi-free so it can be shipped as an EntryPoint module
+// (`Geocoder_AwsLocation_Resolver` bundles it and attaches it as the platform API's
+// `Query.geocode` Lambda data source). 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.
+//
+// Invoked by an AppSync resolver, not a Function URL: the platform API's Cognito
+// authorizer has already authenticated the caller, so there is no token to decode
+// and no anonymous surface. The SDK call, the `[lng, lat]` order and the relevance
+// handling all live in `Geocoder_AwsLocation_Backend`, shared with the unattended
+// slice path so one module owns the AWS Location call.
+//
+// Returns the ranked candidates as `[{label, lat, lng, relevance?}]`. A no-match is
+// an empty array — a browser search box degrades to "no results". A service failure
+// throws, which the resolver's response mapper turns into a GraphQL error rather
+// than an empty answer: the client half of D2's status contract, so a browser can
+// tell "no such address" from "the geocoder is down" the way the Function URL's
+// `200`/`502` split did.
+
+let candidateJson = (c: Reventless.Geocoding.candidate): JSON.t =>
+  Dict.fromArray(
+    Array.concat(
+      [
+        ("label", JSON.Encode.string(c.label)),
+        ("lat", JSON.Encode.float(c.point.lat)),
+        ("lng", JSON.Encode.float(c.point.lng)),
+      ],
+      switch c.relevance {
+      | Some(rel) => [("relevance", JSON.Encode.float(rel))]
+      | None => []
+      },
+    ),
+  )->JSON.Encode.object
+
+// Only `text` is read; `ctx.identity` is forwarded by the resolver but the geocoder
+// does not scope by caller, so the handler ignores it.
+type geocodeArgs = {text?: string}
+type appSyncEvent = {arguments?: geocodeArgs}
+
+let handler = async (event: appSyncEvent): array<JSON.t> => {
+  let indexName = switch NodeProcess.env->Dict.get("PLACE_INDEX_NAME") {
+  | Some("") | None => ""
+  | Some(v) => v
+  }
+  let text = event.arguments->Option.flatMap(a => a.text)->Option.getOr("")
+  switch await Geocoder_AwsLocation_Backend.search(~indexName, ~text) {
+  | Ok(candidates) => candidates->Array.map(candidateJson)
+  // The provider answered and had nothing — a true, final empty answer.
+  | Error(NoMatch) => []
+  // Misconfigured (no index) or the service failed: throw so `ctx.error` is set and
+  // the caller sees an error, never a silent empty list it would read as "no match".
+  | Error(Unavailable(msg)) => JsError.throwWithMessage(`geocoder unavailable: ${msg}`)
+  }
+}

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

@@ -0,0 +1,48 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
+import * as Geocoder_AwsLocation_Backend$ReventlessAws from "./Geocoder_AwsLocation_Backend.res.mjs";
+
+function candidateJson(c) {
+  let rel = c.relevance;
+  return Object.fromEntries([
+    [
+      "label",
+      c.label
+    ],
+    [
+      "lat",
+      c.point.lat
+    ],
+    [
+      "lng",
+      c.point.lng
+    ]
+  ].concat(rel !== undefined ? [[
+        "relevance",
+        rel
+      ]] : []));
+}
+
+async function handler(event) {
+  let v = process.env["PLACE_INDEX_NAME"];
+  let indexName = v !== undefined && v !== "" ? v : "";
+  let text = Stdlib_Option.getOr(Stdlib_Option.flatMap(event.arguments, a => a.text), "");
+  let candidates = await Geocoder_AwsLocation_Backend$ReventlessAws.search(indexName, text, undefined);
+  if (candidates.TAG === "Ok") {
+    return candidates._0.map(candidateJson);
+  }
+  let msg = candidates._0;
+  if (typeof msg !== "object") {
+    return [];
+  } else {
+    return Stdlib_JsError.throwWithMessage(`geocoder unavailable: ` + msg._0);
+  }
+}
+
+export {
+  candidateJson,
+  handler,
+}
+/* Geocoder_AwsLocation_Backend-ReventlessAws Not a pure module */

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 */