envio 3.11.0 → 3.12.0

package/src/db/CheckpointSequence.res

@@ -0,0 +1,109 @@
+// How checkpoint ids are handed out. A schema with a cross-chain entity has
+// rows any chain's reorg can reach, so its checkpoints have to be comparable
+// across chains and come from one shared counter. Without one, no chain can
+// touch another's rows, and each gets a counter of its own — which is what lets
+// a rollback, a prune or a resume name one chain without saying anything about
+// the others.
+type t =
+  | SharedAcrossChains
+  | PerChain
+
+let fromEntities = (entities: array<Internal.entityConfig>) =>
+  entities->Array.some(entityConfig => entityConfig.crossChain) ? SharedAcrossChains : PerChain
+
+// Where a chain stands: under one shared counter that is wherever the counter
+// got to, whichever chain moved it last.
+let position = (sequence: t, frontier: Frontier.t, ~chainId) =>
+  switch sequence {
+  | SharedAcrossChains => frontier->Frontier.max
+  | PerChain => frontier->Frontier.get(chainId)
+  }
+
+// The committed (or processed) id a scope's rows compare against. A chain scope
+// reads its own. A cross-chain scope spans every chain: under one shared
+// sequence the highest id is exactly how far the scope has got, while per-chain
+// ids aren't comparable across chains, so only the lowest is an id every chain
+// has passed.
+let forScope = (sequence: t, frontier: Frontier.t, ~scope: Internal.chainScope) =>
+  switch scope {
+  | Chain(chainId) => frontier->Frontier.get(chainId)
+  | CrossChain =>
+    switch sequence {
+    | SharedAcrossChains => frontier->Frontier.max
+    | PerChain => frontier->Frontier.min
+    }
+  }
+
+// The diff id a scope's rows carry after a rollback, taken from the frontier the
+// rollback stamped them with. A per-chain rollback names only the chains it
+// moved: a sibling it left alone has no diff row, and so no id to compare
+// against.
+let findForScope = (sequence: t, frontier: Frontier.t, ~scope: Internal.chainScope): option<
+  Internal.checkpointId,
+> =>
+  switch scope {
+  | Chain(chainId) => frontier->Frontier.find(chainId)
+  | CrossChain => Some(sequence->forScope(frontier, ~scope))
+  }
+
+// Hands out the ids of one batch, starting from where the frontier left each
+// chain. Under `SharedAcrossChains` the ids come from a single run of the counter, so they
+// interleave across chains in allocation order; under `PerChain` each chain
+// continues its own.
+type cursor = {sequence: t, frontier: Frontier.t}
+
+let cursor = (sequence: t, ~frontier: Frontier.t) => {sequence, frontier: frontier->Frontier.copy}
+
+let next = (cursor, ~chainId): Internal.checkpointId => {
+  let checkpointId = cursor.sequence->position(cursor.frontier, ~chainId)->BigInt.add(1n)
+  cursor.frontier->Frontier.set(chainId, checkpointId)
+  checkpointId
+}
+
+// The checkpoint id each chain's rows are compared against in a query,
+// together with the sequence that decides how the comparison is rendered.
+type checkpointBoundsByChain = {sequence: t, byChain: Frontier.t}
+
+// The pieces a query splices in to read its bound as `checkpointId`.
+type sql = {
+  join: string,
+  using: string,
+  usingMatch: string,
+  checkpointId: string,
+}
+
+// The chain ids are cast to the widest integer type rather than the column's
+// own: nothing indexes the join, so the values only have to compare.
+let relation = `unnest($1::${(Postgres.BigInt :> string)}[],$2::${(Postgres.BigInt :> string)}[]) AS envio_bounds(chain_id, checkpoint_id)`
+
+let sql = (
+  bounds: checkpointBoundsByChain,
+  ~chainIdColumn: option<string>,
+  ~tableRef: string,
+): sql =>
+  switch (bounds.sequence, chainIdColumn) {
+  | (SharedAcrossChains, _) => {join: "", using: "", usingMatch: "", checkpointId: "$1"}
+  | (PerChain, Some(column)) =>
+    let chainMatch = `envio_bounds.chain_id = ${tableRef}."${column}"`
+    {
+      join: ` JOIN ${relation} ON ${chainMatch}`,
+      using: ` USING ${relation}`,
+      usingMatch: ` AND ${chainMatch}`,
+      checkpointId: "envio_bounds.checkpoint_id",
+    }
+  | (PerChain, None) =>
+    JsError.throwWithMessage(
+      "Internal error: per-chain checkpoint bounds can't bound a table with no chain-id column. Only a schema whose entities are all per-chain has them.",
+    )
+  }
+
+// Bound in the order `sql` reads them: under one shared sequence the lowest of
+// the ids as `$1` (every chain is held to it), otherwise the chains and their
+// own ids as the two parallel arrays the relation unnests.
+let params = (bounds: checkpointBoundsByChain): unknown =>
+  switch bounds.sequence {
+  | SharedAcrossChains =>
+    [bounds.byChain->Frontier.min->BigInt.toString]->(Utils.magic: array<string> => unknown)
+  | PerChain =>
+    bounds.byChain->Frontier.unnestParams->(Utils.magic: Frontier.unnestParams => unknown)
+  }

