@reventlessdev/reventless-local 3.0.0-alpha.115 → 3.0.0-alpha.116

package/src/adapter/ProjectionPending.res

@@ -0,0 +1,60 @@
+// In-memory "appended but not yet fully published" tracker backing the SQLite
+// projection checkpoint (see ProjectionCheckpoint.res).
+//
+// The storage adapters register each appended batch here (msgId → global
+// position) the moment the insert transaction commits; Platform's afterPublish
+// hook resolves the batch once `Bus.publishEvent` has returned — i.e. after
+// every subscriber (including all projections) has processed the events. The
+// gap between the two is exactly the crash window a checkpoint must not
+// advance over: `minPending(axis) - 1` is the highest position provably fully
+// projected on that axis.
+//
+// Two independent position axes exist, because the two persisted logs have
+// unrelated global sequences (each uses its own table's rowid):
+//   Aggregate — event_log   (aggregate EventLogs → ReadModel projections)
+//   Dcb       — dcb_event   (DCB slice events → StateViewSlice projections)
+// msgIds are globally unique, so resolution needs no axis; each entry just
+// remembers which axis its position belongs to.
+//
+// Tracking is off by default so bare storage construction (tests, tools) never
+// accumulates entries nobody resolves; Platform enables it for the SQLite
+// backend only. State is module-level — one platform per process, same as the
+// LocalBus registries.
+
+type axis =
+  | Aggregate
+  | Dcb
+
+let enabled = ref(false)
+let pendingByMsgId: dict<(axis, int)> = Dict.make()
+
+let enableTracking = () => enabled := true
+
+let trackAppended = (~axis: axis, entries: array<(string, int)>) =>
+  if enabled.contents {
+    entries->Array.forEach(((msgId, position)) =>
+      pendingByMsgId->Dict.set(msgId, (axis, position))
+    )
+  }
+
+let resolve = (msgIds: array<string>) =>
+  msgIds->Array.forEach(msgId => pendingByMsgId->Dict.delete(msgId))
+
+// Lowest still-pending position on the given axis, or None when every tracked
+// append on that axis has completed its publish cycle.
+let minPending = (axis: axis): option<int> => {
+  let positions =
+    pendingByMsgId
+    ->Dict.valuesToArray
+    ->Array.filterMap(((a, p)) => a == axis ? Some(p) : None)
+  switch positions->Array.get(0) {
+  | None => None
+  | Some(first) => Some(positions->Array.reduce(first, (a, b) => a < b ? a : b))
+  }
+}
+
+// Test isolation: clears state AND disables tracking (the default).
+let reset = () => {
+  enabled := false
+  pendingByMsgId->Dict.keysToArray->Array.forEach(k => pendingByMsgId->Dict.delete(k))
+}

package/src/adapter/ProjectionPending.res.mjs

@@ -0,0 +1,64 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stdlib_Dict from "@rescript/runtime/lib/es6/Stdlib_Dict.js";
+import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
+
+let enabled = {
+  contents: false
+};
+
+let pendingByMsgId = {};
+
+function enableTracking() {
+  enabled.contents = true;
+}
+
+function trackAppended(axis, entries) {
+  if (enabled.contents) {
+    entries.forEach(param => {
+      pendingByMsgId[param[0]] = [
+        axis,
+        param[1]
+      ];
+    });
+    return;
+  }
+}
+
+function resolve(msgIds) {
+  msgIds.forEach(msgId => Stdlib_Dict.$$delete(pendingByMsgId, msgId));
+}
+
+function minPending(axis) {
+  let positions = Stdlib_Array.filterMap(Object.values(pendingByMsgId), param => {
+    if (param[0] === axis) {
+      return param[1];
+    }
+  });
+  let first = positions[0];
+  if (first !== undefined) {
+    return Stdlib_Array.reduce(positions, first, (a, b) => {
+      if (a < b) {
+        return a;
+      } else {
+        return b;
+      }
+    });
+  }
+}
+
+function reset() {
+  enabled.contents = false;
+  Object.keys(pendingByMsgId).forEach(k => Stdlib_Dict.$$delete(pendingByMsgId, k));
+}
+
+export {
+  enabled,
+  pendingByMsgId,
+  enableTracking,
+  trackAppended,
+  resolve,
+  minPending,
+  reset,
+}
+/* No side effect */

