envio 3.15.0-subgraph → 3.16.0

package/src/EffectCacheLookup.res

@@ -1,98 +0,0 @@
-// A cached effect's stored outputs, read straight from storage. For the
-// subgraph register pass: it runs at fetch time, outside any handler context,
-// so its contract calls can't go through the effect machinery, and after
-// `envio start -r` (which keeps the subgraph call caches) it would otherwise ask
-// the RPC again for every call it makes.
-//
-// Only a chain-scoped effect's table that held rows when the run started is
-// read: rows this run writes are already in the register pass's own cache.
-// The calls of one turn share one storage query.
-
-type batch = {
-  effect: Internal.effect,
-  table: Table.table,
-  keys: array<string>,
-  resolvers: array<option<Internal.effectOutput> => unit>,
-}
-
-let startupTables: ref<option<Utils.Set.t<string>>> = ref(None)
-
-// Reset between test indexers, which each bring their own storage.
-let resetStartupTables = () => startupTables := None
-
-let tablesWithRowsAtStart = (cache: dict<Persistence.effectCacheRecord>) =>
-  switch startupTables.contents {
-  | Some(tables) => tables
-  | None =>
-    let tables = Utils.Set.make()
-    cache
-    ->Dict.valuesToArray
-    ->Array.forEach(record =>
-      if record.count > 0 {
-        tables->Utils.Set.add(record.tableName)->ignore
-      }
-    )
-    startupTables := Some(tables)
-    tables
-  }
-
-let pending: dict<batch> = Dict.make()
-
-let load = async (storage: Persistence.storage, batch: batch) => {
-  let rows =
-    (await storage.loadOrThrow(~table=batch.table, ~filter=EntityFilter.byIds(batch.keys)))->(
-      Utils.magic: array<unknown> => array<Internal.effectCacheItem>
-    )
-  let byId = Dict.make()
-  rows->Array.forEach(row =>
-    switch row.output->S.parseOrThrow(batch.effect.storageMeta.outputSchema) {
-    | output => byId->Dict.set(row.id, output)
-    | exception _ => ()
-    }
-  )
-  batch.keys->Array.map(key => byId->Utils.Dict.dangerouslyGetNonOption(key))
-}
-
-let flush = async (storage: Persistence.storage, tableName) => {
-  let batch = pending->Dict.getUnsafe(tableName)
-  pending->Utils.Dict.deleteInPlace(tableName)
-  let outputs = switch await load(storage, batch) {
-  | outputs => outputs
-  | exception _ => batch.keys->Array.map(_ => None)
-  }
-  batch.resolvers->Array.forEachWithIndex((resolve, idx) => resolve(outputs->Array.getUnsafe(idx)))
-}
-
-let cached = (effect: Internal.effect, chainId: int, input: Internal.effectInput): promise<
-  option<Internal.effectOutput>,
-> =>
-  switch (
-    effect.crossChain,
-    EnvioGlobal.value.persistence->(Utils.magic: option<unknown> => option<Persistence.t>),
-  ) {
-  | (Some(false), Some({storageStatus: Ready({cache}), storage})) =>
-    let table = Internal.makeCacheTable(
-      ~effectName=effect.name,
-      ~scope=Chain(chainId->ChainId.fromInt),
-    )
-    if cache->tablesWithRowsAtStart->Utils.Set.has(table.tableName) {
-      let key =
-        input
-        ->S.reverseConvertOrThrow(effect.input)
-        ->Utils.Hash.makeOrThrow
-        ->Utils.Hash.boundCacheKey
-      Promise.make((resolve, _) => {
-        switch pending->Utils.Dict.dangerouslyGetNonOption(table.tableName) {
-        | Some(batch) =>
-          batch.keys->Array.push(key)
-          batch.resolvers->Array.push(resolve)
-        | None =>
-          pending->Dict.set(table.tableName, {effect, table, keys: [key], resolvers: [resolve]})
-          let _ = setTimeout(() => storage->flush(table.tableName)->ignore, 0)
-        }
-      })
-    } else {
-      Promise.resolve(None)
-    }
-  | _ => Promise.resolve(None)
-  }