package/src/db/CheckpointSequence.res.mjs

@@ -0,0 +1,99 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Frontier from "./Frontier.res.mjs";
+import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
+
+function fromEntities(entities) {
+  if (entities.some(entityConfig => entityConfig.crossChain)) {
+    return "SharedAcrossChains";
+  } else {
+    return "PerChain";
+  }
+}
+
+function position(sequence, frontier, chainId) {
+  if (sequence === "SharedAcrossChains") {
+    return Frontier.max(frontier);
+  } else {
+    return Frontier.get(frontier, chainId);
+  }
+}
+
+function forScope(sequence, frontier, scope) {
+  if (scope === "crossChain") {
+    if (sequence === "SharedAcrossChains") {
+      return Frontier.max(frontier);
+    } else {
+      return Frontier.min(frontier);
+    }
+  } else {
+    return Frontier.get(frontier, scope);
+  }
+}
+
+function findForScope(sequence, frontier, scope) {
+  if (scope === "crossChain") {
+    return forScope(sequence, frontier, scope);
+  } else {
+    return Frontier.find(frontier, scope);
+  }
+}
+
+function cursor(sequence, frontier) {
+  return {
+    sequence: sequence,
+    frontier: Frontier.copy(frontier)
+  };
+}
+
+function next(cursor, chainId) {
+  let checkpointId = position(cursor.sequence, cursor.frontier, chainId) + 1n;
+  Frontier.set(cursor.frontier, chainId, checkpointId);
+  return checkpointId;
+}
+
+let relation = `unnest($1::` + "BIGINT" + `[],$2::` + "BIGINT" + `[]) AS envio_bounds(chain_id, checkpoint_id)`;
+
+function sql(bounds, chainIdColumn, tableRef) {
+  let match = bounds.sequence;
+  if (match === "SharedAcrossChains") {
+    return {
+      join: "",
+      using: "",
+      usingMatch: "",
+      checkpointId: "$1"
+    };
+  }
+  if (chainIdColumn === undefined) {
+    return Stdlib_JsError.throwWithMessage("Internal error: per-chain checkpoint bounds can't bound a table with no chain-id column. Only a schema whose entities are all per-chain has them.");
+  }
+  let chainMatch = `envio_bounds.chain_id = ` + tableRef + `."` + chainIdColumn + `"`;
+  return {
+    join: ` JOIN ` + relation + ` ON ` + chainMatch,
+    using: ` USING ` + relation,
+    usingMatch: ` AND ` + chainMatch,
+    checkpointId: "envio_bounds.checkpoint_id"
+  };
+}
+
+function params(bounds) {
+  let match = bounds.sequence;
+  if (match === "SharedAcrossChains") {
+    return [Frontier.min(bounds.byChain).toString()];
+  } else {
+    return Frontier.unnestParams(bounds.byChain);
+  }
+}
+
+export {
+  fromEntities,
+  position,
+  forScope,
+  findForScope,
+  cursor,
+  next,
+  relation,
+  sql,
+  params,
+}
+/* Frontier Not a pure module */

package/src/db/EntityHistory.res