package/src/adapter/QueryDb/QueryDbListQuery.res

@@ -0,0 +1,261 @@
+// The connection-list filter / sort / keyset-paginate logic, extracted verbatim
+// from QueryDbResolvers_GraphQL so there is ONE source of truth for the
+// semantics. The resolver calls `run` over the materialised items (in-memory
+// path); the SQLite backend's list push-down must reproduce these exact
+// semantics, and the parity harness asserts it does. Keeping this pure (no
+// server / storage dependencies — the one server helper it needs, global-id
+// decoding for the `ids` filter, is passed in) is what lets it be the shared
+// spec both paths are tested against.
+
+open ReventlessCore
+
+// base64 cursor of the active sort field's value. Shared with the resolver's
+// items (sub-id) connection so cursor encoding stays in lockstep.
+@val external btoa: string => string = "btoa"
+@val external atob: string => string = "atob"
+let encodeCursor = (value: string): string => btoa(value)
+let decodeCursor = (cursor: string): string => atob(cursor)
+
+// Default page size when neither `first` nor `last` is supplied — a bound is
+// required for keyset `pageInfo` to be reported correctly.
+let defaultListPageSize = 50
+
+// The effective id of an item (its "id" field). Shared with the SQLite
+// push-down so both compute the tiebreak / default-cursor value identically.
+let getId = (item: JSON.t): string =>
+  item
+  ->JSON.Decode.object
+  ->Option.flatMap(d => d->Dict.get("id"))
+  ->Option.flatMap(JSON.Decode.string)
+  ->Option.getOr("")
+
+// String form of a field for comparison / cursor purposes: the string itself,
+// or a number rendered via Float.toString, else None. The push-down must render
+// the same string in SQL (CAST … AS TEXT) for cursor/order parity.
+let getFieldString = (item: JSON.t, field: string): option<string> =>
+  item
+  ->JSON.Decode.object
+  ->Option.flatMap(d => d->Dict.get(field))
+  ->Option.flatMap(v =>
+    switch v->JSON.Decode.string {
+    | Some(s) => Some(s)
+    | None => v->JSON.Decode.float->Option.map(f => Float.toString(f))
+    }
+  )
+
+// Build the Relay connection object from an already-ordered page. Shared by
+// `run` and the SQLite push-down so edges / cursors / pageInfo have one shape.
+let buildConnection = (
+  ~pageItems: array<JSON.t>,
+  ~hasNextPage: bool,
+  ~hasPreviousPage: bool,
+  ~cursorValueOf: JSON.t => string,
+): JSON.t => {
+  let edges =
+    pageItems->Array.map(item => Obj.magic({"node": item, "cursor": encodeCursor(cursorValueOf(item))}))
+  let startCursor = pageItems->Array.get(0)->Option.map(item => encodeCursor(cursorValueOf(item)))
+  let endCursor =
+    pageItems->Array.get(pageItems->Array.length - 1)->Option.map(item => encodeCursor(cursorValueOf(item)))
+  Obj.magic({
+    "edges": edges,
+    "pageInfo": {
+      "hasNextPage": hasNextPage,
+      "hasPreviousPage": hasPreviousPage,
+      "startCursor": startCursor->Nullable.fromOption,
+      "endCursor": endCursor->Nullable.fromOption,
+    },
+  })
+}
+
+// Compute the Relay connection response (edges + pageInfo) for `items` under the
+// GraphQL args. `decodeLocalId` maps a possibly-Relay-encoded id to its local id
+// (the resolver passes DomainGraphQL_Server.decodeGlobalId); everything else is
+// pure over the item array.
+let run = (
+  ~items: array<JSON.t>,
+  ~argsDict: Dict.t<JSON.t>,
+  ~capability: GraphQL_FragmentGenerator.serverCapability,
+  ~labelField: string,
+  ~decodeLocalId: string => option<string>,
+): JSON.t => {
+  let filterDict =
+    argsDict->Dict.get("filter")->Option.flatMap(JSON.Decode.object)->Option.getOr(Dict.make())
+  let search = filterDict->Dict.get("search")->Option.flatMap(JSON.Decode.string)
+  let searchPrefix = filterDict->Dict.get("searchPrefix")->Option.flatMap(JSON.Decode.string)
+  let ids =
+    filterDict
+    ->Dict.get("ids")
+    ->Option.flatMap(JSON.Decode.array)
+    ->Option.map(arr => arr->Array.filterMap(JSON.Decode.string))
+  let getLabel = item =>
+    item
+    ->JSON.Decode.object
+    ->Option.flatMap(d => d->Dict.get(labelField))
+    ->Option.flatMap(JSON.Decode.string)
+    ->Option.getOr("")
+  // Per-field eq / from / to filters derived from capability — applied alongside
+  // the legacy search/searchPrefix/ids block.
+  let perFieldChecks: array<JSON.t => bool> = capability.filterFields->Array.flatMap(f => {
+    let checks: array<JSON.t => bool> = []
+    switch filterDict->Dict.get(f.name ++ "Eq") {
+    | Some(v) when v != JSON.Encode.null =>
+      let expected = switch v->JSON.Decode.string {
+      | Some(s) => s
+      | None => v->JSON.Decode.float->Option.map(f => Float.toString(f))->Option.getOr("")
+      }
+      checks->Array.push(item =>
+        getFieldString(item, f.name)->Option.mapOr(false, v => v == expected)
+      )
+    | _ => ()
+    }
+    if f.range {
+      switch filterDict->Dict.get(f.name ++ "From") {
+      | Some(v) when v != JSON.Encode.null =>
+        let from =
+          v
+          ->JSON.Decode.string
+          ->Option.getOr(v->JSON.Decode.float->Option.map(f => Float.toString(f))->Option.getOr(""))
+        checks->Array.push(item => getFieldString(item, f.name)->Option.mapOr(false, v => v >= from))
+      | _ => ()
+      }
+      switch filterDict->Dict.get(f.name ++ "To") {
+      | Some(v) when v != JSON.Encode.null =>
+        let to_ =
+          v
+          ->JSON.Decode.string
+          ->Option.getOr(v->JSON.Decode.float->Option.map(f => Float.toString(f))->Option.getOr(""))
+        checks->Array.push(item => getFieldString(item, f.name)->Option.mapOr(false, v => v <= to_))
+      | _ => ()
+      }
+    }
+    checks
+  })
+
+  let filtered = items->Array.filter(item => {
+    let passSearch = switch search {
+    | Some(s) if s->String.length > 0 =>
+      getLabel(item)->String.toLowerCase->String.includes(s->String.toLowerCase)
+    | _ => true
+    }
+    let passPrefix = switch searchPrefix {
+    | Some(p) if p->String.length > 0 =>
+      getLabel(item)->String.toLowerCase->String.startsWith(p->String.toLowerCase)
+    | _ => true
+    }
+    let passIds = switch ids {
+    | Some(idList) if idList->Array.length > 0 =>
+      let itemId = getId(item)
+      let itemLocalId = decodeLocalId(itemId)
+      idList->Array.some(i => i == itemId || itemLocalId == Some(i))
+    | _ => true
+    }
+    let passPerField = perFieldChecks->Array.every(check => check(item))
+    passSearch && passPrefix && passIds && passPerField
+  })
+
+  let orderByDict = argsDict->Dict.get("orderBy")->Option.flatMap(JSON.Decode.object)
+  let orderByField =
+    orderByDict->Option.flatMap(ob => ob->Dict.get("field"))->Option.flatMap(JSON.Decode.string)
+  let direction =
+    orderByDict
+    ->Option.flatMap(ob => ob->Dict.get("direction"))
+    ->Option.flatMap(JSON.Decode.string)
+    ->Option.getOr("ASC")
+  let isDesc = direction == "DESC"
+  let sorted = switch orderByField {
+  | Some(f) =>
+    let cmp = (a, b) => {
+      let av = getFieldString(a, f)->Option.getOr("")
+      let bv = getFieldString(b, f)->Option.getOr("")
+      let primary = if av < bv {
+        -1
+      } else if av > bv {
+        1
+      } else {
+        0
+      }
+      let primary = isDesc ? -primary : primary
+      if primary != 0 {
+        primary
+      } else {
+        let aid = getId(a)
+        let bid = getId(b)
+        if aid < bid {
+          -1
+        } else if aid > bid {
+          1
+        } else {
+          0
+        }
+      }
+    }
+    filtered->Array.toSorted((a, b) => cmp(a, b)->Int.toFloat)
+  | None =>
+    filtered->Array.toSorted((a, b) => {
+      let aid = getId(a)
+      let bid = getId(b)
+      if aid < bid {
+        -1.
+      } else if aid > bid {
+        1.
+      } else {
+        0.
+      }
+    })
+  }
+
+  let first =
+    argsDict->Dict.get("first")->Option.flatMap(JSON.Decode.float)->Option.map(Float.toInt)
+  let after = argsDict->Dict.get("after")->Option.flatMap(JSON.Decode.string)
+  let last = argsDict->Dict.get("last")->Option.flatMap(JSON.Decode.float)->Option.map(Float.toInt)
+  let before = argsDict->Dict.get("before")->Option.flatMap(JSON.Decode.string)
+  let isBackward = last->Option.isSome
+  let cursorField = orderByField->Option.getOr("id")
+  let getCursorValue = item => getFieldString(item, cursorField)->Option.getOr(getId(item))
+
+  let cursorBounded = switch (isBackward, after, before) {
+  | (false, Some(c), _) =>
+    let cv = decodeCursor(c)
+    sorted->Array.filter(item => {
+      let v = getCursorValue(item)
+      isDesc ? v < cv : v > cv
+    })
+  | (true, _, Some(c)) =>
+    let cv = decodeCursor(c)
+    sorted->Array.filter(item => {
+      let v = getCursorValue(item)
+      isDesc ? v > cv : v < cv
+    })
+  | _ => sorted
+  }
+
+  let pageSize = if isBackward {
+    last->Option.getOr(defaultListPageSize)
+  } else {
+    first->Option.getOr(defaultListPageSize)
+  }
+  let take = pageSize + 1
+  let (pageItems, hasMore) = if isBackward {
+    let len = cursorBounded->Array.length
+    let startIdx = len > take ? len - take : 0
+    let arr = cursorBounded->Array.slice(~start=startIdx, ~end=len)
+    let hasMore = arr->Array.length > pageSize
+    let result = if hasMore {
+      arr->Array.slice(~start=1, ~end=arr->Array.length)
+    } else {
+      arr
+    }
+    (result, hasMore)
+  } else {
+    let arr = cursorBounded->Array.slice(~start=0, ~end=take)
+    let hasMore = arr->Array.length > pageSize
+    (arr->Array.slice(~start=0, ~end=pageSize), hasMore)
+  }
+
+  buildConnection(
+    ~pageItems,
+    ~hasNextPage=!isBackward && hasMore,
+    ~hasPreviousPage=isBackward && hasMore,
+    ~cursorValueOf=getCursorValue,
+  )
+}

