envio 3.13.0 → 3.14.0-subgraph

package/src/HandlerLoader.res.mjs

@@ -1,26 +1,46 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
 import * as Url from "url";
+import * as Core from "./Core.res.mjs";
 import * as Path from "path";
 import * as Utils from "./Utils.res.mjs";
 import * as Logging from "./Logging.res.mjs";
 import * as Process from "process";
-import * as Nodemodule from "node:module";
+import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
 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 HandlerRegister from "./HandlerRegister.res.mjs";
 import * as Promises from "node:fs/promises";
+import * as TsModuleHooksMjs from "./TsModuleHooks.mjs";
 import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
+import * as HandlerTypeCheckMjs from "./HandlerTypeCheck.mjs";
 
-try {
-  Nodemodule.register("tsx/esm", import.meta.url);
-} catch (exn) {
-  
+function registerTsHooksWith(prim) {
+  TsModuleHooksMjs.register(prim);
 }
 
-function toImportUrl(relativePath) {
-  let absolutePath = Path.resolve(Process.cwd(), relativePath);
-  return Url.pathToFileURL(absolutePath).toString();
+function registerTsHooks() {
+  let addon = Core.getAddon();
+  TsModuleHooksMjs.register({
+    loadTs: addon.loadTs,
+    tsResolveCandidates: addon.tsResolveCandidates,
+    tsNotFoundCandidates: addon.tsNotFoundCandidates
+  });
+}
+
+function isTypeScript(file) {
+  return /\.m?tsx?$/.test(file);
+}
+
+function toAbsolutePath(file) {
+  return Path.resolve(Process.cwd(), file);
+}
+
+async function importHandler(file) {
+  if (isTypeScript(file)) {
+    Core.getAddon().tsCheckHandlerFormat(toAbsolutePath(file));
+  }
+  return await import(Url.pathToFileURL(toAbsolutePath(file)).toString());
 }
 
 async function registerContractHandlers(contractName, handler) {
@@ -28,7 +48,7 @@ async function registerContractHandlers(contractName, handler) {
     return;
   }
   try {
-    await import(toImportUrl(handler));
+    await importHandler(handler);
     return;
   } catch (raw_exn) {
     let exn = Primitive_exceptions.internalToException(raw_exn);
@@ -38,35 +58,80 @@ async function registerContractHandlers(contractName, handler) {
   }
 }
 
-async function autoLoadFromSrcHandlers(handlers) {
+async function globAutoLoadFiles(handlers) {
   let srcPattern = `./` + handlers + `/**/*.{js,mjs,ts}`;
-  let handlerFiles;
   try {
     let iterator = Promises.glob(srcPattern);
     let files = await Utils.$$Array.fromAsyncIterator(iterator);
-    handlerFiles = files.filter(file => !(file.includes(".test.") || file.includes(".spec.") || file.includes("_test.")));
+    return files.filter(file => !(file.includes(".test.") || file.includes(".spec.") || file.includes("_test.")));
   } catch (raw_exn) {
     let exn = Primitive_exceptions.internalToException(raw_exn);
-    handlerFiles = Stdlib_JsError.throwWithMessage(`Failed to glob src/handlers directory for auto-loading handlers. Pattern: ` + srcPattern + `. Before continuing, check that you're using Node.js >=22 version. Error: ` + Utils.prettifyExn(exn));
+    return Stdlib_JsError.throwWithMessage(`Failed to glob src/handlers directory for auto-loading handlers. Pattern: ` + srcPattern + `. Error: ` + Utils.prettifyExn(exn));
+  }
+}
+
+async function getAutoLoadFiles(config) {
+  let match = config.subgraph;
+  if (match !== undefined) {
+    return [];
+  } else {
+    return await globAutoLoadFiles(config.handlers);
   }
-  await Promise.all(handlerFiles.map(file => Stdlib_Promise.$$catch(import(toImportUrl(file)), exn => {
-    let cause = Utils.prettifyExn(exn);
-    Logging.errorWithExn(exn, `Failed to auto-load handler file: ` + file);
-    return Stdlib_JsError.throwWithMessage(`Failed to auto-load handler file: ` + file + `. Cause: ` + cause);
-  })));
 }
 
-async function registerAllHandlers(config) {
+function checkTypesInWorker(prim0, prim1) {
+  return HandlerTypeCheckMjs.check(prim0, prim1);
+}
+
+async function typeCheck(config, autoLoadFiles) {
+  let files = Array.from(new Set(autoLoadFiles.concat(Stdlib_Array.filterMap(config.contractHandlers, param => param.handler)).filter(isTypeScript).map(toAbsolutePath)));
+  if (files.length === 0) {
+    return;
+  }
+  let match = await HandlerTypeCheckMjs.check(Process.cwd(), files);
+  let skipped = match.skipped;
+  let errors = match.errors;
+  if (errors !== undefined) {
+    return Stdlib_JsError.throwWithMessage(`Handler files have type errors:\n\n` + errors);
+  } else if (skipped !== undefined) {
+    return Logging.warn(skipped);
+  } else {
+    return;
+  }
+}
+
+let registerSubgraph = ((subgraph, isDev) =>
+  import("./subgraph/runtime.ts").then((m) => m.registerSubgraph({ ...subgraph, isDev })));
+
+async function registerAllHandlers(config, autoLoadFiles) {
   HandlerRegister.startRegistration(config);
-  await autoLoadFromSrcHandlers(config.handlers);
-  await Promise.all(config.contractHandlers.map(param => registerContractHandlers(param.name, param.handler)));
+  registerTsHooks();
+  let subgraph = config.subgraph;
+  if (subgraph !== undefined) {
+    await registerSubgraph(subgraph, config.isDev);
+  } else {
+    await Promise.all(autoLoadFiles.map(file => Stdlib_Promise.$$catch(importHandler(file), exn => {
+      let cause = Utils.prettifyExn(exn);
+      Logging.errorWithExn(exn, `Failed to auto-load handler file: ` + file);
+      return Stdlib_JsError.throwWithMessage(`Failed to auto-load handler file: ` + file + `. Cause: ` + cause);
+    })));
+    await Promise.all(config.contractHandlers.map(param => registerContractHandlers(param.name, param.handler)));
+  }
   return HandlerRegister.finishRegistration(config);
 }
 
 export {
-  toImportUrl,
+  registerTsHooksWith,
+  registerTsHooks,
+  isTypeScript,
+  toAbsolutePath,
+  importHandler,
   registerContractHandlers,
-  autoLoadFromSrcHandlers,
+  globAutoLoadFiles,
+  getAutoLoadFiles,
+  checkTypesInWorker,
+  typeCheck,
+  registerSubgraph,
   registerAllHandlers,
 }
-/*  Not a pure module */
+/* url Not a pure module */

package/src/HandlerTypeCheck.mjs

@@ -0,0 +1,14 @@
+import { Worker } from "node:worker_threads";
+
+// The compiler blocks the thread it runs on, so it gets its own and the
+// database setup carries on meanwhile.
+export const check = (cwd, files) =>
+  new Promise((resolve, reject) => {
+    const worker = new Worker(new URL("./HandlerTypeCheckWorker.mjs", import.meta.url), {
+      workerData: { cwd, files },
+    });
+    worker.once("message", resolve);
+    worker.once("error", reject);
+    // Settles nothing once the result has arrived.
+    worker.once("exit", () => reject(new Error("The handler type check exited without a result.")));
+  });

package/src/HandlerTypeCheckWorker.mjs

@@ -0,0 +1,68 @@
+import { existsSync } from "node:fs";
+import { createRequire } from "node:module";
+import path from "node:path";
+import { stripVTControlCharacters } from "node:util";
+import { parentPort, workerData } from "node:worker_threads";
+
+const check = ({ cwd, files }) => {
+  // The ReScript compiler checks a ReScript project's handlers, so it has no
+  // reason to set up TypeScript, and the warning would only be noise there.
+  // `rescript.json` at the root is what makes codegen treat it as ReScript.
+  const skip = (warning) => (existsSync(path.join(cwd, "rescript.json")) ? {} : { skipped: warning });
+
+  let ts;
+  try {
+    // The project's own compiler, so handlers are checked exactly as the
+    // user's editor and `tsc` check them.
+    ts = createRequire(path.join(cwd, "package.json"))("typescript");
+  } catch {
+    return skip("Skipped the handler type check: the project doesn't depend on typescript.");
+  }
+
+  const configPath = ts.findConfigFile(cwd, ts.sys.fileExists);
+  if (configPath === undefined) {
+    return skip(
+      "Skipped the handler type check: no tsconfig.json found. Add one to type-check handlers on start, like the one envio init creates."
+    );
+  }
+
+  const host = {
+    getCanonicalFileName: (file) => file,
+    getCurrentDirectory: () => cwd,
+    getNewLine: () => "\n",
+  };
+  const format = (diagnostics) =>
+    stripVTControlCharacters(ts.formatDiagnosticsWithColorAndContext(diagnostics, host)).trimEnd();
+
+  const parsed = ts.getParsedCommandLineOfConfigFile(
+    configPath,
+    { noEmit: true },
+    {
+      ...ts.sys,
+      onUnRecoverableConfigFileDiagnostic: (diagnostic) => {
+        throw new Error(format([diagnostic]));
+      },
+    }
+  );
+
+  // The tsconfig's files are roots, as tsc makes them, since any of them can
+  // declare globals a handler relies on. Only the handlers' errors count.
+  const handlerFiles = files.map((file) => path.resolve(cwd, file));
+  const program = ts.createProgram({
+    rootNames: [...parsed.fileNames, ...handlerFiles],
+    options: parsed.options,
+    projectReferences: parsed.projectReferences,
+  });
+
+  // Every file is a root, so each has a source file. Without one,
+  // `getSemanticDiagnostics` would check the whole program.
+  const diagnostics = handlerFiles
+    .map((file) => program.getSourceFile(file))
+    .flatMap((sourceFile) => [
+      ...program.getSyntacticDiagnostics(sourceFile),
+      ...program.getSemanticDiagnostics(sourceFile),
+    ]);
+  return diagnostics.length === 0 ? {} : { errors: format(diagnostics) };
+};
+
+parentPort.postMessage(check(workerData));

package/src/Internal.res

@@ -491,7 +491,7 @@ type eventConfig = private {
 }
 
 type fuelEventKind =
-  | LogData({logId: string, decode: string => eventParams})
+  | LogData({logId: string, abi: JSON.t})
   | Mint
   | Burn
   | Transfer

package/src/LoadLayer.res

@@ -332,6 +332,44 @@ let loadEffect = (
   )
 }
 
+// Keying an _in walks every value, so it's computed once and handed on rather
+// than recomputed by each reader. Before answering "not in memory", the rows
+// already loaded for other filters are checked: they may cover this one.
+let indexFilter = (inMemTable, ~filter, ~table) => {
+  let filterKey = filter->EntityFilter.toString(~table)
+  if !(inMemTable->InMemoryTable.Entity.hasIndex)(filterKey) {
+    inMemTable->InMemoryTable.Entity.tryIndexFromLoadedValues(~filter, ~table)
+  }
+  filterKey
+}
+
+// A recorded absence is an answer too: `Some(None)` means the entity is known
+// not to exist, so no load is needed to say so.
+let getByIdInMemory = (
+  ~entityConfig: Internal.entityConfig,
+  ~scope,
+  ~indexerState,
+  ~entityId: string,
+) => {
+  let inMemTable = indexerState->InMemoryStore.getInMemTable(~entityConfig, ~scope)
+  inMemTable.latestEntityChangeById->Dict.has(entityId)
+    ? Some((inMemTable->InMemoryTable.Entity.getUnsafe)(entityId))
+    : None
+}
+
+let getByFilterInMemory = (
+  ~entityConfig: Internal.entityConfig,
+  ~scope,
+  ~indexerState,
+  ~filter: EntityFilter.t,
+) => {
+  let inMemTable = indexerState->InMemoryStore.getInMemTable(~entityConfig, ~scope)
+  let filterKey = inMemTable->indexFilter(~filter, ~table=entityConfig.table)
+  (inMemTable->InMemoryTable.Entity.hasIndex)(filterKey)
+    ? Some((inMemTable->InMemoryTable.Entity.getUnsafeOnIndex)(filterKey))
+    : None
+}
+
 let loadByParsedFilter = (
   ~loadManager,
   ~persistence: Persistence.t,
@@ -425,13 +463,7 @@ let loadByParsedFilter = (
     )
   }
 
-  // Keying an _in walks every value, so it's computed once here and handed to
-  // the load manager rather than recomputed by the hasher.
-  let filterKey = filter->EntityFilter.toString(~table=entityConfig.table)
-
-  if !(inMemTable->InMemoryTable.Entity.hasIndex)(filterKey) {
-    inMemTable->InMemoryTable.Entity.tryIndexFromLoadedValues(~filter, ~table=entityConfig.table)
-  }
+  let filterKey = inMemTable->indexFilter(~filter, ~table=entityConfig.table)
 
   loadManager->LoadManager.call(
     ~key,

package/src/LoadLayer.res.mjs

@@ -15,6 +15,7 @@ import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
 import * as ErrorHandling from "./ErrorHandling.res.mjs";
 import * as InMemoryStore from "./InMemoryStore.res.mjs";
 import * as InMemoryTable from "./InMemoryTable.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 Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
 
@@ -182,46 +183,69 @@ function loadEffect(loadManager, persistence, effect, effectArgs, scope, indexer
   return LoadManager.call(loadManager, effectArgs, key, load, args => args.cacheKey, shouldGroup, hash => InMemoryStore.hasEffectOutput(inMemTable, hash), hash => InMemoryStore.getEffectOutputUnsafe(inMemTable, hash));
 }
 
+function indexFilter(inMemTable, filter, table) {
+  let filterKey = EntityFilter.toString(filter, table);
+  if (!InMemoryTable.Entity.hasIndex(inMemTable)(filterKey)) {
+    InMemoryTable.Entity.tryIndexFromLoadedValues(inMemTable, filter, table);
+  }
+  return filterKey;
+}
+
+function getByIdInMemory(entityConfig, scope, indexerState, entityId) {
+  let inMemTable = InMemoryStore.getInMemTable(indexerState, entityConfig, scope);
+  if (entityId in inMemTable.latestEntityChangeById) {
+    return Primitive_option.some(InMemoryTable.Entity.getUnsafe(inMemTable)(entityId));
+  }
+}
+
+function getByFilterInMemory(entityConfig, scope, indexerState, filter) {
+  let inMemTable = InMemoryStore.getInMemTable(indexerState, entityConfig, scope);
+  let filterKey = indexFilter(inMemTable, filter, entityConfig.table);
+  if (InMemoryTable.Entity.hasIndex(inMemTable)(filterKey)) {
+    return InMemoryTable.Entity.getUnsafeOnIndex(inMemTable)(filterKey);
+  }
+}
+
+function loadByParsedFilter(loadManager, persistence, entityConfig, scope, indexerState, shouldGroup, item, ecosystem, filter) {
+  let key = EntityFilter.toOperationKey(filter, entityConfig.name) + scopeKeySuffix(scope);
+  let inMemTable = InMemoryStore.getInMemTable(indexerState, entityConfig, scope);
+  let load = async (filters, param) => {
+    let storage = Persistence.getInitializedStorageOrThrow(persistence);
+    let timerRef = IndexerState.startStorageLoad(indexerState, storage.name, key);
+    let size = {
+      contents: 0
+    };
+    filters.forEach(filter => InMemoryTable.Entity.addEmptyIndex(inMemTable, filter, entityConfig.table));
+    await storage.ensureQueryIndexes(entityConfig, scope, filters);
+    let queries = EntityFilter.merge(filters);
+    await Promise.all(queries.map(async filter => {
+      try {
+        let entities = await storage.loadOrThrow(EntityFilter.scoped(filter, entityConfig.table, scope), entityConfig.table);
+        let committedCheckpointId = IndexerState.committedCheckpointIdFor(indexerState, scope);
+        entities.forEach(entity => InMemoryTable.Entity.initValue(inMemTable, committedCheckpointId, entity.id, entity));
+        InMemoryTable.Entity.recordLoadedValues(inMemTable, filter, entityConfig.table);
+        size.contents = size.contents + entities.length | 0;
+        return;
+      } catch (raw_exn) {
+        let exn = Primitive_exceptions.internalToException(raw_exn);
+        if (exn.RE_EXN_ID === Persistence.StorageError) {
+          return ErrorHandling.mkLogAndRaise(Logging.createChildFrom(Ecosystem.getItemLogger(item, ecosystem), {
+            operation: key,
+            params: EntityFilter.getParams(filter)
+          }), exn.message, exn.reason);
+        }
+        throw exn;
+      }
+    }));
+    return IndexerState.endStorageLoad(indexerState, timerRef, storage.name, key, Stdlib_Array.reduce(queries, 0, (acc, query) => acc + EntityFilter.valuesCount(query) | 0), size.contents);
+  };
+  let filterKey = indexFilter(inMemTable, filter, entityConfig.table);
+  return LoadManager.call(loadManager, filter, key, load, param => filterKey, shouldGroup, InMemoryTable.Entity.hasIndex(inMemTable), InMemoryTable.Entity.getUnsafeOnIndex(inMemTable));
+}
+
 function loadByFilter(loadManager, persistence, entityConfig, scope, indexerState, shouldGroup, item, ecosystem, filter) {
   try {
-    let filter$1 = EntityFilter.parseOrThrow(filter, entityConfig.name, entityConfig.table);
-    let key = EntityFilter.toOperationKey(filter$1, entityConfig.name) + scopeKeySuffix(scope);
-    let inMemTable = InMemoryStore.getInMemTable(indexerState, entityConfig, scope);
-    let load = async (filters, param) => {
-      let storage = Persistence.getInitializedStorageOrThrow(persistence);
-      let timerRef = IndexerState.startStorageLoad(indexerState, storage.name, key);
-      let size = {
-        contents: 0
-      };
-      filters.forEach(filter => InMemoryTable.Entity.addEmptyIndex(inMemTable, filter, entityConfig.table));
-      await storage.ensureQueryIndexes(entityConfig, scope, filters);
-      let queries = EntityFilter.merge(filters);
-      await Promise.all(queries.map(async filter => {
-        try {
-          let entities = await storage.loadOrThrow(EntityFilter.scoped(filter, entityConfig.table, scope), entityConfig.table);
-          let committedCheckpointId = IndexerState.committedCheckpointIdFor(indexerState, scope);
-          entities.forEach(entity => InMemoryTable.Entity.initValue(inMemTable, committedCheckpointId, entity.id, entity));
-          InMemoryTable.Entity.recordLoadedValues(inMemTable, filter, entityConfig.table);
-          size.contents = size.contents + entities.length | 0;
-          return;
-        } catch (raw_exn) {
-          let exn = Primitive_exceptions.internalToException(raw_exn);
-          if (exn.RE_EXN_ID === Persistence.StorageError) {
-            return ErrorHandling.mkLogAndRaise(Logging.createChildFrom(Ecosystem.getItemLogger(item, ecosystem), {
-              operation: key,
-              params: EntityFilter.getParams(filter)
-            }), exn.message, exn.reason);
-          }
-          throw exn;
-        }
-      }));
-      return IndexerState.endStorageLoad(indexerState, timerRef, storage.name, key, Stdlib_Array.reduce(queries, 0, (acc, query) => acc + EntityFilter.valuesCount(query) | 0), size.contents);
-    };
-    let filterKey = EntityFilter.toString(filter$1, entityConfig.table);
-    if (!InMemoryTable.Entity.hasIndex(inMemTable)(filterKey)) {
-      InMemoryTable.Entity.tryIndexFromLoadedValues(inMemTable, filter$1, entityConfig.table);
-    }
-    return LoadManager.call(loadManager, filter$1, key, load, param => filterKey, shouldGroup, InMemoryTable.Entity.hasIndex(inMemTable), InMemoryTable.Entity.getUnsafeOnIndex(inMemTable));
+    return loadByParsedFilter(loadManager, persistence, entityConfig, scope, indexerState, shouldGroup, item, ecosystem, EntityFilter.parseOrThrow(filter, entityConfig.name, entityConfig.table));
   } catch (raw_exn) {
     let exn = Primitive_exceptions.internalToException(raw_exn);
     return Promise.reject(Utils.prettifyExn(exn));
@@ -231,6 +255,9 @@ function loadByFilter(loadManager, persistence, entityConfig, scope, indexerStat
 export {
   loadById,
   loadByFilter,
+  loadByParsedFilter,
+  getByIdInMemory,
+  getByFilterInMemory,
   loadEffect,
 }
 /* Utils Not a pure module */

package/src/LoadLayer.resi

@@ -22,6 +22,34 @@ let loadByFilter: (
   ~filter: dict<dict<unknown>>,
 ) => promise<array<Internal.entity>>
 
+let loadByParsedFilter: (
+  ~loadManager: LoadManager.t,
+  ~persistence: Persistence.t,
+  ~entityConfig: Internal.entityConfig,
+  ~scope: Internal.chainScope,
+  ~indexerState: IndexerState.t,
+  ~shouldGroup: bool,
+  ~item: Internal.item,
+  ~ecosystem: Ecosystem.t,
+  ~filter: EntityFilter.t,
+) => promise<array<Internal.entity>>
+
+// What a get or getWhere answers without a load, or None when it would need
+// one. The sync context reads through these and suspends on None.
+let getByIdInMemory: (
+  ~entityConfig: Internal.entityConfig,
+  ~scope: Internal.chainScope,
+  ~indexerState: IndexerState.t,
+  ~entityId: string,
+) => option<option<Internal.entity>>
+
+let getByFilterInMemory: (
+  ~entityConfig: Internal.entityConfig,
+  ~scope: Internal.chainScope,
+  ~indexerState: IndexerState.t,
+  ~filter: EntityFilter.t,
+) => option<array<Internal.entity>>
+
 let loadEffect: (
   ~loadManager: LoadManager.t,
   ~persistence: Persistence.t,

package/src/Main.res

@@ -411,8 +411,6 @@ let getGlobalIndexer = (): 'indexer => {
   Utils.Proxy.make(Utils.Object.createNullObject(), traps)->(Utils.magic: {..} => 'indexer)
 }
 
-// The RPC-stripped public config that the storage layer persists in
-// `envio_info` (on initialize) and validates against (on resume).
 let migrate = async (~reset) => {
   let config = Config.load()
   let persistence = PgStorage.makePersistenceFromConfig(~config)
@@ -420,8 +418,8 @@ let migrate = async (~reset) => {
     ~reset,
     ~chainConfigs=config.chainMap->ChainMap.values,
     ~contractMapping=config.contractMapping,
-    ~envioInfo=Config.envioInfo(),
-    ~resetCommand="envio local db-migrate setup",
+    ~envioInfo=config.envioInfo,
+    ~resetCommand="envio local db-migrate setup"->Config.withProjectFlags(~config),
     ~runCommand=None,
     ~lowercaseAddresses=config.lowercaseAddresses,
     // A migration command runs once and exits, with nobody watching it recover:
@@ -466,18 +464,23 @@ exception FatalError(exn)
     | None => PgStorage.makePersistenceFromConfig(~config)
     }
     setGlobalPersistence(persistence)
-    await persistence->Persistence.initForRun(
-      ~config,
-      ~reset,
-      ~isDevelopmentMode,
-      ~requireInitialized=config.isolated,
-    )
+    let autoLoadFiles = await HandlerLoader.getAutoLoadFiles(~config)
+    // A worker's supervisor has checked the handlers already, and the test
+    // indexer leaves type checking to the user's test setup.
+    let typeCheck =
+      isTest || Worker.isEnabled
+        ? Promise.resolve()
+        : HandlerLoader.typeCheck(~config, ~autoLoadFiles)
+    let _ = await Promise.all2((
+      persistence->Persistence.initForRun(~config, ~reset, ~isDevelopmentMode),
+      typeCheck,
+    ))
 
     // Loads user handler files, which register handler/contractRegister/where
     // state into the global `HandlerRegister` registry as a side effect; this
     // returns that state resolved into per-chain registrations. `config` itself
     // is never mutated by registration — it holds only event definitions.
-    let registrationsByChainId = await HandlerLoader.registerAllHandlers(~config)
+    let registrationsByChainId = await HandlerLoader.registerAllHandlers(~config, ~autoLoadFiles)
     let config = if isTest {
       {...config, shouldRollbackOnReorg: false}
     } else {
@@ -535,7 +538,7 @@ exception FatalError(exn)
       ~onError,
     )
     if shouldUseTui {
-      let _rerender = Tui.start(~config, ~getMetrics=() => state->IndexerState.toMetrics)
+      Tui.start(~config, ~getMetrics=() => state->IndexerState.toMetrics)
     }
     Worker.bindRun(
       ~getMetrics=() => state->IndexerState.toMetrics,
@@ -565,6 +568,8 @@ let start = async (
   Worker.config->Option.forEach(({chainIds, isDev}) =>
     Config.prime(Config.getPublicConfigJson()->Config.withCommandFields(~chainIds, ~isDev))
   )
+  // An unsupported Node fails here, before the database is touched.
+  HandlerLoader.registerTsHooks()
   let config = Config.load()
   switch isTest ? None : Supervisor.planForRun(~config) {
   | Some(workers) => await Supervisor.run(~config, ~workers, ~reset)

package/src/Main.res.mjs

@@ -351,7 +351,7 @@ function getGlobalIndexer() {
 async function migrate(reset) {
   let config = Config.load();
   let persistence = PgStorage.makePersistenceFromConfig(config, undefined);
-  await Persistence.init(persistence, ChainMap.values(config.chainMap), config.contractMapping, Config.envioInfo(), "envio local db-migrate setup", undefined, reset, config.lowercaseAddresses, undefined, undefined, "Once");
+  await Persistence.init(persistence, ChainMap.values(config.chainMap), config.contractMapping, config.envioInfo, Config.withProjectFlags("envio local db-migrate setup", config), undefined, reset, config.lowercaseAddresses, undefined, undefined, "Once");
   return await persistence.storage.close();
 }
 
@@ -372,8 +372,13 @@ async function startIndexer(config, persistence, resetOpt, isTestOpt, exitAfterF
   let isDevelopmentMode = !isTest && config.isDev;
   let persistence$1 = persistence !== undefined ? persistence : PgStorage.makePersistenceFromConfig(config, undefined);
   EnvioGlobal.value.persistence = Primitive_option.some(persistence$1);
-  await Persistence.initForRun(persistence$1, config, reset, isDevelopmentMode, config.isolated);
-  let registrationsByChainId = await HandlerLoader.registerAllHandlers(config);
+  let autoLoadFiles = await HandlerLoader.getAutoLoadFiles(config);
+  let typeCheck = isTest || Worker.isEnabled ? Promise.resolve() : HandlerLoader.typeCheck(config, autoLoadFiles);
+  await Promise.all([
+    Persistence.initForRun(persistence$1, config, reset, isDevelopmentMode),
+    typeCheck
+  ]);
+  let registrationsByChainId = await HandlerLoader.registerAllHandlers(config, autoLoadFiles);
   let config$1;
   if (isTest) {
     let newrecord = {...config};
@@ -417,6 +422,7 @@ async function start(persistence, resetOpt, isTestOpt, exitAfterFirstEventBlockO
   let isTest = isTestOpt !== undefined ? isTestOpt : false;
   let exitAfterFirstEventBlock = exitAfterFirstEventBlockOpt !== undefined ? exitAfterFirstEventBlockOpt : false;
   Stdlib_Option.forEach(Worker.config, param => Config.prime(Config.withCommandFields(Config.getPublicConfigJson(), param.chainIds, param.isDev)));
+  HandlerLoader.registerTsHooks();
   let config = Config.load();
   let workers = isTest ? undefined : Supervisor.planForRun(config, undefined);
   if (workers !== undefined) {

package/src/NodeVersion.mjs

@@ -0,0 +1,13 @@
+const MINIMUM = [22, 15, 0];
+
+// The message for a Node.js older than envio supports, or undefined.
+export const unsupportedNodeMessage = () => {
+  const current = process.versions.node;
+  const parts = current.split(".").map(Number);
+  const index = MINIMUM.findIndex((minimum, i) => parts[i] !== minimum);
+  if (index === -1 || parts[index] > MINIMUM[index]) return undefined;
+  return [
+    `envio needs Node.js ${MINIMUM.join(".")} or newer, and this is Node.js ${current}.`,
+    "Install a newer one from https://nodejs.org/en/download, or with your version manager, for example: nvm install --lts",
+  ].join("\n");
+};