@reventlessdev/reventless-core 3.0.0-alpha.134

package/src/util/Lru.res

@@ -0,0 +1,51 @@
+// Bounded in-process LRU cache — see Lru.resi for the contract.
+//
+// Recency is tracked via the backing JS Map's insertion order: `get`/`put`
+// delete-then-set the touched key so it moves to the end, leaving the
+// least-recently-used key as the first element of `Map.keys`. `put` evicts that
+// first key once `size` exceeds `capacity`.
+
+type t<'k, 'v> = {
+  capacity: int,
+  store: Map.t<'k, 'v>,
+}
+
+let make = (~capacity: int): t<'k, 'v> => {
+  capacity,
+  store: Map.make(),
+}
+
+let get = (cache: t<'k, 'v>, key: 'k): option<'v> =>
+  switch cache.store->Map.get(key) {
+  | Some(value) =>
+    // Touch: re-insert so this key becomes most-recently-used.
+    let _ = cache.store->Map.delete(key)
+    cache.store->Map.set(key, value)
+    Some(value)
+  | None => None
+  }
+
+let put = (cache: t<'k, 'v>, key: 'k, value: 'v): unit =>
+  if cache.capacity <= 0 {
+    // Disabled cache — nothing to store.
+    ()
+  } else {
+    // Delete first so an update also moves the key to most-recently-used.
+    let _ = cache.store->Map.delete(key)
+    cache.store->Map.set(key, value)
+    if cache.store->Map.size > cache.capacity {
+      // Evict the least-recently-used entry = oldest insertion = first key.
+      switch cache.store->Map.keys->Array.fromIterator->Array.get(0) {
+      | Some(oldest) => let _ = cache.store->Map.delete(oldest)
+      | None => ()
+      }
+    }
+  }
+
+let invalidate = (cache: t<'k, 'v>, key: 'k): unit => {
+  let _ = cache.store->Map.delete(key)
+}
+
+let clear = (cache: t<'k, 'v>): unit => cache.store->Map.clear
+
+let size = (cache: t<'k, 'v>): int => cache.store->Map.size

package/src/util/Lru.res.mjs

@@ -0,0 +1,59 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
+
+function make(capacity) {
+  return {
+    capacity: capacity,
+    store: new Map()
+  };
+}
+
+function get(cache, key) {
+  let value = cache.store.get(key);
+  if (value === undefined) {
+    return;
+  }
+  let value$1 = Primitive_option.valFromOption(value);
+  cache.store.delete(key);
+  cache.store.set(key, value$1);
+  return Primitive_option.some(value$1);
+}
+
+function put(cache, key, value) {
+  if (cache.capacity <= 0) {
+    return;
+  }
+  cache.store.delete(key);
+  cache.store.set(key, value);
+  if (cache.store.size <= cache.capacity) {
+    return;
+  }
+  let oldest = Array.from(cache.store.keys())[0];
+  if (oldest !== undefined) {
+    cache.store.delete(Primitive_option.valFromOption(oldest));
+    return;
+  }
+}
+
+function invalidate(cache, key) {
+  cache.store.delete(key);
+}
+
+function clear(cache) {
+  cache.store.clear();
+}
+
+function size(cache) {
+  return cache.store.size;
+}
+
+export {
+  make,
+  get,
+  put,
+  invalidate,
+  clear,
+  size,
+}
+/* No side effect */

package/src/util/Lru.resi

@@ -0,0 +1,32 @@
+/**
+A bounded, in-process least-recently-used cache.
+
+Backs the StateChangeSlice decision-model projection cache
+(`docs/plans/done/dcb-decision-model-projection-cache.md`): a warm Lambda
+instance keeps the `(decisionState, readHead)` it last derived per query so the
+next same-entity command reads only the delta instead of folding full history.
+
+`get` and `put` both mark the key most-recently-used. Once `size` exceeds
+`capacity`, `put` evicts the least-recently-used key. A `capacity <= 0` disables
+the cache entirely (`get` always misses, `put` is a no-op) so a slice can opt out.
+*/
+
+type t<'k, 'v>
+
+/** Creates an empty cache holding at most `capacity` entries (`<= 0` disables it). */
+let make: (~capacity: int) => t<'k, 'v>
+
+/** Looks up `key`, marking it most-recently-used on a hit. */
+let get: (t<'k, 'v>, 'k) => option<'v>
+
+/** Inserts/updates `key`, marking it most-recently-used and evicting the LRU entry if over capacity. */
+let put: (t<'k, 'v>, 'k, 'v) => unit
+
+/** Drops `key` if present. */
+let invalidate: (t<'k, 'v>, 'k) => unit
+
+/** Drops every entry. */
+let clear: (t<'k, 'v>) => unit
+
+/** Current number of live entries. */
+let size: (t<'k, 'v>) => int

package/src/util/Metrics.res

@@ -0,0 +1,32 @@
+// Provider-neutral metric event emission.
+//
+// Emits one structured JSON line per occurrence — the same posture as `Logger`
+// (generic structured stdout, no provider vocabulary). Core does NOT know about
+// any provider's metric system: a collector/adapter turns these lines into real
+// metrics. On AWS a CloudWatch metric filter (defined in `reventless-aws`,
+// deploy-time) matches the discriminator field and extracts the `slice`
+// dimension + value; another provider can match the same generic shape.
+//
+// Suppressed outside a JSON sink so TTY dev runs stay clean. Used by the DCB
+// StateChangeSlice callback to surface append-retry / append-conflict rates per
+// slice (see docs/analysis/dcb-high-contention-handling.md §6).
+
+// Discriminator key a metric collector keys off. Stable — changing it is a
+// breaking change for any configured metric filter.
+let discriminator = "reventlessMetric"
+
+// Builds the generic metric line. Pure, so the shape is unit-testable.
+let metricLine = (~metric: string, ~slice: string, ~value: int=1): JSON.t =>
+  Dict.fromArray([
+    (discriminator, metric->JSON.Encode.string),
+    ("slice", slice->JSON.Encode.string),
+    ("value", value->JSON.Encode.int),
+    ("unit", "Count"->JSON.Encode.string),
+  ])->JSON.Encode.object
+
+// Emits a single count for `metric`, dimensioned by `slice`. No-op outside a
+// JSON sink. `value` defaults to 1 (one occurrence).
+let emitCount = (~metric: string, ~slice: string, ~value: int=1): unit =>
+  if Reventless.AnsiStyle.isJsonSink() {
+    Console.log(metricLine(~metric, ~slice, ~value)->JSON.stringify)
+  }

package/src/util/Metrics.res.mjs

@@ -0,0 +1,42 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as AnsiStyle$Reventless from "@reventlessdev/reventless-spec/src/AnsiStyle.res.mjs";
+
+let discriminator = "reventlessMetric";
+
+function metricLine(metric, slice, valueOpt) {
+  let value = valueOpt !== undefined ? valueOpt : 1;
+  return Object.fromEntries([
+    [
+      discriminator,
+      metric
+    ],
+    [
+      "slice",
+      slice
+    ],
+    [
+      "value",
+      value
+    ],
+    [
+      "unit",
+      "Count"
+    ]
+  ]);
+}
+
+function emitCount(metric, slice, valueOpt) {
+  let value = valueOpt !== undefined ? valueOpt : 1;
+  if (AnsiStyle$Reventless.isJsonSink()) {
+    console.log(JSON.stringify(metricLine(metric, slice, value)));
+    return;
+  }
+}
+
+export {
+  discriminator,
+  metricLine,
+  emitCount,
+}
+/* AnsiStyle-Reventless Not a pure module */

package/src/util/OutputFailsafeDeploytime.res

@@ -0,0 +1,16 @@
+let apply: (Pulumi.Output.t<string>, string => string) => Pulumi.Output.t<string> = (output, f) =>
+  if output->typeof == #string {
+    output->Pulumi.Output.unwrap->Pulumi.Output.make
+  } else {
+    output
+  }->Pulumi.Output.apply(f)
+
+let flatMap: (
+  Pulumi.Output.t<string>,
+  string => Pulumi.Output.t<string>,
+) => Pulumi.Output.t<string> = (output, f) =>
+  if output->typeof == #string {
+    output->Pulumi.Output.unwrap->Pulumi.Output.make
+  } else {
+    output
+  }->Pulumi.Output.flatMap(f)

package/src/util/OutputFailsafeDeploytime.res.mjs

@@ -0,0 +1,20 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Output$Pulumi from "@reventlessdev/rescript-pulumi-pulumi/src/Output.res.mjs";
+import * as Pulumi from "@pulumi/pulumi";
+
+function apply(output, f) {
+  return (
+    typeof output === "string" ? Pulumi.output(output) : output
+  ).apply(f);
+}
+
+function flatMap(output, f) {
+  return Output$Pulumi.flatMap(typeof output === "string" ? Pulumi.output(output) : output, f);
+}
+
+export {
+  apply,
+  flatMap,
+}
+/* Output-Pulumi Not a pure module */

package/src/util/OutputFailsafeRuntime.res

@@ -0,0 +1,6 @@
+let get: Pulumi.Output.t<string> => string = output =>
+  if output->typeof == #string {
+    output->Pulumi.Output.unwrap
+  } else {
+    output->Pulumi.Output.get
+  }