@@ -105,12 +105,12 @@ let makePruneStaleEntityHistoryQuery = (
   ~entityIndex,
   ~pgSchema,
   ~chainIdColumn,
-  ~safeCheckpoints: CheckpointBounds.t,
+  ~safeCheckpoints: CheckpointSequence.checkpointBoundsByChain,
 ) => {
   let historyTableRef = `"${pgSchema}"."${historyTableName(~entityName, ~entityIndex)}"`
   let keyColumns = makeKeyColumns(~chainIdColumn)
   let anchorKeys = keyColumns->Array.map(column => `t.${column}`)->Array.joinUnsafe(", ")
-  let bounds = safeCheckpoints->CheckpointBounds.sql(~chainIdColumn, ~tableRef="t")
+  let bounds = safeCheckpoints->CheckpointSequence.sql(~chainIdColumn, ~tableRef="t")
 
   // Whether a key still has a row above the safe checkpoint is an aggregate
   // over the same groups as the anchor, so it's computed in the one pass
@@ -151,7 +151,7 @@ let pruneStaleEntityHistory = (
       ~chainIdColumn,
       ~safeCheckpoints,
     ),
-    safeCheckpoints->CheckpointBounds.params,
+    safeCheckpoints->CheckpointSequence.params,
   )
 
 // If an entity doesn't have a history before the update
@@ -224,11 +224,12 @@ let rollback = (
   ~floors: RollbackFloors.t,
 ) => {
   let historyTableRef = `"${pgSchema}"."${historyTableName(~entityName, ~entityIndex)}"`
-  let bounds = floors.floors->CheckpointBounds.sql(~chainIdColumn, ~tableRef=historyTableRef)
+  let bounds =
+    floors.checkpointBounds->CheckpointSequence.sql(~chainIdColumn, ~tableRef=historyTableRef)
   sql
   ->Postgres.preparedUnsafe(
     `DELETE FROM ${historyTableRef}${bounds.using} WHERE "${checkpointIdFieldName}" > ${bounds.checkpointId}${bounds.usingMatch};`,
-    floors.floors->CheckpointBounds.params,
+    floors.checkpointBounds->CheckpointSequence.params,
   )
   ->Utils.Promise.ignoreValue
 }

package/src/db/EntityHistory.res.mjs

@@ -3,9 +3,9 @@
 import * as Table from "./Table.res.mjs";
 import * as ChainId from "../ChainId.res.mjs";
 import * as Stdlib_BigInt from "@rescript/runtime/lib/es6/Stdlib_BigInt.js";
-import * as CheckpointBounds from "./CheckpointBounds.res.mjs";
 import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
 import * as S$RescriptSchema from "rescript-schema/src/S.res.mjs";
