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

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

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