@reventlessdev/reventless-aws 3.0.0-alpha.259 → 3.0.0-alpha.261

package/src/util/Util_DcbMetrics.res

@@ -0,0 +1,48 @@
+// The CloudWatch half of DCB metrics: the provider-neutral metric lines that
+// StateChangeSlice_Callback emits (`{reventlessMetric, slice, value}`) become
+// CloudWatch metrics through a log metric filter per metric name. Namespace and
+// dimension are CloudWatch-specific and belong here rather than in core.
+//
+// Pure on purpose. The filters are only built for a Lambda that has a MANAGED log
+// group to attach to, so no stack exercised this code until managed groups existed
+// — and an invalid transformation therefore shipped without any deploy catching it.
+// Keeping the transformation a plain function makes the one rule CloudWatch enforces
+// testable without standing up a Pulumi resource.
+
+open PulumiAws
+
+/** The metrics extracted from a DCB command handler's logs. */
+let metricNames = [
+  "AppendRetry",
+  "AppendConflict",
+  "DcbDecisionModelCacheHit",
+  "DcbDecisionModelCacheMiss",
+  "DcbDecisionModelDeltaEventCount",
+]
+
+let namespace = "Reventless/DCB"
+
+/** Filter pattern selecting one metric's lines out of the log stream. */
+let patternFor = (metricName: string): string => `{ $.reventlessMetric = "${metricName}" }`
+
+/**
+The metric transformation for one DCB metric, dimensioned by slice.
+
+`dimensions` and `defaultValue` are **mutually exclusive** — `PutMetricFilter`
+rejects a transformation carrying both with `InvalidParameterException: Invalid
+metric transformation: dimensions and default value are mutually exclusive
+properties`. The reason is that a default value is emitted when the pattern does not
+match, and for a dimensioned metric there is no dimension value to attribute such a
+point to.
+
+The `slice` dimension is the half worth keeping: without it every slice's counts
+collapse into one undifferentiated series. So this sets no `defaultValue`, and a
+metric simply reports no data point for a period in which nothing matched.
+*/
+let transformationFor = (metricName: string): Cloudwatch.LogMetricFilter.metricTransformation => {
+  name: metricName->Pulumi.Input.make,
+  namespace: namespace->Pulumi.Input.make,
+  value: "$.value"->Pulumi.Input.make,
+  unit: "Count"->Pulumi.Input.make,
+  dimensions: Dict.fromArray([("slice", "$.slice")])->Pulumi.Input.make,
+}

package/src/util/Util_DcbMetrics.res.mjs

@@ -0,0 +1,37 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+
+let metricNames = [
+  "AppendRetry",
+  "AppendConflict",
+  "DcbDecisionModelCacheHit",
+  "DcbDecisionModelCacheMiss",
+  "DcbDecisionModelDeltaEventCount"
+];
+
+let namespace = "Reventless/DCB";
+
+function patternFor(metricName) {
+  return `{ $.reventlessMetric = "` + metricName + `" }`;
+}
+
+function transformationFor(metricName) {
+  return {
+    name: metricName,
+    namespace: namespace,
+    value: "$.value",
+    unit: "Count",
+    dimensions: Object.fromEntries([[
+        "slice",
+        "$.slice"
+      ]])
+  };
+}
+
+export {
+  metricNames,
+  namespace,
+  patternFor,
+  transformationFor,
+}
+/* No side effect */

package/src/util/Util_ShellConfig.res

