@reventlessdev/reventless-core 3.0.0-alpha.134

package/src/util/Util.res.mjs

@@ -0,0 +1,42 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+
+function baseName(name) {
+  return Stdlib_Option.getOr(name.split("-")[0], name);
+}
+
+let Adapter;
+
+let AdapterRuntime;
+
+let $$Array;
+
+let $$Error;
+
+let LogFormat;
+
+let $$Promise;
+
+let Pulumi;
+
+let QueryDb;
+
+let QueryDbRuntime;
+
+let ReadModel;
+
+export {
+  baseName,
+  Adapter,
+  AdapterRuntime,
+  $$Array,
+  $$Error,
+  LogFormat,
+  $$Promise,
+  Pulumi,
+  QueryDb,
+  QueryDbRuntime,
+  ReadModel,
+}
+/* No side effect */

package/src/util/Util_Adapter.res

@@ -0,0 +1,97 @@
+open ReventlessInfra.Adapter
+
+let log = Logger.fromEnv()
+
+let filterSupportedResources: (
+  array<resource>,
+  array<string>,
+) => Pulumi.Output.t<array<resource>> = (resources, supportedServices) =>
+  resources
+  ->Array.map(resource => resource.service)
+  ->Pulumi.Output.all
+  ->Pulumi.Output.apply(services =>
+    resources
+    ->Array.zip(services)
+    ->Array.filter(((_resource, service)) =>
+      supportedServices->Array.some(supportedService => service == supportedService)
+    )
+    ->Array.map(((resource, _)) => resource)
+  )
+
+let filterSupportedResolvedResources: (
+  array<Adapter.resolvedResource>,
+  array<string>,
+) => array<Adapter.resolvedResource> = (resources, supportedServices) =>
+  resources->Array.filter(resource =>
+    supportedServices->Array.some(supportedService => resource.service == supportedService)
+  )
+
+let findResource = (resources, service) =>
+  resources
+  ->filterSupportedResources([service])
+  ->Pulumi.Output.apply(resources =>
+    switch resources {
+    | [] =>
+      let err = `Util.Adapter.findResource: Couldn't find service ${service} in resources`
+      let _ =
+        resources
+        ->Array.map(Adapter.resourceToResolvedOutput)
+        ->Pulumi.Output.all
+        ->Pulumi.Output.apply(resources => {
+          let resourcesStr = resources->Adapter.resolvedToString
+          log.error(~comp="Util_Adapter", ~data=JSON.Encode.string(resourcesStr), err)
+        })
+      JsError.throwWithMessage(err)
+    | matching => matching->Array.getUnsafe(0)
+    }
+  )
+  ->Adapter.outputToResource
+
+let findResolvedResource = (resources, service) =>
+  switch resources->filterSupportedResolvedResources([service]) {
+  | [] =>
+    let err = `Util.Adapter.findResolvedResource: Couldn't find service ${service} in resources: ${resources->Adapter.resolvedToString}`
+    log.error(~comp="Util_Adapter", err)
+    JsError.throwWithMessage(err)
+  | matching => matching->Array.getUnsafe(0)
+  }
+
+let findResourceInOutput = (resourcesOutput, service) =>
+  resourcesOutput->Pulumi.Output.apply(resources => resources->findResource(service))
+
+let partitionSupportedResources = (allResources, supportedServices) => {
+  let (names, resourceOutputs) =
+    allResources
+    ->Dict.toArray
+    ->Array.map(((name, resources)) => (
+      name,
+      resources->filterSupportedResources(supportedServices),
+    ))
+    ->Array.unzip
+
+  resourceOutputs // TODO: Avoid waiting for all resourceOutputs, call apply only on needed Outputs
+  ->Pulumi.Output.all // Outputs are unwrapped within Pulumi.Output.all !
+  ->Pulumi.Output.apply(resources => {
+    let (supported, unsupported) =
+      names
+      ->Array.zip(resources)
+      ->Array.partition(((_, resources)) => resources->Array.length > 0)
+    (
+      supported->Array.map(((name, resources)) => (
+        name,
+        resources->Array.map(AdapterDeploytime.unsafeUnwrapResource),
+      )),
+      unsupported->Array.map(((name, _)) => name),
+    )
+  })
+}
+
+type resolvedResources = array<(string, array<Adapter.resolvedResource>)>
+
+let partitionResolvedResourcesByService: (
+  resolvedResources,
+  string,
+) => (resolvedResources, resolvedResources) = (resources, supportedService) =>
+  resources->Array.partition(((_, resources)) =>
+    resources->Array.some(resource => resource.service == supportedService)
+  )

