envio 3.13.0 → 3.14.0-subgraph

package/src/PgStorage.res.mjs

@@ -32,6 +32,7 @@ import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
 import * as Stdlib_Promise from "@rescript/runtime/lib/es6/Stdlib_Promise.js";
 import * as ContractMapping from "./ContractMapping.res.mjs";
 import * as IndexDefinition from "./db/IndexDefinition.res.mjs";
+import * as Stdlib_Nullable from "@rescript/runtime/lib/es6/Stdlib_Nullable.js";
 import * as Primitive_object from "@rescript/runtime/lib/es6/Primitive_object.js";
 import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
 import * as S$RescriptSchema from "rescript-schema/src/S.res.mjs";
@@ -244,12 +245,16 @@ function getEntityHistory(entityConfig) {
   return cache$1;
 }
 
+function makeCreatePartitionQuery(entityConfig, pgSchema, chainId) {
+  return `CREATE TABLE IF NOT EXISTS "` + pgSchema + `"."` + partitionTableName(entityConfig, chainId) + `" PARTITION OF "` + pgSchema + `"."` + entityConfig.table.tableName + `" FOR VALUES IN (` + ChainId.toString(chainId) + `);`;
+}
+
 function makeCreateEntityTableQueries(entityConfig, pgSchema, isNumericArrayAsText, chainIdModeOpt, chainIds) {
   let chainIdMode = chainIdModeOpt !== undefined ? chainIdModeOpt : "int32";
   let createTable = (table, partitionByColumn) => makeCreateTableQuery(table, pgSchema, isNumericArrayAsText, chainIdMode, partitionByColumn);
   let chainIdField = Table.getChainIdField(entityConfig.table);
   return (
-    chainIdField !== undefined ? [createTable(entityConfig.table, Table.getPgDbFieldName(chainIdField))].concat(chainIds.map(chainId => `CREATE TABLE IF NOT EXISTS "` + pgSchema + `"."` + partitionTableName(entityConfig, chainId) + `" PARTITION OF "` + pgSchema + `"."` + entityConfig.table.tableName + `" FOR VALUES IN (` + ChainId.toString(chainId) + `);`)) : [createTable(entityConfig.table, undefined)]
+    chainIdField !== undefined ? [createTable(entityConfig.table, Table.getPgDbFieldName(chainIdField))].concat(chainIds.map(chainId => makeCreatePartitionQuery(entityConfig, pgSchema, chainId))) : [createTable(entityConfig.table, undefined)]
   ).concat([createTable(getEntityHistory(entityConfig).table, undefined)]);
 }
 