@@ -0,0 +1,72 @@
+// Assembly of the `config.json` the deploy writes beside the host shell's
+// `index.html`.
+//
+// The keys split in two: the ones the deploy *computes* (endpoints, region,
+// pool ids — resolved Pulumi Outputs by the time they get here) and the ones a
+// deployment *chooses*. This module is the pure join of the two, so the whole
+// key set is reachable from a test instead of living inside deployPlatform's
+// `Pulumi.Output.apply`, where nothing could assert a single key of it.
+
+module Platform = ReventlessInfra.Platform
+
+// A mode's options, flattened to the wire shape. They are payloads of their arm
+// on the deploy side (so `mapStyle` with the map off cannot be expressed) and
+// flat siblings of `viewModes` on the wire (because that is where the released
+// shell reads them). This function is the whole of that translation.
+let modeOptions = (mode: Platform.viewMode): array<(string, JSON.t)> =>
+  switch mode {
+  | Map(opts) =>
+    switch opts.style {
+    | Some(style) => [("mapStyle", JSON.Encode.string(style))]
+    | None => []
+    }
+  | Graph(opts) =>
+    switch opts.layout {
+    | Some(layout) => [("graphLayout", JSON.Encode.string(layout))]
+    | None => []
+    }
+  }
+
+/**
+The config.json field set.
+
+`computed` arrives in wire order and keeps it. `viewModes` unset ⇒ no
+`viewModes` key and no per-mode key, so a deployment that wants no optional mode
+gets byte-identical output to before this input existed. `shellConfig` merges in
+last; a key it shares with one already present fails the deploy naming it,
+because silently resolving the collision either way produces an app pointed
+somewhere unintended with nothing in the diff to say so.
+*/
+let fields = (
+  ~computed: array<(string, JSON.t)>,
+  ~viewModes: option<array<Platform.viewMode>>=?,
+  ~shellConfig: option<dict<JSON.t>>=?,
+): dict<JSON.t> => {
+  let out = computed->Dict.fromArray
+
+  switch viewModes {
+  | Some(modes) =>
+    out->Dict.set(
+      "viewModes",
+      modes->Array.map(m => m->Platform.viewModeToString->JSON.Encode.string)->JSON.Encode.array,
+    )
+    modes->Array.forEach(m => m->modeOptions->Array.forEach(((k, v)) => out->Dict.set(k, v)))
+  | None => ()
+  }
+
+  switch shellConfig {
+  | Some(extra) =>
+    let collisions = extra->Dict.keysToArray->Array.filter(k => out->Dict.get(k)->Option.isSome)
+    if collisions->Array.length > 0 {
+      failwith(
+        "host UI config.json: shellConfig sets key(s) the deploy already computes — " ++
+        collisions->Array.join(", ") ++
+        ". Remove them from shellConfig; a passthrough cannot redirect a computed key.",
+      )
+    }
+    extra->Dict.forEachWithKey((v, k) => out->Dict.set(k, v))
+  | None => ()
+  }
+
+  out
+}

package/src/util/Util_ShellConfig.res.mjs

@@ -0,0 +1,60 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Pervasives from "@rescript/runtime/lib/es6/Pervasives.js";
+import * as Stdlib_Dict from "@rescript/runtime/lib/es6/Stdlib_Dict.js";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Platform$ReventlessInfra from "@reventlessdev/reventless-infra/src/types/Platform.res.mjs";
+
+function modeOptions(mode) {
+  if (mode.TAG === "Map") {
+    let style = mode._0.style;
+    if (style !== undefined) {
+      return [[
+          "mapStyle",
+          style
+        ]];
+    } else {
+      return [];
+    }
+  }
+  let layout = mode._0.layout;
+  if (layout !== undefined) {
+    return [[
+        "graphLayout",
+        layout
+      ]];
+  } else {
+    return [];
+  }
+}
+
+function fields(computed, viewModes, shellConfig) {
+  let out = Object.fromEntries(computed);
+  if (viewModes !== undefined) {
+    out["viewModes"] = viewModes.map(Platform$ReventlessInfra.viewModeToString);
+    viewModes.forEach(m => {
+      modeOptions(m).forEach(param => {
+        out[param[0]] = param[1];
+      });
+    });
+  }
+  if (shellConfig !== undefined) {
+    let collisions = Object.keys(shellConfig).filter(k => Stdlib_Option.isSome(out[k]));
+    if (collisions.length !== 0) {
+      Pervasives.failwith("host UI config.json: shellConfig sets key(s) the deploy already computes — " + collisions.join(", ") + ". Remove them from shellConfig; a passthrough cannot redirect a computed key.");
+    }
+    Stdlib_Dict.forEachWithKey(shellConfig, (v, k) => {
+      out[k] = v;
+    });
+  }
+  return out;
+}
+
+let Platform;
+
+export {
+  Platform,
+  modeOptions,
+  fields,
+}
+/* No side effect */

package/tests/Geocoder_AwsLocation_OpsTest.res

@@ -0,0 +1,78 @@
+// 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)
+  })
+})

package/tests/Geocoder_AwsLocation_OpsTest.res.mjs