package/src/util/Util_Adapter.res.mjs

@@ -0,0 +1,82 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
+import * as Pulumi from "@pulumi/pulumi";
+import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
+import * as Logger$ReventlessCore from "./Logger.res.mjs";
+import * as Adapter$ReventlessCore from "../adapter/Adapter.res.mjs";
+
+let log = Logger$ReventlessCore.fromEnv();
+
+function filterSupportedResources(resources, supportedServices) {
+  return Pulumi.all(resources.map(resource => resource.service)).apply(services => Stdlib_Array.zip(resources, services).filter(param => {
+    let service = param[1];
+    return supportedServices.some(supportedService => service === supportedService);
+  }).map(param => param[0]));
+}
+
+function filterSupportedResolvedResources(resources, supportedServices) {
+  return resources.filter(resource => supportedServices.some(supportedService => resource.service === supportedService));
+}
+
+function findResource(resources, service) {
+  return Adapter$ReventlessCore.outputToResource(filterSupportedResources(resources, [service]).apply(resources => {
+    if (resources.length !== 0) {
+      return resources[0];
+    }
+    let err = `Util.Adapter.findResource: Couldn't find service ` + service + ` in resources`;
+    Pulumi.all(resources.map(Adapter$ReventlessCore.resourceToResolvedOutput)).apply(resources => {
+      let resourcesStr = Adapter$ReventlessCore.resolvedToString(resources);
+      log.error("Util_Adapter", resourcesStr, err);
+    });
+    return Stdlib_JsError.throwWithMessage(err);
+  }));
+}
+
+function findResolvedResource(resources, service) {
+  let matching = filterSupportedResolvedResources(resources, [service]);
+  if (matching.length !== 0) {
+    return matching[0];
+  }
+  let err = `Util.Adapter.findResolvedResource: Couldn't find service ` + service + ` in resources: ` + Adapter$ReventlessCore.resolvedToString(resources);
+  log.error("Util_Adapter", undefined, err);
+  return Stdlib_JsError.throwWithMessage(err);
+}
+
+function findResourceInOutput(resourcesOutput, service) {
+  return resourcesOutput.apply(resources => findResource(resources, service));
+}
+
+function partitionSupportedResources(allResources, supportedServices) {
+  let match = Stdlib_Array.unzip(Object.entries(allResources).map(param => [
+    param[0],
+    filterSupportedResources(param[1], supportedServices)
+  ]));
+  let names = match[0];
+  return Pulumi.all(match[1]).apply(resources => {
+    let match = Stdlib_Array.partition(Stdlib_Array.zip(names, resources), param => param[1].length !== 0);
+    return [
+      match[0].map(param => [
+        param[0],
+        param[1].map(prim => prim)
+      ]),
+      match[1].map(param => param[0])
+    ];
+  });
+}
+
+function partitionResolvedResourcesByService(resources, supportedService) {
+  return Stdlib_Array.partition(resources, param => param[1].some(resource => resource.service === supportedService));
+}
+
+export {
+  log,
+  filterSupportedResources,
+  filterSupportedResolvedResources,
+  findResource,
+  findResolvedResource,
+  findResourceInOutput,
+  partitionSupportedResources,
+  partitionResolvedResourcesByService,
+}
+/* log Not a pure module */

package/src/util/Util_AdapterRuntime.res