+import * as CheckpointSequence from "./CheckpointSequence.res.mjs";
 
 let variants = [
   "SET",
@@ -90,7 +90,7 @@ function makePruneStaleEntityHistoryQuery(entityName, entityIndex, pgSchema, cha
   let historyTableRef = `"` + pgSchema + `"."` + historyTableName(entityName, entityIndex) + `"`;
   let keyColumns = makeKeyColumns(chainIdColumn);
   let anchorKeys = keyColumns.map(column => `t.` + column).join(", ");
-  let bounds = CheckpointBounds.sql(safeCheckpoints, chainIdColumn, "t");
+  let bounds = CheckpointSequence.sql(safeCheckpoints, chainIdColumn, "t");
   return `WITH anchors AS (
   SELECT ` + anchorKeys + `,
     MAX(t.` + checkpointIdFieldName + `) FILTER (WHERE t.` + checkpointIdFieldName + ` <= ` + bounds.checkpointId + `) AS keep_checkpoint_id,
@@ -107,7 +107,7 @@ WHERE ` + makeKeyMatch(chainIdColumn, "d", "a") + `
 }
 
 function pruneStaleEntityHistory(sql, entityName, entityIndex, pgSchema, chainIdColumn, safeCheckpoints) {
-  return sql.unsafe(makePruneStaleEntityHistoryQuery(entityName, entityIndex, pgSchema, chainIdColumn, safeCheckpoints), CheckpointBounds.params(safeCheckpoints), {prepare: true});
+  return sql.unsafe(makePruneStaleEntityHistoryQuery(entityName, entityIndex, pgSchema, chainIdColumn, safeCheckpoints), CheckpointSequence.params(safeCheckpoints), {prepare: true});
 }
 
 function makeBackfillHistoryQuery(pgSchema, entityName, entityIndex, idPgType, chainIdColumn, chainId) {
@@ -137,8 +137,8 @@ function backfillHistory(sql, pgSchema, table, entityIndex, chainId, ids) {
 
 function rollback(sql, pgSchema, entityName, entityIndex, chainIdColumn, floors) {
   let historyTableRef = `"` + pgSchema + `"."` + historyTableName(entityName, entityIndex) + `"`;
-  let bounds = CheckpointBounds.sql(floors.floors, chainIdColumn, historyTableRef);
-  return sql.unsafe(`DELETE FROM ` + historyTableRef + bounds.using + ` WHERE "` + checkpointIdFieldName + `" > ` + bounds.checkpointId + bounds.usingMatch + `;`, CheckpointBounds.params(floors.floors), {prepare: true});
+  let bounds = CheckpointSequence.sql(floors.checkpointBounds, chainIdColumn, historyTableRef);
+  return sql.unsafe(`DELETE FROM ` + historyTableRef + bounds.using + ` WHERE "` + checkpointIdFieldName + `" > ` + bounds.checkpointId + bounds.usingMatch + `;`, CheckpointSequence.params(floors.checkpointBounds), {prepare: true});
 }
 
 let checkpointIdFieldType = "UInt64";

package/src/db/Frontier.res

@@ -0,0 +1,86 @@
+// Where each chain stands in its checkpoint sequence.
+type t = dict<Internal.checkpointId>
+
+let empty = (): t => Dict.make()
+
+let fromEntries = (entries: array<(ChainId.t, Internal.checkpointId)>): t => {
+  let frontier = Dict.make()
+  entries->Array.forEach(((chainId, checkpointId)) =>
+    frontier->ChainId.Dict.set(chainId, checkpointId)
+  )
+  frontier
+}
+
+let copy = (frontier: t): t => frontier->Dict.copy
+
+// A chain the frontier doesn't name has committed nothing yet, which is what
+// the initial checkpoint id means.
+let get = (frontier: t, chainId): Internal.checkpointId =>
+  switch frontier->ChainId.Dict.dangerouslyGetNonOption(chainId) {
+  | Some(checkpointId) => checkpointId
+  | None => Internal.initialCheckpointId
+  }
+
+// Whether the frontier names the chain at all, as opposed to `get`'s reading of
+// an absent chain as the initial id. A rollback frontier names only the chains
+// it moved, and "no id" is not the same answer as "id zero" there.
+let find = (frontier: t, chainId): option<Internal.checkpointId> =>
+  frontier->ChainId.Dict.dangerouslyGetNonOption(chainId)
+
+let set = (frontier: t, chainId, checkpointId) => frontier->ChainId.Dict.set(chainId, checkpointId)
+
+let entries = (frontier: t): array<(ChainId.t, Internal.checkpointId)> =>
+  frontier
+  ->Dict.toArray
+  ->Array.map(((key, checkpointId)) => (key->ChainId.normalizeOrThrow, checkpointId))
+
+let chainIds = (frontier: t): array<ChainId.t> =>
+  frontier->Dict.keysToArray->Array.map(ChainId.normalizeOrThrow)
+
+// The two parallel arrays an `unnest($1, $2) AS ...(chain_id, checkpoint_id)`
+// relation reads positionally.
+type unnestParams = (array<ChainId.t>, array<string>)
+
+let unnestParams = (frontier: t): unnestParams => {
+  let chainIds = []
+  let checkpointIds = []
+  frontier->Utils.Dict.forEachWithKey((checkpointId, key) => {
+    chainIds->Array.push(key->ChainId.normalizeOrThrow)
+    checkpointIds->Array.push(checkpointId->BigInt.toString)
+  })
+  (chainIds, checkpointIds)
+}
+
+%%private(
+  let fold = (frontier: t, pick) =>
+    frontier
+    ->Dict.valuesToArray
+    ->Array.reduce(None, (acc, checkpointId) =>
+      switch acc {
+      | None => Some(checkpointId)
+      | Some(picked) => Some(pick(picked, checkpointId))
+      }
+    )
+)
+
+// A frontier naming no chain has committed nothing anywhere.
+let max = (frontier: t) =>
+  frontier->fold(Pervasives.max)->Option.getOr(Internal.initialCheckpointId)
+let min = (frontier: t) =>
+  frontier->fold(Pervasives.min)->Option.getOr(Internal.initialCheckpointId)
+
+let mergeMin = (a: t, b: t): t => Utils.Dict.mergeWith(a, b, Pervasives.min)
+let mergeMax = (a: t, b: t): t => Utils.Dict.mergeWith(a, b, Pervasives.max)
+
+let equals = (a: t, b: t) => {
+  let same = (a: t, b: t) =>
+    a
+    ->Dict.toArray
+    ->Array.every(((key, checkpointId)) =>
+      switch b->Utils.Dict.dangerouslyGetNonOption(key) {
+      | Some(other) => other == checkpointId
+      | None => checkpointId == Internal.initialCheckpointId
+      }
+    )
+  same(a, b) && same(b, a)
+}

package/src/db/Frontier.res.mjs

@@ -0,0 +1,126 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Utils from "../Utils.res.mjs";
+import * as ChainId from "../ChainId.res.mjs";
+import * as Internal from "../Internal.res.mjs";
+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 Primitive_bigint from "@rescript/runtime/lib/es6/Primitive_bigint.js";
+
+function empty() {
+  return {};
+}
+
+function fromEntries(entries) {
+  let frontier = {};
+  entries.forEach(param => {
+    frontier[param[0]] = param[1];
+  });
+  return frontier;
+}
+
+function copy(frontier) {
+  return Object.assign({}, frontier);
+}
+
+function get(frontier, chainId) {
+  let checkpointId = frontier[chainId];
+  if (checkpointId !== undefined) {
+    return checkpointId;
+  } else {
+    return Internal.initialCheckpointId;
+  }
+}
+
+function find(frontier, chainId) {
+  return frontier[chainId];
+}
+
+function set(frontier, chainId, checkpointId) {
+  frontier[chainId] = checkpointId;
+}
+
+function entries(frontier) {
+  return Object.entries(frontier).map(param => [
+    ChainId.normalizeOrThrow(param[0]),
+    param[1]
+  ]);
+}
+
+function chainIds(frontier) {
+  return Object.keys(frontier).map(ChainId.normalizeOrThrow);
+}
+
+function unnestParams(frontier) {
+  let chainIds = [];
+  let checkpointIds = [];
+  Utils.Dict.forEachWithKey(frontier, (checkpointId, key) => {
+    chainIds.push(ChainId.normalizeOrThrow(key));
+    checkpointIds.push(checkpointId.toString());
+  });
+  return [
+    chainIds,
+    checkpointIds
+  ];
+}
+
+function fold(frontier, pick) {
+  return Stdlib_Array.reduce(Object.values(frontier), undefined, (acc, checkpointId) => {
+    if (acc !== undefined) {
+      return pick(acc, checkpointId);
+    } else {
+      return checkpointId;
+    }
+  });
+}
+
+function max(frontier) {
+  return Stdlib_Option.getOr(fold(frontier, Primitive_bigint.max), Internal.initialCheckpointId);
+}
+
+function min(frontier) {
+  return Stdlib_Option.getOr(fold(frontier, Primitive_bigint.min), Internal.initialCheckpointId);
+}
+
+function mergeMin(a, b) {
+  return Utils.Dict.mergeWith(a, b, Primitive_bigint.min);
+}
+
+function mergeMax(a, b) {
+  return Utils.Dict.mergeWith(a, b, Primitive_bigint.max);
+}
+
+function equals(a, b) {
+  let same = (a, b) => Object.entries(a).every(param => {
+    let checkpointId = param[1];
+    let other = b[param[0]];
+    if (other !== undefined) {
+      return other === checkpointId;
+    } else {
+      return checkpointId === Internal.initialCheckpointId;
+    }
+  });
+  if (same(a, b)) {
+    return same(b, a);
+  } else {
+    return false;
+  }
+}
+
+export {
+  empty,
+  fromEntries,
+  copy,
+  get,
+  find,
+  set,
+  entries,
+  chainIds,
+  unnestParams,
+  max,
+  min,
+  mergeMin,
+  mergeMax,
+  equals,
+}
+/* Utils Not a pure module */