@@ -0,0 +1,71 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stdlib_Dict from "@rescript/runtime/lib/es6/Stdlib_Dict.js";
+import * as Geocoder_AwsLocation_Ops$ReventlessAws from "../src/adapter/Geocoder/Geocoder_AwsLocation_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_Ops.handler status contract", () => {
+  globalThis.test("an unset PLACE_INDEX_NAME is a service failure, not a verdict", async () => {
+    Stdlib_Dict.$$delete(process.env, "PLACE_INDEX_NAME");
+    let resp = await Geocoder_AwsLocation_Ops$ReventlessAws.handler({
+      queryStringParameters: Object.fromEntries([[
+          "q",
+          "10 Downing Street"
+        ]])
+    });
+    globalThis.expect(resp.statusCode).toBe(502);
+    globalThis.expect(resp.body).toBe("[]");
+  });
+  globalThis.test("an empty query is an answer — nothing was asked", async () => {
+    setIndex("some-index");
+    let resp = await Geocoder_AwsLocation_Ops$ReventlessAws.handler({
+      queryStringParameters: Object.fromEntries([[
+          "q",
+          ""
+        ]])
+    });
+    globalThis.expect(resp.statusCode).toBe(200);
+    globalThis.expect(resp.body).toBe("[]");
+    return Stdlib_Dict.$$delete(process.env, "PLACE_INDEX_NAME");
+  });
+  globalThis.test("a missing q param is treated as an empty one", async () => {
+    setIndex("some-index");
+    let resp = await Geocoder_AwsLocation_Ops$ReventlessAws.handler({});
+    globalThis.expect(resp.statusCode).toBe(200);
+    return Stdlib_Dict.$$delete(process.env, "PLACE_INDEX_NAME");
+  });
+});
+
+globalThis.describe("Geocoder_AwsLocation_Ops.readQueryParam", () => {
+  globalThis.test("prefers the parsed params", () => {
+    globalThis.expect(Geocoder_AwsLocation_Ops$ReventlessAws.readQueryParam({
+      queryStringParameters: Object.fromEntries([[
+          "q",
+          "Berlin"
+        ]])
+    })).toEqual("Berlin");
+  });
+  globalThis.test("falls back to the raw query string, percent-decoded", () => {
+    globalThis.expect(Geocoder_AwsLocation_Ops$ReventlessAws.readQueryParam({
+      rawQueryString: "lang=en&q=10%20Downing%20Street"
+    })).toEqual("10 Downing Street");
+  });
+  globalThis.test("no q anywhere is None", () => {
+    globalThis.expect(Geocoder_AwsLocation_Ops$ReventlessAws.readQueryParam({
+      rawQueryString: "lang=en"
+    })).toEqual(undefined);
+  });
+});
+
+export {
+  setIndex,
+  clearIndex,
+}
+/*  Not a pure module */

package/tests/Util_DcbMetricsTest.res

@@ -0,0 +1,35 @@
+open JestGlobals
+
+// The rule that matters is CloudWatch's, not ours: a metric transformation may carry
+// `dimensions` OR `defaultValue`, never both. Violating it is not caught at compile
+// time — both fields are optional in the binding — and not caught at deploy time
+// either unless the stack happens to have a managed log group for the filter to
+// attach to. So it is asserted here.
+
+describe("Util_DcbMetrics.transformationFor", () => {
+  testSync("never sets defaultValue — it is mutually exclusive with dimensions", () =>
+    Util_DcbMetrics.metricNames->Array.forEach(m =>
+      expect(Util_DcbMetrics.transformationFor(m).defaultValue)->toBe(None)
+    )
+  )
+
+  testSync("dimensions the metric by slice", () =>
+    expect(
+      Util_DcbMetrics.transformationFor("AppendRetry").dimensions->Option.isSome,
+    )->toBe(true)
+  )
+
+  testSync("counts into the DCB namespace", () =>
+    expect(Util_DcbMetrics.transformationFor("AppendRetry").namespace)->toBe("Reventless/DCB")
+  )
+
+  testSync("names the metric after the emitted marker", () =>
+    expect(Util_DcbMetrics.transformationFor("AppendConflict").name)->toBe("AppendConflict")
+  )
+})
+
+describe("Util_DcbMetrics.patternFor", () => {
+  testSync("selects one metric's lines by its marker", () =>
+    expect(Util_DcbMetrics.patternFor("AppendRetry"))->toBe(`{ $.reventlessMetric = "AppendRetry" }`)
+  )
+})

package/tests/Util_DcbMetricsTest.res.mjs