package/src/adapter/QueryDb/QueryDbListQuery.res.mjs

@@ -0,0 +1,212 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stdlib_JSON from "@rescript/runtime/lib/es6/Stdlib_JSON.js";
+import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Stdlib_Nullable from "@rescript/runtime/lib/es6/Stdlib_Nullable.js";
+import * as Primitive_object from "@rescript/runtime/lib/es6/Primitive_object.js";
+
+function encodeCursor(value) {
+  return btoa(value);
+}
+
+function decodeCursor(cursor) {
+  return atob(cursor);
+}
+
+function getId(item) {
+  return Stdlib_Option.getOr(Stdlib_Option.flatMap(Stdlib_Option.flatMap(Stdlib_JSON.Decode.object(item), d => d["id"]), Stdlib_JSON.Decode.string), "");
+}
+
+function getFieldString(item, field) {
+  return Stdlib_Option.flatMap(Stdlib_Option.flatMap(Stdlib_JSON.Decode.object(item), d => d[field]), v => {
+    let s = Stdlib_JSON.Decode.string(v);
+    if (s !== undefined) {
+      return s;
+    } else {
+      return Stdlib_Option.map(Stdlib_JSON.Decode.float(v), f => f.toString());
+    }
+  });
+}
+
+function buildConnection(pageItems, hasNextPage, hasPreviousPage, cursorValueOf) {
+  let edges = pageItems.map(item => ({
+    node: item,
+    cursor: btoa(cursorValueOf(item))
+  }));
+  let startCursor = Stdlib_Option.map(pageItems[0], item => btoa(cursorValueOf(item)));
+  let endCursor = Stdlib_Option.map(pageItems[pageItems.length - 1 | 0], item => btoa(cursorValueOf(item)));
+  return {
+    edges: edges,
+    pageInfo: {
+      hasNextPage: hasNextPage,
+      hasPreviousPage: hasPreviousPage,
+      startCursor: Stdlib_Nullable.fromOption(startCursor),
+      endCursor: Stdlib_Nullable.fromOption(endCursor)
+    }
+  };
+}
+
+function run(items, argsDict, capability, labelField, decodeLocalId) {
+  let filterDict = Stdlib_Option.getOr(Stdlib_Option.flatMap(argsDict["filter"], Stdlib_JSON.Decode.object), {});
+  let search = Stdlib_Option.flatMap(filterDict["search"], Stdlib_JSON.Decode.string);
+  let searchPrefix = Stdlib_Option.flatMap(filterDict["searchPrefix"], Stdlib_JSON.Decode.string);
+  let ids = Stdlib_Option.map(Stdlib_Option.flatMap(filterDict["ids"], Stdlib_JSON.Decode.array), arr => Stdlib_Array.filterMap(arr, Stdlib_JSON.Decode.string));
+  let getLabel = item => Stdlib_Option.getOr(Stdlib_Option.flatMap(Stdlib_Option.flatMap(Stdlib_JSON.Decode.object(item), d => d[labelField]), Stdlib_JSON.Decode.string), "");
+  let perFieldChecks = capability.filterFields.flatMap(f => {
+    let checks = [];
+    let v = filterDict[f.name + "Eq"];
+    if (v !== undefined && v !== null) {
+      let s = Stdlib_JSON.Decode.string(v);
+      let expected = s !== undefined ? s : Stdlib_Option.getOr(Stdlib_Option.map(Stdlib_JSON.Decode.float(v), f => f.toString()), "");
+      checks.push(item => Stdlib_Option.mapOr(getFieldString(item, f.name), false, v => v === expected));
+    }
+    if (f.range) {
+      let v$1 = filterDict[f.name + "From"];
+      if (v$1 !== undefined && v$1 !== null) {
+        let from = Stdlib_Option.getOr(Stdlib_JSON.Decode.string(v$1), Stdlib_Option.getOr(Stdlib_Option.map(Stdlib_JSON.Decode.float(v$1), f => f.toString()), ""));
+        checks.push(item => Stdlib_Option.mapOr(getFieldString(item, f.name), false, v => v >= from));
+      }
+      let v$2 = filterDict[f.name + "To"];
+      if (v$2 !== undefined && v$2 !== null) {
+        let to_ = Stdlib_Option.getOr(Stdlib_JSON.Decode.string(v$2), Stdlib_Option.getOr(Stdlib_Option.map(Stdlib_JSON.Decode.float(v$2), f => f.toString()), ""));
+        checks.push(item => Stdlib_Option.mapOr(getFieldString(item, f.name), false, v => v <= to_));
+      }
+    }
+    return checks;
+  });
+  let filtered = items.filter(item => {
+    let passSearch = search !== undefined && search.length > 0 ? getLabel(item).toLowerCase().includes(search.toLowerCase()) : true;
+    let passPrefix = searchPrefix !== undefined && searchPrefix.length > 0 ? getLabel(item).toLowerCase().startsWith(searchPrefix.toLowerCase()) : true;
+    let passIds;
+    if (ids !== undefined && ids.length !== 0) {
+      let itemId = getId(item);
+      let itemLocalId = decodeLocalId(itemId);
+      passIds = ids.some(i => {
+        if (i === itemId) {
+          return true;
+        } else {
+          return Primitive_object.equal(itemLocalId, i);
+        }
+      });
+    } else {
+      passIds = true;
+    }
+    let passPerField = perFieldChecks.every(check => check(item));
+    if (passSearch && passPrefix && passIds) {
+      return passPerField;
+    } else {
+      return false;
+    }
+  });
+  let orderByDict = Stdlib_Option.flatMap(argsDict["orderBy"], Stdlib_JSON.Decode.object);
+  let orderByField = Stdlib_Option.flatMap(Stdlib_Option.flatMap(orderByDict, ob => ob["field"]), Stdlib_JSON.Decode.string);
+  let direction = Stdlib_Option.getOr(Stdlib_Option.flatMap(Stdlib_Option.flatMap(orderByDict, ob => ob["direction"]), Stdlib_JSON.Decode.string), "ASC");
+  let isDesc = direction === "DESC";
+  let sorted;
+  if (orderByField !== undefined) {
+    sorted = filtered.toSorted((a, b) => {
+      let av = Stdlib_Option.getOr(getFieldString(a, orderByField), "");
+      let bv = Stdlib_Option.getOr(getFieldString(b, orderByField), "");
+      let primary = av < bv ? -1 : (
+          av > bv ? 1 : 0
+        );
+      let primary$1 = isDesc ? -primary | 0 : primary;
+      if (primary$1 !== 0) {
+        return primary$1;
+      }
+      let aid = getId(a);
+      let bid = getId(b);
+      if (aid < bid) {
+        return -1;
+      } else if (aid > bid) {
+        return 1;
+      } else {
+        return 0;
+      }
+    });
+  } else {
+    sorted = filtered.toSorted((a, b) => {
+      let aid = getId(a);
+      let bid = getId(b);
+      if (aid < bid) {
+        return -1;
+      } else if (aid > bid) {
+        return 1;
+      } else {
+        return 0;
+      }
+    });
+  }
+  let first = Stdlib_Option.map(Stdlib_Option.flatMap(argsDict["first"], Stdlib_JSON.Decode.float), prim => prim | 0);
+  let after = Stdlib_Option.flatMap(argsDict["after"], Stdlib_JSON.Decode.string);
+  let last = Stdlib_Option.map(Stdlib_Option.flatMap(argsDict["last"], Stdlib_JSON.Decode.float), prim => prim | 0);
+  let before = Stdlib_Option.flatMap(argsDict["before"], Stdlib_JSON.Decode.string);
+  let isBackward = Stdlib_Option.isSome(last);
+  let cursorField = Stdlib_Option.getOr(orderByField, "id");
+  let getCursorValue = item => Stdlib_Option.getOr(getFieldString(item, cursorField), getId(item));
+  let cursorBounded;
+  if (isBackward) {
+    if (before !== undefined) {
+      let cv = atob(before);
+      cursorBounded = sorted.filter(item => {
+        let v = getCursorValue(item);
+        if (isDesc) {
+          return v > cv;
+        } else {
+          return v < cv;
+        }
+      });
+    } else {
+      cursorBounded = sorted;
+    }
+  } else if (after !== undefined) {
+    let cv$1 = atob(after);
+    cursorBounded = sorted.filter(item => {
+      let v = getCursorValue(item);
+      if (isDesc) {
+        return v < cv$1;
+      } else {
+        return v > cv$1;
+      }
+    });
+  } else {
+    cursorBounded = sorted;
+  }
+  let pageSize = isBackward ? Stdlib_Option.getOr(last, 50) : Stdlib_Option.getOr(first, 50);
+  let take = pageSize + 1 | 0;
+  let match;
+  if (isBackward) {
+    let len = cursorBounded.length;
+    let startIdx = len > take ? len - take | 0 : 0;
+    let arr = cursorBounded.slice(startIdx, len);
+    let hasMore = arr.length > pageSize;
+    let result = hasMore ? arr.slice(1, arr.length) : arr;
+    match = [
+      result,
+      hasMore
+    ];
+  } else {
+    let arr$1 = cursorBounded.slice(0, take);
+    let hasMore$1 = arr$1.length > pageSize;
+    match = [
+      arr$1.slice(0, pageSize),
+      hasMore$1
+    ];
+  }
+  let hasMore$2 = match[1];
+  return buildConnection(match[0], !isBackward && hasMore$2, isBackward && hasMore$2, getCursorValue);
+}
+
+let defaultListPageSize = 50;
+
+export {
+  encodeCursor,
+  decodeCursor,
+  defaultListPageSize,
+  getId,
+  getFieldString,
+  buildConnection,
+  run,
+}
+/* No side effect */