package/src/EffectCacheLookup.res.mjs

@@ -1,116 +0,0 @@
-// Generated by ReScript, PLEASE EDIT WITH CARE
-
-import * as Utils from "./Utils.res.mjs";
-import * as Internal from "./Internal.res.mjs";
-import * as EnvioGlobal from "./EnvioGlobal.res.mjs";
-import * as EntityFilter from "./db/EntityFilter.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";
-
-let startupTables = {
-  contents: undefined
-};
-
-function resetStartupTables() {
-  startupTables.contents = undefined;
-}
-
-function tablesWithRowsAtStart(cache) {
-  let tables = startupTables.contents;
-  if (tables !== undefined) {
-    return Primitive_option.valFromOption(tables);
-  }
-  let tables$1 = new Set();
-  Object.values(cache).forEach(record => {
-    if (record.count > 0) {
-      tables$1.add(record.tableName);
-      return;
-    }
-  });
-  startupTables.contents = Primitive_option.some(tables$1);
-  return tables$1;
-}
-
-let pending = {};
-
-async function load(storage, batch) {
-  let rows = await storage.loadOrThrow(EntityFilter.byIds(batch.keys), batch.table);
-  let byId = {};
-  rows.forEach(row => {
-    let output;
-    try {
-      output = S$RescriptSchema.parseOrThrow(row.output, batch.effect.storageMeta.outputSchema);
-    } catch (exn) {
-      return;
-    }
-    byId[row.id] = output;
-  });
-  return batch.keys.map(key => byId[key]);
-}
-
-async function flush(storage, tableName) {
-  let batch = pending[tableName];
-  Utils.Dict.deleteInPlace(pending, tableName);
-  let outputs;
-  try {
-    outputs = await load(storage, batch);
-  } catch (exn) {
-    outputs = batch.keys.map(param => {});
-  }
-  batch.resolvers.forEach((resolve, idx) => resolve(outputs[idx]));
-}
-
-function cached(effect, chainId, input) {
-  let match = effect.crossChain;
-  let match$1 = EnvioGlobal.value.persistence;
-  if (match === undefined) {
-    return Promise.resolve(undefined);
-  }
-  if (match) {
-    return Promise.resolve(undefined);
-  }
-  if (match$1 === undefined) {
-    return Promise.resolve(undefined);
-  }
-  let match$2 = match$1.storageStatus;
-  if (typeof match$2 !== "object") {
-    return Promise.resolve(undefined);
-  }
-  if (match$2.TAG === "Initializing") {
-    return Promise.resolve(undefined);
-  }
-  let storage = match$1.storage;
-  let table = Internal.makeCacheTable(effect.name, chainId);
-  if (!tablesWithRowsAtStart(match$2._0.cache).has(table.tableName)) {
-    return Promise.resolve(undefined);
-  }
-  let key = Utils.Hash.boundCacheKey(Utils.Hash.makeOrThrow(S$RescriptSchema.reverseConvertOrThrow(input, effect.input)));
-  return new Promise((resolve, param) => {
-    let batch = pending[table.tableName];
-    if (batch !== undefined) {
-      batch.keys.push(key);
-      batch.resolvers.push(resolve);
-    } else {
-      pending[table.tableName] = {
-        effect: effect,
-        table: table,
-        keys: [key],
-        resolvers: [resolve]
-      };
-      setTimeout(() => {
-        flush(storage, table.tableName);
-      }, 0);
-    }
-  });
-}
-
-export {
-  startupTables,
-  resetStartupTables,
-  tablesWithRowsAtStart,
-  pending,
-  load,
-  flush,
-  cached,
-}
-/* Utils Not a pure module */

package/src/PgWriting.res