@@ -0,0 +1,29 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Util_DcbMetrics$ReventlessAws from "../src/util/Util_DcbMetrics.res.mjs";
+
+globalThis.describe("Util_DcbMetrics.transformationFor", () => {
+  globalThis.test("never sets defaultValue — it is mutually exclusive with dimensions", () => {
+    Util_DcbMetrics$ReventlessAws.metricNames.forEach(m => {
+      globalThis.expect(Util_DcbMetrics$ReventlessAws.transformationFor(m).defaultValue).toBe(undefined);
+    });
+  });
+  globalThis.test("dimensions the metric by slice", () => {
+    globalThis.expect(Stdlib_Option.isSome(Util_DcbMetrics$ReventlessAws.transformationFor("AppendRetry").dimensions)).toBe(true);
+  });
+  globalThis.test("counts into the DCB namespace", () => {
+    globalThis.expect(Util_DcbMetrics$ReventlessAws.transformationFor("AppendRetry").namespace).toBe("Reventless/DCB");
+  });
+  globalThis.test("names the metric after the emitted marker", () => {
+    globalThis.expect(Util_DcbMetrics$ReventlessAws.transformationFor("AppendConflict").name).toBe("AppendConflict");
+  });
+});
+
+globalThis.describe("Util_DcbMetrics.patternFor", () => {
+  globalThis.test("selects one metric's lines by its marker", () => {
+    globalThis.expect(Util_DcbMetrics$ReventlessAws.patternFor("AppendRetry")).toBe(`{ $.reventlessMetric = "AppendRetry" }`);
+  });
+});
+
+/*  Not a pure module */

package/tests/Util_ShellConfigTest.res

@@ -0,0 +1,78 @@
+open JestGlobals
+
+// The host shell reads config.json by key name, and every failure here is a
+// silent one: a missing key deletes a feature with nothing in any log, and a
+// key overwritten by a passthrough points the app at the wrong API. Both are
+// only assertable because `fields` is pure.
+
+let computed = [
+  ("apiEndpoint", JSON.Encode.string("https://domain.example/graphql")),
+  ("region", JSON.Encode.string("eu-west-1")),
+]
+
+let get = (out, key) => out->Dict.get(key)->Option.getOr(JSON.Encode.null)
+
+describe("Util_ShellConfig.fields — viewModes", () => {
+  testSync("unset ⇒ no viewModes key and the computed set is untouched", () => {
+    let out = Util_ShellConfig.fields(~computed)
+    expect(out->Dict.keysToArray)->toEqual(["apiEndpoint", "region"])
+    expect(out->Dict.get("viewModes")->Option.isNone)->toBe(true)
+  })
+
+  testSync("Map with defaults ⇒ the mode, and no mapStyle key", () => {
+    let out = Util_ShellConfig.fields(~computed, ~viewModes=[Map({})])
+    expect(out->get("viewModes"))->toEqual(JSON.Encode.array([JSON.Encode.string("map")]))
+    expect(out->Dict.get("mapStyle")->Option.isNone)->toBe(true)
+  })
+
+  testSync("per-mode options flatten beside the mode", () => {
+    let out = Util_ShellConfig.fields(
+      ~computed,
+      ~viewModes=[Map({style: "https://tiles.example/style.json"}), Graph({layout: "dagre"})],
+    )
+    expect(out->get("viewModes"))->toEqual(
+      JSON.Encode.array([JSON.Encode.string("map"), JSON.Encode.string("graph")]),
+    )
+    expect(out->get("mapStyle"))->toEqual(
+      JSON.Encode.string("https://tiles.example/style.json"),
+    )
+    expect(out->get("graphLayout"))->toEqual(JSON.Encode.string("dagre"))
+  })
+})
+
+describe("Util_ShellConfig.fields — shellConfig passthrough", () => {
+  testSync("shell-owned keys land verbatim, under the computed ones", () => {
+    let out = Util_ShellConfig.fields(
+      ~computed,
+      ~shellConfig=Dict.fromArray([
+        ("platformName", JSON.Encode.string("Online Shop")),
+        ("accessTiers", JSON.Encode.array([JSON.Encode.string("public")])),
+      ]),
+    )
+    expect(out->Dict.keysToArray)->toEqual([
+      "apiEndpoint",
+      "region",
+      "platformName",
+      "accessTiers",
+    ])
+    expect(out->get("platformName"))->toEqual(JSON.Encode.string("Online Shop"))
+  })
+
+  testSync("a key the deploy computes fails the deploy, naming it", () => {
+    let failure = try {
+      let _ = Util_ShellConfig.fields(
+        ~computed,
+        ~shellConfig=Dict.fromArray([
+          ("apiEndpoint", JSON.Encode.string("https://wrong.example/graphql")),
+        ]),
+      )
+      None
+    } catch {
+    | Failure(message) => Some(message)
+    }
+    switch failure {
+    | Some(message) => expect(message->String.includes("apiEndpoint"))->toBe(true)
+    | None => fail("a shellConfig key colliding with a computed one must fail the deploy")
+    }
+  })
+})