@@ -444,6 +449,7 @@ SELECT * FROM unnest(` + match.arrayFieldTypes.map((arrayFieldType, idx) => `$`
 function makeInsertValuesSetQuery(pgSchema, table, itemSchema, itemsCount, chainIdModeOpt) {
   let chainIdMode = chainIdModeOpt !== undefined ? chainIdModeOpt : "int32";
   let match = Table.toSqlParams(table, itemSchema, pgSchema, chainIdMode);
+  let booleanArrayColumnIndexes = match.booleanArrayColumnIndexes;
   let quotedNonPrimaryFieldNames = match.quotedNonPrimaryFieldNames;
   let quotedFieldNames = match.quotedFieldNames;
   let primaryKeyFieldNames = Table.getPgPrimaryKeyFieldNames(table);
@@ -459,6 +465,9 @@ function makeInsertValuesSetQuery(pgSchema, table, itemSchema, itemsCount, chain
         placeholders = placeholders + ",";
       }
       placeholders = placeholders + (`$` + ((fieldIdx * itemsCount | 0) + idx | 0).toString());
+      if (booleanArrayColumnIndexes.includes(fieldIdx)) {
+        placeholders = placeholders + "::integer[]::boolean[]";
+      }
     }
     placeholders = placeholders + ")";
   }
@@ -473,6 +482,7 @@ VALUES` + placeholders + (
 function makeTableBatchSetQuery(pgSchema, table, itemSchema, chainIdModeOpt) {
   let chainIdMode = chainIdModeOpt !== undefined ? chainIdModeOpt : "int32";
   let match = Table.toSqlParams(table, itemSchema, pgSchema, chainIdMode);
+  let booleanArrayColumnIndexes = match.booleanArrayColumnIndexes;
   let byteaColumnIndexes = match.byteaColumnIndexes;
   let isRawEvents = table.tableName === InternalTable.RawEvents.table.tableName;
   let isHistoryUpdate = table.tableName.startsWith(EntityHistory.historyTablePrefix);
@@ -493,7 +503,18 @@ function makeTableBatchSetQuery(pgSchema, table, itemSchema, chainIdModeOpt) {
     return {
       query: makeInsertValuesSetQuery(pgSchema, table, itemSchema, 500, chainIdMode),
       convertOrThrow: S$RescriptSchema.compile(S$RescriptSchema.preprocess(S$RescriptSchema.unnest(itemSchema), param => ({
-        s: prim => prim.flat(1)
+        s: columns => {
+          booleanArrayColumnIndexes.forEach(index => {
+            columns[index] = columns[index].map(value => Stdlib_Nullable.map(value, flags => flags.map(flag => {
+              if (flag) {
+                return 1;
+              } else {
+                return 0;
+              }
+            })));
+          });
+          return columns.flat(1);
+        }
       })), "Output", "Input", "Sync", false),
       isInsertValues: true
     };
@@ -1234,7 +1255,6 @@ function make(sql, pgHost, pgSchema, pgPort, pgUser, pgDatabase, pgPassword, isH
     return {
       cleanRun: true,
       contractMapping: contractMapping,
-      envioInfo: envioInfo,
       cache: cache,
       chains: chainConfigs.map((chainConfig, idx) => ({
         id: chainConfig.id,
@@ -1500,7 +1520,58 @@ function make(sql, pgHost, pgSchema, pgPort, pgUser, pgDatabase, pgPassword, isH
       return Logging.errorWithExn(Utils.prettifyExn(exn$1), `Failed to dump cache.`);
     }
   };
-  let resumeInitialState = async (entities, chainIds, throwIfIncompatible) => {
+  let readStoredConfig = async () => {
+    let match = await Promise.all([
+      InternalTable.EnvioInfo.read(sql, pgSchema),
+      InternalTable.EnvioContracts.read(sql, pgSchema)
+    ]);
+    let contractNames = match[1];
+    let envioInfo = match[0];
+    if (envioInfo !== undefined) {
+      if (contractNames !== undefined) {
+        return {
+          envioInfo: envioInfo,
+          chains: await InternalTable.Chains.readStoredChains(sql, pgSchema),
+          contractMapping: ContractMapping.fromStoredNames(contractNames)
+        };
+      } else {
+        return {
+          envioInfo: undefined,
+          chains: [],
+          contractMapping: ContractMapping.empty
+        };
+      }
+    } else {
+      return {
+        envioInfo: undefined,
+        chains: [],
+        contractMapping: ContractMapping.empty
+      };
+    }
+  };
+  let addChain = async (chainConfig, entities, contractMapping) => {
+    let partitionQueries = entities.filter(entityConfig => {
+      if (entityConfig.storage.postgres) {
+        return Stdlib_Option.isSome(Table.getChainIdField(entityConfig.table));
+      } else {
+        return false;
+      }
+    }).map(entityConfig => makeCreatePartitionQuery(entityConfig, pgSchema, chainConfig.id));
+    let addressRows = ChainState.configStorageRows(chainConfig, ecosystem, contractMapping);
+    await sql.begin(async sql => {
+      for (let idx = 0, idx_finish = partitionQueries.length; idx < idx_finish; ++idx) {
+        await sql.unsafe(partitionQueries[idx]);
+      }
+      if (Utils.$$Array.notEmpty(addressRows)) {
+        await InternalTable.EnvioAddresses.insert(sql, pgSchema, addressRows, chainIdMode);
+      }
+      let query = InternalTable.Chains.makeInitialValuesQuery(pgSchema, [chainConfig]);
+      if (query !== undefined) {
+        return await sql.unsafe(query);
+      }
+    });
+  };
+  let resumeInitialState = async (entities, chainIds, contractMapping) => {
     let match = await Promise.all([
       restoreEffectCache(false),
       InternalTable.Chains.getInitialState(sql, pgSchema).then(rawInitialStates => {
@@ -1525,33 +1596,11 @@ function make(sql, pgHost, pgSchema, pgPort, pgUser, pgDatabase, pgPassword, isH
           ]))
         ];
       }),
-      sql.unsafe(InternalTable.Checkpoints.makeGetReorgCheckpointsQuery(pgSchema)),
-      Promise.all([
-        InternalTable.EnvioInfo.read(sql, pgSchema),
-        InternalTable.EnvioContracts.read(sql, pgSchema)
-      ]).then(param => {
-        let names = param[1];
-        let info = param[0];
-        if (info !== undefined && names !== undefined) {
-          return [
-            info,
-            ContractMapping.fromStoredNames(names)
-          ];
-        } else {
-          return [
-            undefined,
-            ContractMapping.empty
-          ];
-        }
-      })
+      sql.unsafe(InternalTable.Checkpoints.makeGetReorgCheckpointsQuery(pgSchema))
     ]);
-    let match$1 = match[3];
-    let storedContractMapping = match$1[1];
-    let storedEnvioInfo = match$1[0];
-    let match$2 = match[1];
-    let checkpointFrontier = match$2[1];
-    let chains = match$2[0];
-    throwIfIncompatible(storedEnvioInfo, storedContractMapping);
+    let match$1 = match[1];
+    let checkpointFrontier = match$1[1];
+    let chains = match$1[0];
     await reloadIndexCatalog();
     let reorgCheckpoints = match[2].map(raw => ({
       id: BigInt(raw.id),
@@ -1564,8 +1613,7 @@ function make(sql, pgHost, pgSchema, pgPort, pgUser, pgDatabase, pgPassword, isH
     }
     return {
       cleanRun: false,
-      contractMapping: storedContractMapping,
-      envioInfo: storedEnvioInfo,
+      contractMapping: contractMapping,
       cache: match[0],
       chains: chains,
       checkpointFrontier: checkpointFrontier,
@@ -1647,6 +1695,8 @@ function make(sql, pgHost, pgSchema, pgPort, pgUser, pgDatabase, pgPassword, isH
     name: storageName,
     isInitialized: isInitialized,
     initialize: initialize,
+    readStoredConfig: readStoredConfig,
+    addChain: addChain,
     resumeInitialState: resumeInitialState,
     loadOrThrow: loadOrThrow,
     ensureQueryIndexes: ensureQueryIndexes,
@@ -1720,6 +1770,7 @@ export {
   getRowSchema,
   entityHistoryCache,
   getEntityHistory,
+  makeCreatePartitionQuery,
   makeCreateEntityTableQueries,
   makeInitializeTransaction,
   makeLoadQuery,

package/src/ResumePlan.res

@@ -0,0 +1,172 @@
+// A chain as its storage holds it: what its `envio_chains` row keeps of its
+// config, and the addresses the config declared for it.
+type storedChain = {
+  id: ChainId.t,
+  ecosystem: string,
+  startBlock: int,
+  endBlock: option<int>,
+  maxReorgDepth: int,
+  configAddresses: array<AddressRows.row>,
+}
+
+// What a storage holds of the config it was built from. `envioInfo` is `None`
+// for a storage an older envio built, which kept no such record.
+type stored = {
+  envioInfo: option<JSON.t>,
+  chains: array<storedChain>,
+  contractMapping: ContractMapping.t,
+}
+
+type t =
+  | Resume
+  // Configured since the storage was built, and the only chain its
+  // `envio start --chain` process drives.
+  | AddChain(Config.chain)
+  | Incompatible(array<string>)
+
+// The part of a chain's config its storage keeps, shaped so a stored chain and
+// a configured one diff by the path config.yaml spells: `chains.137.endBlock`,
+// `chains.137.contracts.Token.addresses.0x…`.
+let chainEntry = (
+  ~startBlock: option<int>,
+  ~endBlock: option<int>,
+  ~maxReorgDepth: int,
+  ~addresses: array<(string, string)>,
+) => {
+  let contracts = Dict.make()
+  addresses->Array.forEach(((contractName, address)) =>
+    contracts->Utils.Dict.push(contractName, address)
+  )
+  let entry = dict{
+    "maxReorgDepth": JSON.Number(maxReorgDepth->Int.toFloat),
+    "contracts": JSON.Object(
+      contracts->Dict.mapValues(addresses => JSON.Object(
+        dict{
+          "addresses": JSON.Object(
+            addresses->Array.map(address => (address, JSON.Boolean(true)))->Dict.fromArray,
+          ),
+        },
+      )),
+    ),
+  }
+  startBlock->Option.forEach(startBlock =>
+    entry->Dict.set("startBlock", JSON.Number(startBlock->Int.toFloat))
+  )
+  endBlock->Option.forEach(endBlock =>
+    entry->Dict.set("endBlock", JSON.Number(endBlock->Int.toFloat))
+  )
+  JSON.Object(entry)
+}
+
+let withChains = (envioInfo: JSON.t, ~chains: array<(ChainId.t, JSON.t)>) =>
+  switch envioInfo {
+  | Object(fields) =>
+    let joined = fields->Dict.copy
+    joined->Dict.set(
+      "chains",
+      JSON.Object(
+        chains->Array.map(((chainId, entry)) => (chainId->ChainId.toString, entry))->Dict.fromArray,
+      ),
+    )
+    JSON.Object(joined)
+  | _ => envioInfo
+  }
+
+// `envioInfo` is the running config's, `chainConfigs` the chains this process
+// drives. An isolated process answers for `envioInfo` and its own chains only:
+// the ones it leaves out are checked, and added, by the processes that drive
+// them.
+let make = (
+  ~stored: stored,
+  ~envioInfo: JSON.t,
+  ~chainConfigs: array<Config.chain>,
+  ~contractMapping: ContractMapping.t,
+  ~lowercaseAddresses: bool,
+  ~isolated: bool,
+) =>
+  switch stored.envioInfo {
+  | None => Incompatible(["storage was initialized by an older envio version"])
+  | Some(storedEnvioInfo) =>
+    let storedChainOf = chainId => stored.chains->Array.find(chain => chain.id == chainId)
+    let added = switch (isolated, chainConfigs) {
+    | (true, [chain]) if storedChainOf(chain.id)->Option.isNone => Some(chain)
+    | _ => None
+    }
+    let storedChains = isolated
+      ? stored.chains->Array.filter(storedChain =>
+          chainConfigs->Array.some(chain => chain.id == storedChain.id)
+        )
+      : stored.chains
+    let storedEntries = storedChains->Array.map(storedChain => {
+      let addresses =
+        storedChain.configAddresses
+        ->AddressRows.render(~ecosystem=storedChain.ecosystem, ~shouldChecksum=!lowercaseAddresses)
+        ->Array.mapWithIndex((address, idx) => (
+          stored.contractMapping->ContractMapping.nameOfOrThrow(
+            (storedChain.configAddresses->Array.getUnsafe(idx)).contractId,
+          ),
+          address->Address.toString,
+        ))
+      (
+        storedChain.id,
+        chainEntry(
+          ~startBlock=Some(storedChain.startBlock),
+          ~endBlock=storedChain.endBlock,
+          ~maxReorgDepth=storedChain.maxReorgDepth,
+          ~addresses,
+        ),
+      )
+    })
+    let currentEntries = chainConfigs->Array.filterMap(chain =>
+      switch added {
+      | Some(added) if added.id == chain.id => None
+      | _ =>
+        Some((
+          chain.id,
+          chainEntry(
+            // `latest` is whatever it resolved to when the chain was first
+            // stored, so it matches any stored block.
+            ~startBlock=switch chain.startBlock {
+            | Block(startBlock) => Some(startBlock)
+            | Latest => storedChainOf(chain.id)->Option.map(storedChain => storedChain.startBlock)
+            },
+            ~endBlock=chain.endBlock,
+            ~maxReorgDepth=chain.maxReorgDepth,
+            ~addresses=chain.contracts->Array.flatMap(contract =>
+              contract.addresses->Array.map(address => (contract.name, address->Address.toString))
+            ),
+          ),
+        ))
+      }
+    )
+    let changedPaths = Config.diffPaths(
+      ~stored=storedEnvioInfo->withChains(~chains=storedEntries),
+      ~current=envioInfo->withChains(~chains=currentEntries),
+    )
+    let changedPaths =
+      stored.contractMapping->ContractMapping.isEqual(contractMapping)
+        ? changedPaths
+        : changedPaths->Array.concat(["contracts"])
+    switch (changedPaths, added) {
+    | ([], None) => Resume
+    | ([], Some(chain)) => AddChain(chain)
+    | (changedPaths, _) => Incompatible(changedPaths)
+    }
+  }
+
+let incompatibleMessage = (
+  changedPaths,
+  ~envioInfo: JSON.t,
+  ~resetCommand: string,
+  ~runCommand: option<string>,
+) => {
+  let hasClickhouse = switch envioInfo {
+  | Object(d) =>
+    switch d->Dict.get("storage") {
+    | Some(Object(s)) => s->Dict.get("clickhouse") == Some(Boolean(true))
+    | _ => false
+    }
+  | _ => false
+  }
+  Config.incompatibleMessage(changedPaths, ~resetCommand, ~runCommand, ~hasClickhouse)
+}

package/src/ResumePlan.res.mjs

@@ -0,0 +1,122 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Utils from "./Utils.res.mjs";
+import * as Config from "./Config.res.mjs";
+import * as ChainId from "./ChainId.res.mjs";
+import * as AddressRows from "./AddressRows.res.mjs";
+import * as Stdlib_Dict from "@rescript/runtime/lib/es6/Stdlib_Dict.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 ContractMapping from "./ContractMapping.res.mjs";
+import * as Primitive_object from "@rescript/runtime/lib/es6/Primitive_object.js";
+
+function chainEntry(startBlock, endBlock, maxReorgDepth, addresses) {
+  let contracts = {};
+  addresses.forEach(param => Utils.Dict.push(contracts, param[0], param[1]));
+  let entry = {
+    maxReorgDepth: maxReorgDepth,
+    contracts: Stdlib_Dict.mapValues(contracts, addresses => ({
+      addresses: Object.fromEntries(addresses.map(address => [
+        address,
+        true
+      ]))
+    }))
+  };
+  Stdlib_Option.forEach(startBlock, startBlock => {
+    entry["startBlock"] = startBlock;
+  });
+  Stdlib_Option.forEach(endBlock, endBlock => {
+    entry["endBlock"] = endBlock;
+  });
+  return entry;
+}
+
+function withChains(envioInfo, chains) {
+  if (typeof envioInfo !== "object" || envioInfo === null || Array.isArray(envioInfo)) {
+    return envioInfo;
+  }
+  let joined = Object.assign({}, envioInfo);
+  joined["chains"] = Object.fromEntries(chains.map(param => [
+    ChainId.toString(param[0]),
+    param[1]
+  ]));
+  return joined;
+}
+
+function make(stored, envioInfo, chainConfigs, contractMapping, lowercaseAddresses, isolated) {
+  let storedEnvioInfo = stored.envioInfo;
+  if (storedEnvioInfo === undefined) {
+    return {
+      TAG: "Incompatible",
+      _0: ["storage was initialized by an older envio version"]
+    };
+  }
+  let storedChainOf = chainId => stored.chains.find(chain => Primitive_object.equal(chain.id, chainId));
+  let added;
+  if (isolated && chainConfigs.length === 1) {
+    let chain = chainConfigs[0];
+    added = Stdlib_Option.isNone(storedChainOf(chain.id)) ? chain : undefined;
+  } else {
+    added = undefined;
+  }
+  let storedChains = isolated ? stored.chains.filter(storedChain => chainConfigs.some(chain => Primitive_object.equal(chain.id, storedChain.id))) : stored.chains;
+  let storedEntries = storedChains.map(storedChain => {
+    let addresses = AddressRows.render(storedChain.configAddresses, storedChain.ecosystem, !lowercaseAddresses).map((address, idx) => [
+      ContractMapping.nameOfOrThrow(stored.contractMapping, storedChain.configAddresses[idx].contractId),
+      address
+    ]);
+    return [
+      storedChain.id,
+      chainEntry(storedChain.startBlock, storedChain.endBlock, storedChain.maxReorgDepth, addresses)
+    ];
+  });
+  let currentEntries = Stdlib_Array.filterMap(chainConfigs, chain => {
+    if (added !== undefined && Primitive_object.equal(added.id, chain.id)) {
+      return;
+    }
+    let startBlock = chain.startBlock;
+    let tmp;
+    tmp = startBlock === "latest" ? Stdlib_Option.map(storedChainOf(chain.id), storedChain => storedChain.startBlock) : startBlock;
+    return [
+      chain.id,
+      chainEntry(tmp, chain.endBlock, chain.maxReorgDepth, chain.contracts.flatMap(contract => contract.addresses.map(address => [
+        contract.name,
+        address
+      ])))
+    ];
+  });
+  let changedPaths = Config.diffPaths(withChains(storedEnvioInfo, storedEntries), withChains(envioInfo, currentEntries));
+  let changedPaths$1 = ContractMapping.isEqual(stored.contractMapping, contractMapping) ? changedPaths : changedPaths.concat(["contracts"]);
+  if (changedPaths$1.length !== 0) {
+    return {
+      TAG: "Incompatible",
+      _0: changedPaths$1
+    };
+  } else if (added !== undefined) {
+    return {
+      TAG: "AddChain",
+      _0: added
+    };
+  } else {
+    return "Resume";
+  }
+}
+
+function incompatibleMessage(changedPaths, envioInfo, resetCommand, runCommand) {
+  let hasClickhouse;
+  if (typeof envioInfo === "object" && envioInfo !== null && !Array.isArray(envioInfo)) {
+    let match = envioInfo["storage"];
+    hasClickhouse = typeof match === "object" && match !== null && !Array.isArray(match) ? Primitive_object.equal(match["clickhouse"], true) : false;
+  } else {
+    hasClickhouse = false;
+  }
+  return Config.incompatibleMessage(changedPaths, resetCommand, runCommand, hasClickhouse);
+}
+
+export {
+  chainEntry,
+  withChains,
+  make,
+  incompatibleMessage,
+}
+/* Utils Not a pure module */

package/src/Supervisor.res

@@ -183,7 +183,7 @@ let fork = (
   )
   if pipeOutput {
     // The supervisor writes a worker's lines the way it writes its own, which is
-    // the only way ink can keep them out of its frame. Each stream keeps the one
+    // the only way the display can print them above its frame. Each stream keeps the one
     // it was written to, so a worker's errors stay on stderr for whoever is
     // redirecting it.
     [
@@ -430,12 +430,12 @@ let run = async (~config: Config.t, ~workers: array<worker>, ~reset) => {
   // same initialization an unsplit run does, and the supervisor hands the
   // connections it used to its workers.
   let persistence = PgStorage.makePersistenceFromConfig(~config)
-  await persistence->Persistence.initForRun(
-    ~config,
-    ~reset,
-    ~isDevelopmentMode=config.isDev,
-    ~requireInitialized=false,
-  )
+  // Checked here once, so the workers don't each check the same handlers.
+  let autoLoadFiles = await HandlerLoader.getAutoLoadFiles(~config)
+  let _ = await Promise.all2((
+    persistence->Persistence.initForRun(~config, ~reset, ~isDevelopmentMode=config.isDev),
+    HandlerLoader.typeCheck(~config, ~autoLoadFiles),
+  ))
   await persistence.storage.close()
 
   let startTime = Date.make()
@@ -508,7 +508,7 @@ let run = async (~config: Config.t, ~workers: array<worker>, ~reset) => {
   )
 
   if shouldUseTui {
-    let _rerender = Tui.start(~config, ~getMetrics=() =>
+    Tui.start(~config, ~getMetrics=() =>
       switch reported() {
       | [] => {...[]->merge, chains: configuredChains(config)}
       | snapshots => snapshots->merge

package/src/Supervisor.res.mjs

@@ -15,6 +15,7 @@ import * as PgStorage from "./PgStorage.res.mjs";
 import * as Performance from "./bindings/Performance.res.mjs";
 import * as Persistence from "./Persistence.res.mjs";
 import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
+import * as HandlerLoader from "./HandlerLoader.res.mjs";
 import * as Primitive_int from "@rescript/runtime/lib/es6/Primitive_int.js";
 import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
 import * as Child_process from "child_process";
@@ -367,7 +368,11 @@ function configuredChains(config) {
 
 async function run(config, workers, reset) {
   let persistence = PgStorage.makePersistenceFromConfig(config, undefined);
-  await Persistence.initForRun(persistence, config, reset, config.isDev, false);
+  let autoLoadFiles = await HandlerLoader.getAutoLoadFiles(config);
+  await Promise.all([
+    Persistence.initForRun(persistence, config, reset, config.isDev),
+    HandlerLoader.typeCheck(config, autoLoadFiles)
+  ]);
   await persistence.storage.close();
   let startTime = new Date();
   let startTimeRef = Performance.now();

package/src/SyncWrites.res

@@ -0,0 +1,86 @@
+// The writes one round of a synchronous handler has made. A round that
+// suspends is replayed from the top, so its writes are held here rather than
+// applied: the replay has to see the store exactly as the first round did, or a
+// read-modify-write lands once per round.
+
+type table = {
+  entityConfig: Internal.entityConfig,
+  scope: Internal.chainScope,
+  changes: dict<Change.t<Internal.entity>>,
+}
+
+// A handler runs on one chain, so an entity's scope is fixed for the whole
+// round and the entity name is enough to key its table.
+type t = dict<table>
+
+let make = (): t => Dict.make()
+
+let record = (writes: t, ~entityConfig: Internal.entityConfig, ~scope, change) => {
+  let table = switch writes->Utils.Dict.dangerouslyGetNonOption(entityConfig.name) {
+  | Some(table) => table
+  | None =>
+    let table = {entityConfig, scope, changes: Dict.make()}
+    writes->Dict.set(entityConfig.name, table)
+    table
+  }
+  table.changes->Dict.set(change->Change.getEntityId->EntityId.toKey, change)
+}
+
+let changesOf = (writes: t, ~entityConfig: Internal.entityConfig) =>
+  switch writes->Utils.Dict.dangerouslyGetNonOption(entityConfig.name) {
+  | Some({changes}) => Some(changes)
+  | None => None
+  }
+
+// `Some(None)` is a delete this round made: the entity is known not to exist.
+let getById = (writes: t, ~entityConfig, ~entityId: string) =>
+  switch writes->changesOf(~entityConfig) {
+  | Some(changes) =>
+    changes
+    ->Utils.Dict.dangerouslyGetNonOption(entityId)
+    ->Option.map(InMemoryTable.Entity.mapChangeToEntity)
+  | None => None
+  }
+
+// What the store answered, as it reads once this round's writes land: a row
+// the round rewrote is re-tested against the filter, and one it created joins.
+let overlayFilter = (
+  writes: t,
+  entities: array<Internal.entity>,
+  ~entityConfig: Internal.entityConfig,
+  ~filter: EntityFilter.t,
+) =>
+  switch writes->changesOf(~entityConfig) {
+  | None => entities
+  | Some(changes) =>
+    let matches = filter->EntityFilter.makeMatcher(~table=entityConfig.table)
+    let untouched =
+      entities->Array.filter(entity =>
+        !(changes->Dict.has(entity->InMemoryTable.Entity.getEntityIdUnsafe))
+      )
+    let written =
+      changes
+      ->Dict.valuesToArray
+      ->Array.filterMap(change =>
+        switch change->InMemoryTable.Entity.mapChangeToEntity {
+        | Some(entity) if matches(entity) => Some(entity)
+        | _ => None
+        }
+      )
+    untouched->Array.concat(written)
+  }
+
+// How a change lands in the in-memory store, whether written directly or
+// committed at the end of a round.
+let write = (indexerState, ~entityConfig, ~scope, change) =>
+  indexerState
+  ->InMemoryStore.getInMemTable(~entityConfig, ~scope)
+  ->InMemoryTable.Entity.set(
+    ~committedCheckpointId=indexerState->IndexerState.committedCheckpointIdFor(~scope),
+    change,
+  )
+
+let commit = (writes: t, ~indexerState) =>
+  writes->Utils.Dict.forEach(({entityConfig, scope, changes}) =>
+    changes->Utils.Dict.forEach(change => indexerState->write(~entityConfig, ~scope, change))
+  )