@@ -1,36 +0,0 @@
-let columns = (fields: array<Table.field>, ~kinds: array<Staging.kind>): array<Staging.column> =>
-  fields->Array.mapWithIndex((field, index) => {
-    Staging.name: field->Table.getPgDbFieldName,
-    kind: kinds->Array.getUnsafe(index),
-    isNullable: field.isNullable,
-  })
-
-// Lays a batch into the arena, column by column. The values are the ones the
-// table's own schema produced — a bigint as its digits, a date as its text, a
-// boolean as the number the statement's cast expects — so nothing here has to
-// know what a column means, only where its values go.
-//
-// The rows of a column are written in order because a variable-width slot's row
-// starts where the row before it ended.
-let stage = (
-  arena,
-  ~table,
-  ~columns: array<Staging.column>,
-  ~values: array<array<unknown>>,
-  ~rows,
-) => {
-  let stage = arena->Staging.begin(~table, ~rows, ~columns)
-  try {
-    for column in 0 to columns->Array.length - 1 {
-      let values = values->Array.getUnsafe(column)
-      for row in 0 to rows - 1 {
-        stage->Staging.writeValue(~column, ~row, values->Array.getUnsafe(row))
-      }
-    }
-    stage->Staging.commit
-  } catch {
-  | exn =>
-    stage->Staging.abort
-    throw(exn)
-  }
-}

package/src/PgWriting.res.mjs

@@ -1,34 +0,0 @@
-// Generated by ReScript, PLEASE EDIT WITH CARE
-
-import * as Table from "./db/Table.res.mjs";
-import * as Staging from "./Staging.res.mjs";
-
-function columns(fields, kinds) {
-  return fields.map((field, index) => ({
-    name: Table.getPgDbFieldName(field),
-    kind: kinds[index],
-    isNullable: field.isNullable
-  }));
-}
-
-function stage(arena, table, columns, values, rows) {
-  let stage$1 = Staging.begin(arena, table, rows, columns);
-  try {
-    for (let column = 0, column_finish = columns.length; column < column_finish; ++column) {
-      let values$1 = values[column];
-      for (let row = 0; row < rows; ++row) {
-        Staging.writeValue(stage$1, column, row, values$1[row]);
-      }
-    }
-    return Staging.commit(stage$1);
-  } catch (exn) {
-    Staging.abort(stage$1);
-    throw exn;
-  }
-}
-
-export {
-  columns,
-  stage,
-}
-/* Table Not a pure module */

package/src/PreloadLookahead.res