@@ -0,0 +1,39 @@
+open Adapter
+
+let filterSupportedResources = (resources, supportedServices) =>
+  resources->Array.filter((resource: ReventlessInfra.Adapter.resource) =>
+    supportedServices->Array.some(supportedService =>
+      resource.service->Pulumi.Output.get == supportedService
+    )
+  )
+
+let filterSupportedResolvedResources: (
+  array<resolvedResource>,
+  array<string>,
+) => array<resolvedResource> = (resources, supportedServices) =>
+  resources->Array.filter(resource =>
+    supportedServices->Array.some(supportedService => resource.service == supportedService)
+  )
+
+let findResource = (resources, service) =>
+  switch resources->filterSupportedResources([service]) {
+  | [] =>
+    let err = `Util.Adapter.findResource: Couldn't find service ${service} in resources: ${resources
+      ->Array.map(res => res->JSON.stringifyAny->Option.getOrThrow)
+      ->Array.joinUnsafe(", ")}`
+    EffectLogger.logError(~comp=__MODULE__, err)->Effect.runSync
+    JsError.throwWithMessage(err)
+  | matching => matching->Array.getUnsafe(0)
+  }
+
+let findResolvedResource = (resources, service) =>
+  switch resources->filterSupportedResolvedResources([service]) {
+  | [] =>
+    let err = `Util.Adapter.findResolvedResource: Couldn't find service ${service} in resources: ${resources
+      ->Array.map(res => res->JSON.stringifyAny->Option.getOrThrow)
+      ->Array.joinUnsafe(", ")}`
+    EffectLogger.logError(~comp=__MODULE__, err)->Effect.runSync
+    JsError.throwWithMessage(err)
+
+  | resources => resources->Array.getUnsafe(0)
+  }

package/src/util/Util_AdapterRuntime.res.mjs

@@ -0,0 +1,42 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Effect from "effect/Effect";
+import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
+import * as EffectLogger$ReventlessCore from "./EffectLogger.res.mjs";
+
+function filterSupportedResources(resources, supportedServices) {
+  return resources.filter(resource => supportedServices.some(supportedService => resource.service.get() === supportedService));
+}
+
+function filterSupportedResolvedResources(resources, supportedServices) {
+  return resources.filter(resource => supportedServices.some(supportedService => resource.service === supportedService));
+}
+
+function findResource(resources, service) {
+  let matching = filterSupportedResources(resources, [service]);
+  if (matching.length !== 0) {
+    return matching[0];
+  }
+  let err = `Util.Adapter.findResource: Couldn't find service ` + service + ` in resources: ` + resources.map(res => Stdlib_Option.getOrThrow(JSON.stringify(res), undefined)).join(", ");
+  Effect.runSync(EffectLogger$ReventlessCore.logError("Util_AdapterRuntime-ReventlessCore", undefined, err));
+  return Stdlib_JsError.throwWithMessage(err);
+}
+
+function findResolvedResource(resources, service) {
+  let resources$1 = filterSupportedResolvedResources(resources, [service]);
+  if (resources$1.length !== 0) {
+    return resources$1[0];
+  }
+  let err = `Util.Adapter.findResolvedResource: Couldn't find service ` + service + ` in resources: ` + resources.map(res => Stdlib_Option.getOrThrow(JSON.stringify(res), undefined)).join(", ");
+  Effect.runSync(EffectLogger$ReventlessCore.logError("Util_AdapterRuntime-ReventlessCore", undefined, err));
+  return Stdlib_JsError.throwWithMessage(err);
+}
+
+export {
+  filterSupportedResources,
+  filterSupportedResolvedResources,
+  findResource,
+  findResolvedResource,
+}
+/* effect/Effect Not a pure module */

package/src/util/Util_Array.res

@@ -0,0 +1,2 @@
+let containsByPredicate: (array<'a>, 'a => bool) => bool = (arr, predicate) =>
+  arr->Array.find(predicate)->Option.isNone

package/src/util/Util_Array.res.mjs

@@ -0,0 +1,12 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+
+function containsByPredicate(arr, predicate) {
+  return Stdlib_Option.isNone(arr.find(predicate));
+}
+
+export {
+  containsByPredicate,
+}
+/* No side effect */