package/src/util/OutputFailsafeRuntime.res.mjs

@@ -0,0 +1,15 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+
+function get(output) {
+  if (typeof output === "string") {
+    return output;
+  } else {
+    return output.get();
+  }
+}
+
+export {
+  get,
+}
+/* No side effect */

package/src/util/OutputLogger.res

@@ -0,0 +1,9 @@
+let logOutput: (string, Pulumi.Output.t<'a>) => unit = (desc, output) =>
+  if output->Pulumi.Output.isOutput {
+    output
+    ->Pulumi.Output.apply(item => Console.log2(desc, item))
+    ->ignore
+  } else {
+    let itemType = (output->typeof :> string)
+    Console.error(desc ++ " ~}> was expected to be a Pulumi.Output.t, but is " ++ itemType ++ "!")
+  }

package/src/util/OutputLogger.res.mjs

@@ -0,0 +1,19 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Pulumi from "@pulumi/pulumi";
+
+function logOutput(desc, output) {
+  if (Pulumi.Output.isInstance(output)) {
+    output.apply(item => {
+      console.log(desc, item);
+    });
+    return;
+  }
+  let itemType = typeof output;
+  console.error(desc + " ~}> was expected to be a Pulumi.Output.t, but is " + itemType + "!");
+}
+
+export {
+  logOutput,
+}
+/* @pulumi/pulumi Not a pure module */

package/src/util/ResourceQuery.res

@@ -0,0 +1,14 @@
+open ReventlessInfra.Adapter
+
+type runtimeQueryExn = string => resource
+
+type deploytimeQueryExn = string => resource
+
+let unwrapResource = (resource, resourceType, name) =>
+  switch resource {
+  | Some(resource) => resource
+  | None =>
+    JsError.throwWithMessage(
+      `ResourceQuery: Couldn't find ${resourceType} for Service/Task ${name}.`,
+    )
+  }

package/src/util/ResourceQuery.res.mjs

@@ -0,0 +1,17 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
+import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
+
+function unwrapResource(resource, resourceType, name) {
+  if (resource !== undefined) {
+    return Primitive_option.valFromOption(resource);
+  } else {
+    return Stdlib_JsError.throwWithMessage(`ResourceQuery: Couldn't find ` + resourceType + ` for Service/Task ` + name + `.`);
+  }
+}
+
+export {
+  unwrapResource,
+}
+/* No side effect */

package/src/util/ResourceQueryRuntime.res

@@ -0,0 +1,17 @@
+let bucketNameOfAllTasks: (
+  array<Task.outputs>,
+  ~taskName: string,
+  ~bucketName: string,
+) => option<string> = (tasks, ~taskName, ~bucketName) =>
+  tasks
+  ->Array.find(task => task.name == taskName)
+  ->Option.flatMap(task =>
+    task.bucketNames->Option.flatMap(buckets => buckets->Dict.get(bucketName))
+  )
+  ->Option.map(bucket => bucket->Pulumi.Output.get)
+
+let bucketNameOfTaskExn = (tasks, ~taskName, ~bucketName) =>
+  bucketNameOfAllTasks(tasks, ~taskName, ~bucketName)->ResourceQuery.unwrapResource(
+    "Bucket",
+    taskName,
+  )

package/src/util/ResourceQueryRuntime.res.mjs

@@ -0,0 +1,18 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as ResourceQuery$ReventlessCore from "./ResourceQuery.res.mjs";
+
+function bucketNameOfAllTasks(tasks, taskName, bucketName) {
+  return Stdlib_Option.map(Stdlib_Option.flatMap(tasks.find(task => task.name === taskName), task => Stdlib_Option.flatMap(task.bucketNames, buckets => buckets[bucketName])), bucket => bucket.get());
+}
+
+function bucketNameOfTaskExn(tasks, taskName, bucketName) {
+  return ResourceQuery$ReventlessCore.unwrapResource(bucketNameOfAllTasks(tasks, taskName, bucketName), "Bucket", taskName);
+}
+
+export {
+  bucketNameOfAllTasks,
+  bucketNameOfTaskExn,
+}
+/* No side effect */

package/src/util/ScheduleOps.res

@@ -0,0 +1,124 @@
+open Reventless.Schedule
+
+module DateCalc = {
+  /*** Immutable functions to calculate new Dates without mutation the arguments */
+  @new
+  external dateFromDate: Date.t => Date.t = "Date"
+
+  let addMinutes: (Date.t, int) => Date.t = (date, minutes) => {
+    let result = date->dateFromDate
+    result->Date.setUTCMinutes(result->Date.getUTCMinutes + minutes)
+    result
+  }
+
+  let addDays: (Date.t, int) => Date.t = (date, days) => {
+    let result = date->dateFromDate
+    result->Date.setUTCDate(result->Date.getUTCDate + days)
+    result
+  }
+}
+
+let forChannel = (~name, ~channelId, ~resourceNaming: ReventlessInfra.ResourceNaming.operations) =>
+  name->resourceNaming.validateName ++ ("-" ++ channelId->String.split("-")->Array.getUnsafe(1))
+
+let minutesFromNow = minutes => {
+  let m = Date.make()->DateCalc.addMinutes(minutes)
+  Single(
+    m->Date.getUTCFullYear,
+    m->Date.getUTCMonth + 1,
+    m->Date.getUTCDate,
+    m->Date.getUTCHours,
+    m->Date.getUTCMinutes,
+  )
+}
+
+let nextTime = (h: hour, m: minute) => {
+  let now = Date.make()
+  let today = {
+    let epoch = Date.make()
+    epoch->Date.setUTCHours(h)
+    epoch->Date.setUTCMinutes(m)
+    epoch->Date.setUTCSeconds(0)
+    epoch
+  }
+  let tomorrow = today->DateCalc.addDays(1)
+  today < now
+    ? Single(
+        tomorrow->Date.getUTCFullYear,
+        tomorrow->Date.getUTCMonth + 1,
+        tomorrow->Date.getUTCDate,
+        tomorrow->Date.getUTCHours,
+        tomorrow->Date.getUTCMinutes,
+      )
+    : Single(
+        today->Date.getUTCFullYear,
+        today->Date.getUTCMonth + 1,
+        today->Date.getUTCDate,
+        today->Date.getUTCHours,
+        today->Date.getUTCMinutes,
+      )
+}
+
+exception ScheduleNotCreated(schedule)
+exception ScheduleNotDeleted(string)
+
+let create = (
+  ~scheduler: Scheduler.operations,
+  ~channelResources,
+  ~resourceNaming: ReventlessInfra.ResourceNaming.operations,
+) =>
+  async schedule => {
+    let name = schedule.name->resourceNaming.validateName
+    let schedule = {...schedule, name}
+    let createSchedule = scheduler.createSchedule
+    let exit =
+      await Effect.tryPromise(
+        ~catch=err => Util.Error.messageFromUnknown(err, "schedule create"),
+        () => createSchedule(channelResources, schedule),
+      )
+      ->Effect.tap(_ =>
+        EffectLogger.logInfo(
+          ~comp=__MODULE__,
+          `create: created ${schedule->JSON.stringifyAny->Option.getOr("")}`,
+        )
+      )
+      ->Effect.runPromiseExit
+    if !(exit->Exit.isSuccess) {
+      let errMsg = exit->Exit.match(
+        ~onFailure=cause => cause->Cause.pretty,
+        ~onSuccess=_ => "unknown",
+      )
+      EffectLogger.logError(
+        ~comp=__MODULE__,
+        `create: couldn't create ${schedule
+          ->JSON.stringifyAny
+          ->Option.getOr("")}: ${errMsg}`,
+      )->Effect.runSync
+      throw(ScheduleNotCreated(schedule))
+    }
+  }
+
+let delete = (
+  ~scheduler: Scheduler.operations,
+  ~channelResources,
+  ~resourceNaming: ReventlessInfra.ResourceNaming.operations,
+) =>
+  async name => {
+    let name = name->resourceNaming.validateName
+    let deleteSchedule = scheduler.deleteSchedule
+    let exit =
+      await Effect.tryPromise(
+        ~catch=err => Util.Error.messageFromUnknown(err, "schedule delete"),
+        () => deleteSchedule(channelResources, name),
+      )
+      ->Effect.tap(_ => EffectLogger.logInfo(~comp=__MODULE__, `delete: deleted ${name}`))
+      ->Effect.runPromiseExit
+    if !(exit->Exit.isSuccess) {
+      let errMsg = exit->Exit.match(
+        ~onFailure=cause => cause->Cause.pretty,
+        ~onSuccess=_ => "unknown",
+      )
+      EffectLogger.logError(~comp=__MODULE__, `delete: couldn't delete ${name}: ${errMsg}`)->Effect.runSync
+      throw(ScheduleNotDeleted(name))
+    }
+  }

package/src/util/ScheduleOps.res.mjs

@@ -0,0 +1,132 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Exit from "@reventlessdev/rescript-effect/src/Exit.res.mjs";
+import * as Effect from "@reventlessdev/rescript-effect/src/Effect.res.mjs";
+import * as Exit$1 from "effect/Exit";
+import * as Cause from "effect/Cause";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Effect$1 from "effect/Effect";
+import * as Primitive_object from "@rescript/runtime/lib/es6/Primitive_object.js";
+import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
+import * as Util_Error$ReventlessCore from "./Util_Error.res.mjs";
+import * as EffectLogger$ReventlessCore from "./EffectLogger.res.mjs";
+
+function addMinutes(date, minutes) {
+  let result = new Date(date);
+  result.setUTCMinutes(result.getUTCMinutes() + minutes | 0);
+  return result;
+}
+
+function addDays(date, days) {
+  let result = new Date(date);
+  result.setUTCDate(result.getUTCDate() + days | 0);
+  return result;
+}
+
+let DateCalc = {
+  addMinutes: addMinutes,
+  addDays: addDays
+};
+
+function forChannel(name, channelId, resourceNaming) {
+  return resourceNaming.validateName(name) + ("-" + channelId.split("-")[1]);
+}
+
+function minutesFromNow(minutes) {
+  let m = addMinutes(new Date(), minutes);
+  return {
+    TAG: "Single",
+    _0: m.getUTCFullYear(),
+    _1: m.getUTCMonth() + 1 | 0,
+    _2: m.getUTCDate(),
+    _3: m.getUTCHours(),
+    _4: m.getUTCMinutes()
+  };
+}
+
+function nextTime(h, m) {
+  let now = new Date();
+  let epoch = new Date();
+  epoch.setUTCHours(h);
+  epoch.setUTCMinutes(m);
+  epoch.setUTCSeconds(0);
+  let tomorrow = addDays(epoch, 1);
+  if (Primitive_object.lessthan(epoch, now)) {
+    return {
+      TAG: "Single",
+      _0: tomorrow.getUTCFullYear(),
+      _1: tomorrow.getUTCMonth() + 1 | 0,
+      _2: tomorrow.getUTCDate(),
+      _3: tomorrow.getUTCHours(),
+      _4: tomorrow.getUTCMinutes()
+    };
+  } else {
+    return {
+      TAG: "Single",
+      _0: epoch.getUTCFullYear(),
+      _1: epoch.getUTCMonth() + 1 | 0,
+      _2: epoch.getUTCDate(),
+      _3: epoch.getUTCHours(),
+      _4: epoch.getUTCMinutes()
+    };
+  }
+}
+
+let ScheduleNotCreated = /* @__PURE__ */Primitive_exceptions.create("ScheduleOps-ReventlessCore.ScheduleNotCreated");
+
+let ScheduleNotDeleted = /* @__PURE__ */Primitive_exceptions.create("ScheduleOps-ReventlessCore.ScheduleNotDeleted");
+
+function create(scheduler, channelResources, resourceNaming) {
+  return async schedule => {
+    let name = resourceNaming.validateName(schedule.name);
+    let schedule_rate = schedule.rate;
+    let schedule_payload = schedule.payload;
+    let schedule$1 = {
+      name: name,
+      rate: schedule_rate,
+      payload: schedule_payload
+    };
+    let createSchedule = scheduler.createSchedule;
+    let exit = await Effect$1.runPromiseExit(Effect$1.tap(Effect.tryPromise(err => Util_Error$ReventlessCore.messageFromUnknown(err, "schedule create"), () => createSchedule(channelResources, schedule$1)), () => EffectLogger$ReventlessCore.logInfo("ScheduleOps-ReventlessCore", undefined, `create: created ` + Stdlib_Option.getOr(JSON.stringify(schedule$1), ""))));
+    if (Exit$1.isSuccess(exit)) {
+      return;
+    }
+    let errMsg = Exit.match(exit, cause => Cause.pretty(cause), () => "unknown");
+    Effect$1.runSync(EffectLogger$ReventlessCore.logError("ScheduleOps-ReventlessCore", undefined, `create: couldn't create ` + Stdlib_Option.getOr(JSON.stringify(schedule$1), "") + `: ` + errMsg));
+    throw {
+      RE_EXN_ID: ScheduleNotCreated,
+      _1: schedule$1,
+      Error: new Error()
+    };
+  };
+}
+
+function $$delete(scheduler, channelResources, resourceNaming) {
+  return async name => {
+    let name$1 = resourceNaming.validateName(name);
+    let deleteSchedule = scheduler.deleteSchedule;
+    let exit = await Effect$1.runPromiseExit(Effect$1.tap(Effect.tryPromise(err => Util_Error$ReventlessCore.messageFromUnknown(err, "schedule delete"), () => deleteSchedule(channelResources, name$1)), () => EffectLogger$ReventlessCore.logInfo("ScheduleOps-ReventlessCore", undefined, `delete: deleted ` + name$1)));
+    if (Exit$1.isSuccess(exit)) {
+      return;
+    }
+    let errMsg = Exit.match(exit, cause => Cause.pretty(cause), () => "unknown");
+    Effect$1.runSync(EffectLogger$ReventlessCore.logError("ScheduleOps-ReventlessCore", undefined, `delete: couldn't delete ` + name$1 + `: ` + errMsg));
+    throw {
+      RE_EXN_ID: ScheduleNotDeleted,
+      _1: name$1,
+      Error: new Error()
+    };
+  };
+}
+
+export {
+  DateCalc,
+  forChannel,
+  minutesFromNow,
+  nextTime,
+  ScheduleNotCreated,
+  ScheduleNotDeleted,
+  create,
+  $$delete,
+}
+/* Exit Not a pure module */

package/src/util/Util.res

@@ -0,0 +1,12 @@
+let baseName = name => (name->String.split("-"))[0]->Option.getOr(name)
+
+module Adapter = Util_Adapter
+module AdapterRuntime = Util_AdapterRuntime
+module Array = Util_Array
+module Error = Util_Error
+module LogFormat = LogFormat
+module Promise = Util_Promise
+module Pulumi = Util_Pulumi
+module QueryDb = Util_QueryDb
+module QueryDbRuntime = Util_QueryDbRuntime
+module ReadModel = Util_ReadModel