@@ -1,184 +0,0 @@
-// Preload runs a batch's handlers against the store as it was before the batch,
-// so a handler reading an entity an earlier event of the batch creates (a v3
-// pool's Mint after its PoolCreated) reads it as absent and makes none of the
-// contract calls after that read. The execute pass then asks them one event
-// at a time, a round trip each.
-//
-// So preload reads that find an entity absent are remembered per item, and once
-// execute creates that entity, the items that read it are preloaded again, as
-// long as they are within `window` items of the one executing. Preload only
-// warms the store and the effect cache, and every value it fetches is keyed by
-// its full input, so what execute computes is the same with or without it.
-//
-// Preload also sees what earlier items of the batch wrote in their own preload
-// (`overlay`): agent0's URIUpdated(n), the log right after the Registered(n)
-// that creates agent n, would otherwise find no agent and return before its
-// call, and preloading it again once agent n exists is too late — it executes
-// right after. Those writes are a guess at the store execute will see; they
-// are held here, never in the store, and only an item before the reader that
-// execute hasn't run yet is taken: once it has, the store is the answer.
-//
-// Preloading again costs the handler's CPU time once more, and an item whose
-// preloads have already spent `maxPreloadMs` (a v3 Mint computing 1.0001^tick
-// a step at a time) isn't preloaded again: its calls would land later than the
-// CPU it takes away from execute.
-
-type t = {
-  items: array<Internal.item>,
-  indexOf: Utils.Map.t<Internal.item, int>,
-  absentReaders: dict<array<int>>,
-  dirty: array<bool>,
-  // Milliseconds the item's preload rounds have run for, all runs together.
-  preloadMs: array<float>,
-  // By entity key, the writes items' preloads made: (item, entity or deleted).
-  overlay: dict<array<(int, option<Internal.entity>)>>,
-  window: int,
-  // The last item execute finished; reads and writes at or before it are history.
-  mutable executed: int,
-}
-
-let active: ref<option<t>> = ref(None)
-
-// Subgraph mappings make their contract calls in the middle of a handler, after
-// the reads, so a read that misses is the difference between preloading the
-// calls and not. Native handlers are left as they are.
-let start = (~items: array<Internal.item>) => {
-  let window = Env.subgraphPreloadLookahead
-  if Env.subgraphMode.contents && window > 0 {
-    let indexOf = Utils.Map.make()
-    items->Array.forEachWithIndex((item, idx) => indexOf->Utils.Map.set(item, idx)->ignore)
-    active :=
-      Some({
-        items,
-        indexOf,
-        absentReaders: Dict.make(),
-        dirty: Array.make(~length=items->Array.length, false),
-        preloadMs: Array.make(~length=items->Array.length, 0.),
-        overlay: Dict.make(),
-        window,
-        executed: -1,
-      })
-  } else {
-    active := None
-  }
-}
-
-let stop = () => active := None
-
-let maxPreloadMs = 20.
-
-let roundStarted = (~isPreload) =>
-  switch active.contents {
-  | Some(_) if isPreload => Performance.now()
-  | _ => 0.
-  }
-
-let roundEnded = (~item: Internal.item, ~startedAt) =>
-  if startedAt > 0. {
-    switch active.contents {
-    | None => ()
-    | Some(t) =>
-      switch t.indexOf->Utils.Map.get(item) {
-      | Some(idx) =>
-        t.preloadMs->Array.setUnsafe(
-          idx,
-          t.preloadMs->Array.getUnsafe(idx) +. startedAt->Performance.secondsSince *. 1000.,
-        )
-      | None => ()
-      }
-    }
-  }
-
-let entityKey = (~entityName, ~scope: Internal.chainScope, ~entityId) =>
-  switch scope {
-  | CrossChain => `${entityName}..${entityId}`
-  | Chain(chainId) => `${entityName}.${chainId->ChainId.toString}.${entityId}`
-  }
-
-let recordAbsent = (~item: Internal.item, ~entityName, ~scope, ~entityId) =>
-  switch active.contents {
-  | None => ()
-  | Some(t) =>
-    switch t.indexOf->Utils.Map.get(item) {
-    | Some(idx) if idx > t.executed =>
-      let key = entityKey(~entityName, ~scope, ~entityId)
-      switch t.absentReaders->Utils.Dict.dangerouslyGetNonOption(key) {
-      | Some(readers) => readers->Array.push(idx)
-      | None => t.absentReaders->Dict.set(key, [idx])
-      }
-    | _ => ()
-    }
-  }
-
-let onSet = (~entityName, ~scope, ~entityId) =>
-  switch active.contents {
-  | None => ()
-  | Some(t) =>
-    let key = entityKey(~entityName, ~scope, ~entityId)
-    switch t.absentReaders->Utils.Dict.dangerouslyGetNonOption(key) {
-    | None => ()
-    | Some(readers) =>
-      t.absentReaders->Utils.Dict.deleteInPlace(key)
-      readers->Array.forEach(idx =>
-        if idx > t.executed {
-          t.dirty->Array.setUnsafe(idx, true)
-        }
-      )
-    }
-  }
-
-let isActive = () => active.contents->Option.isSome
-
-let overlaySet = (~item: Internal.item, ~entityName, ~scope, ~entityId, ~entity) =>
-  switch active.contents {
-  | None => ()
-  | Some(t) =>
-    switch t.indexOf->Utils.Map.get(item) {
-    | Some(writer) =>
-      let key = entityKey(~entityName, ~scope, ~entityId)
-      let writes = switch t.overlay->Utils.Dict.dangerouslyGetNonOption(key) {
-      | Some(writes) => writes->Array.filter(((idx, _)) => idx !== writer)
-      | None => []
-      }
-      writes->Array.push((writer, entity))
-      t.overlay->Dict.set(key, writes)
-    | None => ()
-    }
-  }
-
-// `Some(entity or None for deleted)` when an item before the reader that execute
-// hasn't run yet wrote the entity in its preload: the latest such write.
-let overlayGet = (~item: Internal.item, ~entityName, ~scope, ~entityId) =>
-  switch active.contents {
-  | None => None
-  | Some(t) =>
-    switch (
-      t.indexOf->Utils.Map.get(item),
-      t.overlay->Utils.Dict.dangerouslyGetNonOption(entityKey(~entityName, ~scope, ~entityId)),
-    ) {
-    | (Some(reader), Some(writes)) =>
-      let found = ref(None)
-      let foundAt = ref(t.executed)
-      writes->Array.forEach(((writer, entity)) =>
-        if writer > foundAt.contents && writer < reader {
-          foundAt := writer
-          found := Some(entity)
-        }
-      )
-      found.contents
-    | _ => None
-    }
-  }
-
-// Called once execute has finished the item at `index`: the dirty items in the
-// window ahead of it are preloaded again against the store as it is now.
-let afterItem = (t: t, ~index, ~preload: (Internal.item, int) => unit) => {
-  t.executed = index
-  let last = Math.Int.min(t.items->Array.length - 1, index + t.window)
-  for idx in index + 1 to last {
-    if t.dirty->Array.getUnsafe(idx) && t.preloadMs->Array.getUnsafe(idx) < maxPreloadMs {
-      t.dirty->Array.setUnsafe(idx, false)
-      preload(t.items->Array.getUnsafe(idx), idx)
-    }
-  }
-}