package/src/util/Util_Error.res

@@ -0,0 +1,16 @@
+type t = {code: string, message: string}
+
+@deprecated("now supported by standard library")
+external ofPromise: exn => t = "%identity"
+
+let message = (~loc=?, exn) =>
+  exn->JsExn.message->Option.getOr("unspecified error") ++
+    loc->Option.mapOr("", loc => ` at ${loc}`)
+
+/** Safely extracts a message string from any caught JS exception-like value. */
+let messageFromUnknown: (unknown, string) => string = %raw(`
+  function(err, fallback) {
+    if (err != null && typeof err.message === 'string') return err.message;
+    return fallback;
+  }
+`)

package/src/util/Util_Error.res.mjs

@@ -0,0 +1,19 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stdlib_JsExn from "@rescript/runtime/lib/es6/Stdlib_JsExn.js";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+
+function message(loc, exn) {
+  return Stdlib_Option.getOr(Stdlib_JsExn.message(exn), "unspecified error") + Stdlib_Option.mapOr(loc, "", loc => ` at ` + loc);
+}
+
+let messageFromUnknown = (function(err, fallback) {
+    if (err != null && typeof err.message === 'string') return err.message;
+    return fallback;
+  });
+
+export {
+  message,
+  messageFromUnknown,
+}
+/* Stdlib_JsExn Not a pure module */

package/src/util/Util_Promise.res