package/tests/Util_ShellConfigTest.res.mjs

@@ -0,0 +1,113 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as JestGlobals from "@reventlessdev/rescript-jest/src/JestGlobals.res.mjs";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
+import * as Util_ShellConfig$ReventlessAws from "../src/util/Util_ShellConfig.res.mjs";
+
+let computed = [
+  [
+    "apiEndpoint",
+    "https://domain.example/graphql"
+  ],
+  [
+    "region",
+    "eu-west-1"
+  ]
+];
+
+function get(out, key) {
+  return Stdlib_Option.getOr(out[key], null);
+}
+
+globalThis.describe("Util_ShellConfig.fields — viewModes", () => {
+  globalThis.test("unset ⇒ no viewModes key and the computed set is untouched", () => {
+    let out = Util_ShellConfig$ReventlessAws.fields(computed, undefined, undefined);
+    globalThis.expect(Object.keys(out)).toEqual([
+      "apiEndpoint",
+      "region"
+    ]);
+    globalThis.expect(Stdlib_Option.isNone(out["viewModes"])).toBe(true);
+  });
+  globalThis.test("Map with defaults ⇒ the mode, and no mapStyle key", () => {
+    let out = Util_ShellConfig$ReventlessAws.fields(computed, [{
+        TAG: "Map",
+        _0: {}
+      }], undefined);
+    globalThis.expect(get(out, "viewModes")).toEqual(["map"]);
+    globalThis.expect(Stdlib_Option.isNone(out["mapStyle"])).toBe(true);
+  });
+  globalThis.test("per-mode options flatten beside the mode", () => {
+    let out = Util_ShellConfig$ReventlessAws.fields(computed, [
+      {
+        TAG: "Map",
+        _0: {
+          style: "https://tiles.example/style.json"
+        }
+      },
+      {
+        TAG: "Graph",
+        _0: {
+          layout: "dagre"
+        }
+      }
+    ], undefined);
+    globalThis.expect(get(out, "viewModes")).toEqual([
+      "map",
+      "graph"
+    ]);
+    globalThis.expect(get(out, "mapStyle")).toEqual("https://tiles.example/style.json");
+    globalThis.expect(get(out, "graphLayout")).toEqual("dagre");
+  });
+});
+
+globalThis.describe("Util_ShellConfig.fields — shellConfig passthrough", () => {
+  globalThis.test("shell-owned keys land verbatim, under the computed ones", () => {
+    let out = Util_ShellConfig$ReventlessAws.fields(computed, undefined, Object.fromEntries([
+      [
+        "platformName",
+        "Online Shop"
+      ],
+      [
+        "accessTiers",
+        ["public"]
+      ]
+    ]));
+    globalThis.expect(Object.keys(out)).toEqual([
+      "apiEndpoint",
+      "region",
+      "platformName",
+      "accessTiers"
+    ]);
+    globalThis.expect(get(out, "platformName")).toEqual("Online Shop");
+  });
+  globalThis.test("a key the deploy computes fails the deploy, naming it", () => {
+    let failure;
+    try {
+      Util_ShellConfig$ReventlessAws.fields(computed, undefined, Object.fromEntries([[
+          "apiEndpoint",
+          "https://wrong.example/graphql"
+        ]]));
+      failure = undefined;
+    } catch (raw_message) {
+      let message = Primitive_exceptions.internalToException(raw_message);
+      if (message.RE_EXN_ID === "Failure") {
+        failure = message._1;
+      } else {
+        throw message;
+      }
+    }
+    if (failure !== undefined) {
+      globalThis.expect(failure.includes("apiEndpoint")).toBe(true);
+      return;
+    } else {
+      return JestGlobals.fail("a shellConfig key colliding with a computed one must fail the deploy");
+    }
+  });
+});
+
+export {
+  computed,
+  get,
+}
+/*  Not a pure module */