package/src/PreloadLookahead.res.mjs

@@ -1,197 +0,0 @@
-// Generated by ReScript, PLEASE EDIT WITH CARE
-
-import * as Env from "./Env.res.mjs";
-import * as Utils from "./Utils.res.mjs";
-import * as ChainId from "./ChainId.res.mjs";
-import * as Performance from "./bindings/Performance.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_option from "@rescript/runtime/lib/es6/Primitive_option.js";
-
-let active = {
-  contents: undefined
-};
-
-function start(items) {
-  if (!(Env.subgraphMode.contents && Env.subgraphPreloadLookahead > 0)) {
-    active.contents = undefined;
-    return;
-  }
-  let indexOf = new Map();
-  items.forEach((item, idx) => {
-    indexOf.set(item, idx);
-  });
-  active.contents = {
-    items: items,
-    indexOf: indexOf,
-    absentReaders: {},
-    dirty: Stdlib_Array.make(items.length, false),
-    preloadMs: Stdlib_Array.make(items.length, 0),
-    overlay: {},
-    window: Env.subgraphPreloadLookahead,
-    executed: -1
-  };
-}
-
-function stop() {
-  active.contents = undefined;
-}
-
-function roundStarted(isPreload) {
-  let match = active.contents;
-  if (match !== undefined) {
-    if (isPreload) {
-      return Performance.now();
-    } else {
-      return 0;
-    }
-  } else {
-    return 0;
-  }
-}
-
-function roundEnded(item, startedAt) {
-  if (startedAt <= 0) {
-    return;
-  }
-  let t = active.contents;
-  if (t === undefined) {
-    return;
-  }
-  let idx = t.indexOf.get(item);
-  if (idx !== undefined) {
-    t.preloadMs[idx] = t.preloadMs[idx] + Performance.secondsSince(startedAt) * 1000;
-    return;
-  }
-}
-
-function entityKey(entityName, scope, entityId) {
-  if (scope === "crossChain") {
-    return entityName + `..` + entityId;
-  } else {
-    return entityName + `.` + ChainId.toString(scope) + `.` + entityId;
-  }
-}
-
-function recordAbsent(item, entityName, scope, entityId) {
-  let t = active.contents;
-  if (t === undefined) {
-    return;
-  }
-  let idx = t.indexOf.get(item);
-  if (idx === undefined) {
-    return;
-  }
-  if (idx <= t.executed) {
-    return;
-  }
-  let key = entityKey(entityName, scope, entityId);
-  let readers = t.absentReaders[key];
-  if (readers !== undefined) {
-    readers.push(idx);
-  } else {
-    t.absentReaders[key] = [idx];
-  }
-}
-
-function onSet(entityName, scope, entityId) {
-  let t = active.contents;
-  if (t === undefined) {
-    return;
-  }
-  let key = entityKey(entityName, scope, entityId);
-  let readers = t.absentReaders[key];
-  if (readers !== undefined) {
-    Utils.Dict.deleteInPlace(t.absentReaders, key);
-    readers.forEach(idx => {
-      if (idx > t.executed) {
-        t.dirty[idx] = true;
-        return;
-      }
-    });
-    return;
-  }
-}
-
-function isActive() {
-  return Stdlib_Option.isSome(active.contents);
-}
-
-function overlaySet(item, entityName, scope, entityId, entity) {
-  let t = active.contents;
-  if (t === undefined) {
-    return;
-  }
-  let writer = t.indexOf.get(item);
-  if (writer === undefined) {
-    return;
-  }
-  let key = entityKey(entityName, scope, entityId);
-  let writes = t.overlay[key];
-  let writes$1 = writes !== undefined ? writes.filter(param => param[0] !== writer) : [];
-  writes$1.push([
-    writer,
-    entity
-  ]);
-  t.overlay[key] = writes$1;
-}
-
-function overlayGet(item, entityName, scope, entityId) {
-  let t = active.contents;
-  if (t === undefined) {
-    return;
-  }
-  let match = t.indexOf.get(item);
-  let match$1 = t.overlay[entityKey(entityName, scope, entityId)];
-  if (match === undefined) {
-    return;
-  }
-  if (match$1 === undefined) {
-    return;
-  }
-  let found = {
-    contents: undefined
-  };
-  let foundAt = {
-    contents: t.executed
-  };
-  match$1.forEach(param => {
-    let writer = param[0];
-    if (writer > foundAt.contents && writer < match) {
-      foundAt.contents = writer;
-      found.contents = Primitive_option.some(param[1]);
-      return;
-    }
-  });
-  return found.contents;
-}
-
-function afterItem(t, index, preload) {
-  t.executed = index;
-  let last = Math.min(t.items.length - 1 | 0, index + t.window | 0);
-  for (let idx = index + 1 | 0; idx <= last; ++idx) {
-    if (t.dirty[idx] && t.preloadMs[idx] < 20) {
-      t.dirty[idx] = false;
-      preload(t.items[idx], idx);
-    }
-  }
-}
-
-let maxPreloadMs = 20;
-
-export {
-  active,
-  start,
-  stop,
-  maxPreloadMs,
-  roundStarted,
-  roundEnded,
-  entityKey,
-  recordAbsent,
-  onSet,
-  isActive,
-  overlaySet,
-  overlayGet,
-  afterItem,
-}
-/* Env Not a pure module */

package/src/SubgraphLog.res

@@ -1,19 +0,0 @@
-// Every line the subgraph runtime logs, and every line a mapping logs through
-// graph-ts (`uinfo`, `uwarn`, ...), as it is logged. A test indexer's own logger
-// is silent, so this is how a test reads them. Compiled to JavaScript so a test
-// can import it from an installed envio, where TypeScript isn't stripped.
-
-type listener = (string, string) => unit
-
-let listeners: array<listener> = []
-
-let onLog = (listener: listener) => {
-  listeners->Array.push(listener)
-  () =>
-    switch listeners->Array.indexOf(listener) {
-    | -1 => ()
-    | index => listeners->Array.splice(~start=index, ~remove=1, ~insert=[])
-    }
-}
-
-let notify = (level, message) => listeners->Array.forEach(listener => listener(level, message))