@@ -0,0 +1,67 @@
+type result<'a> = {status: string, value: option<'a>, reason: option<exn>}
+
+let filterRejected = results =>
+  results
+  ->Array.mapWithIndex((result, idx) => (idx, result))
+  ->Array.filter(((_, result)) => result.status == "rejected")
+  ->Array.map(((idx, result)) => (
+    idx,
+    result.reason
+    ->Option.flatMap(reason => reason->JsExn.fromException)
+    ->Option.flatMap(exn => exn->JsExn.message)
+    ->Option.getOr("Unknown error"),
+  ))
+
+@ocaml.doc(
+  " https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise/allSettled "
+)
+@val
+@scope("Promise")
+external allSettled: array<promise<'a>> => promise<array<result<'a>>> = "allSettled"
+
+let map: (promise<'a>, 'a => 'b, exn => 'b) => promise<'b> = async (p, mapOk, mapExn) =>
+  switch await p {
+  | a => a->mapOk
+  | exception e => e->mapExn
+  }
+
+let mapOk: (promise<'a>, 'a => 'b) => promise<'b> = async (p, mapOk) =>
+  switch await p {
+  | a => a->mapOk
+  }
+
+let mapExn: (promise<'a>, 'exn => 'b) => promise<'b> = async (p, mapExn) =>
+  switch await p {
+  | a => a
+  | exception e => e->mapExn
+  }
+
+let toUnit: promise<'a> => promise<unit> = p => p->mapOk(ignore)
+
+let make = () => {
+  let res = ref(_result => ())
+  let rej = ref(_exn => ())
+  let promise = Promise.make((resolve, reject) => {
+    res := resolve
+    rej := reject
+  })
+  (promise, res.contents, rej.contents)
+}
+
+let onEndHandler = async (flush, resolve) => {
+  let _ = switch await flush() {
+  | _res => resolve()
+  | exception JsExn(e) =>
+    EffectLogger.logError(~comp=__MODULE__, `${__LOC__}: ${e->JsExn.message->Option.getOr("unknown")}`)->Effect.runSync
+  }
+}
+
+let finishTimeout = timeout => {
+  let (promise, resolve, _reject) = make()
+  let _ = setTimeout(() => resolve(), timeout)
+  promise
+}
+
+let finishRandomTimeout = (min, max) => {
+  Math.Int.random(min, max)->finishTimeout
+}

package/src/util/Util_Promise.res.mjs

@@ -0,0 +1,105 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stdlib_Math from "@rescript/runtime/lib/es6/Stdlib_Math.js";
+import * as Stdlib_JsExn from "@rescript/runtime/lib/es6/Stdlib_JsExn.js";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Effect from "effect/Effect";
+import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
+import * as EffectLogger$ReventlessCore from "./EffectLogger.res.mjs";
+
+function filterRejected(results) {
+  return results.map((result, idx) => [
+    idx,
+    result
+  ]).filter(param => param[1].status === "rejected").map(param => [
+    param[0],
+    Stdlib_Option.getOr(Stdlib_Option.flatMap(Stdlib_Option.flatMap(param[1].reason, Stdlib_JsExn.fromException), exn => Stdlib_JsExn.message(exn)), "Unknown error")
+  ]);
+}
+
+async function map(p, mapOk, mapExn) {
+  let a;
+  try {
+    a = await p;
+  } catch (raw_e) {
+    return mapExn(Primitive_exceptions.internalToException(raw_e));
+  }
+  return mapOk(a);
+}
+
+async function mapOk(p, mapOk$1) {
+  return mapOk$1(await p);
+}
+
+async function mapExn(p, mapExn$1) {
+  try {
+    return await p;
+  } catch (raw_e) {
+    return mapExn$1(Primitive_exceptions.internalToException(raw_e));
+  }
+}
+
+function toUnit(p) {
+  return mapOk(p, prim => {});
+}
+
+function make() {
+  let res = {
+    contents: _result => {}
+  };
+  let rej = {
+    contents: _exn => {}
+  };
+  let promise = new Promise((resolve, reject) => {
+    res.contents = resolve;
+    rej.contents = reject;
+  });
+  return [
+    promise,
+    res.contents,
+    rej.contents
+  ];
+}
+
+async function onEndHandler(flush, resolve) {
+  let exit = 0;
+  let _res;
+  try {
+    _res = await flush();
+    exit = 1;
+  } catch (raw_e) {
+    let e = Primitive_exceptions.internalToException(raw_e);
+    if (e.RE_EXN_ID === "JsExn") {
+      Effect.runSync(EffectLogger$ReventlessCore.logError("Util_Promise-ReventlessCore", undefined, "File \"Util_Promise.res\", line 55, characters 47-54" + `: ` + Stdlib_Option.getOr(Stdlib_JsExn.message(e._1), "unknown")));
+    } else {
+      throw e;
+    }
+  }
+  if (exit === 1) {
+    resolve();
+  }
+}
+
+function finishTimeout(timeout) {
+  let match = make();
+  let resolve = match[1];
+  setTimeout(() => resolve(), timeout);
+  return match[0];
+}
+
+function finishRandomTimeout(min, max) {
+  return finishTimeout(Stdlib_Math.Int.random(min, max));
+}
+
+export {
+  filterRejected,
+  map,
+  mapOk,
+  mapExn,
+  toUnit,
+  make,
+  onEndHandler,
+  finishTimeout,
+  finishRandomTimeout,
+}
+/* Stdlib_JsExn Not a pure module */

package/src/util/Util_Pulumi.res

@@ -0,0 +1,35 @@
+module Output = {
+  module Async = {
+    type t<'a> = (Pulumi.Output.t<'a>, Pulumi.Output.t<'a> => unit)
+
+    let make = () => {
+      let (set, output) = {
+        let set = ref(_eventCollector => ())
+        let output =
+          Promise.make((resolve, _) => set := resolve)
+          ->Pulumi.Output.fromPromise
+          ->Pulumi.Output.unwrap
+        (set.contents, output)
+      }
+      (output, set)
+    }
+  }
+}
+
+module ComponentResourceOptions = {
+  let ofCustomResourceOptions = (customResourceOpts: Pulumi.CustomResourceOptions.t) => {
+    Pulumi.ComponentResource.id: ?customResourceOpts.id,
+    dependsOn: ?customResourceOpts.dependsOn,
+    parent: ?customResourceOpts.parent,
+    protect: ?customResourceOpts.protect,
+    provider: ?customResourceOpts.provider,
+  }
+
+  let toCustomResourceOptions = (componentResourceOpts: Pulumi.ComponentResource.options) => {
+    Pulumi.CustomResourceOptions.id: ?componentResourceOpts.id,
+    dependsOn: ?componentResourceOpts.dependsOn,
+    parent: ?componentResourceOpts.parent,
+    protect: ?componentResourceOpts.protect,
+    provider: ?componentResourceOpts.provider,
+  }
+}

package/src/util/Util_Pulumi.res.mjs

@@ -0,0 +1,55 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+
+function make() {
+  let set = {
+    contents: _eventCollector => {}
+  };
+  let output = new Promise((resolve, param) => {
+    set.contents = resolve;
+  });
+  let set$1 = set.contents;
+  return [
+    output,
+    set$1
+  ];
+}
+
+let Async = {
+  make: make
+};
+
+let Output = {
+  Async: Async
+};
+
+function ofCustomResourceOptions(customResourceOpts) {
+  return {
+    dependsOn: customResourceOpts.dependsOn,
+    id: customResourceOpts.id,
+    parent: customResourceOpts.parent,
+    protect: customResourceOpts.protect,
+    provider: customResourceOpts.provider
+  };
+}
+
+function toCustomResourceOptions(componentResourceOpts) {
+  return {
+    dependsOn: componentResourceOpts.dependsOn,
+    id: componentResourceOpts.id,
+    parent: componentResourceOpts.parent,
+    protect: componentResourceOpts.protect,
+    provider: componentResourceOpts.provider
+  };
+}
+
+let ComponentResourceOptions = {
+  ofCustomResourceOptions: ofCustomResourceOptions,
+  toCustomResourceOptions: toCustomResourceOptions
+};
+
+export {
+  Output,
+  ComponentResourceOptions,
+}
+/* No side effect */

package/src/util/Util_Pulumi.resi

@@ -0,0 +1,21 @@
+module Output: {
+  module Async: {
+    /** Use an Output before you actually know the value.
+    */
+    type t<'a> = (Pulumi.Output.t<'a>, Pulumi.Output.t<'a> => unit)
+
+    /** create a new async output
+     *
+     *  NOTE: The set function needs to be called in deploytime code
+     *        while the output itself needs to be used in runtime-code.
+     *        Otherwise, just use Pulumi's Output functions (e.g. all, apply)
+     *        to prevent possible dependency-cycles.
+     */
+    let make: unit => t<'a>
+  }
+}
+
+module ComponentResourceOptions: {
+  let ofCustomResourceOptions: Pulumi.CustomResourceOptions.t => Pulumi.ComponentResource.options
+  let toCustomResourceOptions: Pulumi.ComponentResource.options => Pulumi.CustomResourceOptions.t
+}

package/src/util/Util_QueryDb.res

@@ -0,0 +1,14 @@
+let log = Logger.fromEnv()
+
+let getLocalStorageResources = (allQueryDbs: dict<QueryDb.outputs>, queryDbName): array<
+  ReventlessInfra.Adapter.resource,
+> =>
+  try (allQueryDbs->Dict.get(queryDbName)->Option.getOrThrow).resources catch {
+  | exn =>
+    log.error(
+      ~comp="Util_QueryDb",
+      ~data=allQueryDbs->JSON.stringifyAny->Option.getOr("")->JSON.Encode.string,
+      `getLocalStorageResources: Couldn't find QueryDb ${queryDbName}`,
+    )
+    throw(exn)
+  }

package/src/util/Util_QueryDb.res.mjs

@@ -0,0 +1,21 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Logger$ReventlessCore from "./Logger.res.mjs";
+
+let log = Logger$ReventlessCore.fromEnv();
+
+function getLocalStorageResources(allQueryDbs, queryDbName) {
+  try {
+    return Stdlib_Option.getOrThrow(allQueryDbs[queryDbName], undefined).resources;
+  } catch (exn) {
+    log.error("Util_QueryDb", Stdlib_Option.getOr(JSON.stringify(allQueryDbs), ""), `getLocalStorageResources: Couldn't find QueryDb ` + queryDbName);
+    throw exn;
+  }
+}
+
+export {
+  log,
+  getLocalStorageResources,
+}
+/* log Not a pure module */