envio 3.12.0 → 3.13.0-alpha.0

package/src/PgStorage.res

@@ -1,4 +1,4 @@
-let makeClient = () => {
+let makeClient = (~maxConnections=Env.Db.maxConnections) => {
   Postgres.makeSql(
     ~config={
       host: Env.Db.host,
@@ -14,7 +14,7 @@ let makeClient = () => {
           : Some(_str => ())
       ),
       transform: {undefined: Null},
-      max: Env.Db.maxConnections,
+      max: maxConnections,
       // debug: (~connection, ~query, ~params as _, ~types as _) => Js.log2(connection, query),
     },
   )
@@ -409,9 +409,10 @@ let makeLoadQuery = (~pgSchema, ~tableName, ~condition) => {
 // Field names are spliced as quoted identifiers only after the queryFields
 // lookup proves they exist on the table (and they originate from
 // codegen-validated schemas), so the interpolation can't be abused.
-let rec makeFilterCondition = (
+let makeFilterCondition = (
   ~filter: EntityFilter.t,
   ~table: Table.table,
+  ~pgSchema,
   ~params: array<unknown>,
 ) => {
   // Filters reference fields by API name, while the SQL references columns
@@ -447,60 +448,89 @@ let rec makeFilterCondition = (
     params->Array.push(param)->ignore
     `$${params->Array.length->Int.toString}`
   }
-  let scalarCondition = (~fieldName, ~fieldValue, ~op) => {
+
+  let condition = ref("")
+  filter
+  ->EntityFilter.entries
+  ->Utils.Dict.forEachWithKey((operators, fieldName) => {
     let queryField = getQueryFieldOrThrow(fieldName)
-    `"${queryField.pgDbFieldName}" ${op} ${serializeParamOrThrow(
-        ~queryField,
-        ~fieldName,
-        ~fieldValue,
-        ~isArray=false,
-      )}`
-  }
-  switch filter {
-  // A per-chain entity's table is partitioned by its chain-id column, and
-  // Postgres can only prune a plan it caches when that column is a constant in
-  // the SQL. Bound, the cached plan has to keep every partition, and the
-  // planner ends up throwing it away and re-planning on every execution
-  // instead — measured at 315us per load against 218us with the id written in,
-  // on 30 chains.
-  //
-  // The cost is that each chain gets its own query text, so Postgres caches a
-  // prepared statement per (entity, chain, filter shape) rather than per
-  // (entity, filter shape). Measured at ~8KB of plan cache each, which is ~10MB
-  // per connection for 40 entities across 30 chains — accepted, since the
-  // alternative is a cached plan that can't prune.
-  //
-  // `LoadLayer.scopeFilter` is what puts this filter here, and the value is
-  // range-checked to a non-negative safe integer, so it can carry nothing but
-  // digits.
-  | Eq({fieldName, fieldValue}) if getQueryFieldOrThrow(fieldName).isChainId =>
-    `"${getQueryFieldOrThrow(fieldName).pgDbFieldName}" = ${fieldValue
-      ->ChainId.normalizeOrThrow
-      ->ChainId.toString}`
-  | Eq({fieldName, fieldValue}) => scalarCondition(~fieldName, ~fieldValue, ~op="=")
-  | Gt({fieldName, fieldValue}) => scalarCondition(~fieldName, ~fieldValue, ~op=">")
-  | Lt({fieldName, fieldValue}) => scalarCondition(~fieldName, ~fieldValue, ~op="<")
-  | In({fieldName, fieldValue}) => {
-      let queryField = getQueryFieldOrThrow(fieldName)
-      `"${queryField.pgDbFieldName}" = ANY(${serializeParamOrThrow(
-          ~queryField,
-          ~fieldName,
-          ~fieldValue=fieldValue->(Utils.magic: array<unknown> => unknown),
-          ~isArray=true,
-        )})`
-    }
-  | And({filters: []}) =>
-    throw(
-      Persistence.StorageError({
-        message: `Failed loading "${table.tableName}" from storage. The "and" filter must contain at least one nested filter.`,
-        reason: Utils.Error.make(`Empty "and" filter`),
-      }),
-    )
-  | And({filters}) =>
-    `(${filters
-      ->Array.map(filter => makeFilterCondition(~filter, ~table, ~params))
-      ->Array.join(" AND ")})`
-  }
+    operators->Utils.Dict.forEachWithKey((fieldValue, operator) => {
+      let column = `"${queryField.pgDbFieldName}"`
+      let part = switch operator {
+      // A per-chain entity's table is partitioned by its chain-id column, and
+      // Postgres can only prune a plan it caches when that column is a constant
+      // in the SQL. Bound, the cached plan has to keep every partition, and the
+      // planner ends up throwing it away and re-planning on every execution
+      // instead — measured at 315us per load against 218us with the id written
+      // in, on 30 chains.
+      //
+      // The cost is that each chain gets its own query text, so Postgres caches
+      // a prepared statement per (entity, chain, filter shape) rather than per
+      // (entity, filter shape). Measured at ~8KB of plan cache each, which is
+      // ~10MB per connection for 40 entities across 30 chains — accepted, since
+      // the alternative is a cached plan that can't prune.
+      //
+      // `EntityFilter.scoped` is what puts this filter here, and the value is
+      // range-checked to a non-negative safe integer, so it can carry nothing
+      // but digits.
+      | "_eq" if queryField.isChainId =>
+        `${column} = ${fieldValue->ChainId.normalizeOrThrow->ChainId.toString}`
+      // Postgres arrays are rectangular, so candidates for a list column can't
+      // be bound as one array unless they all have the same length, and
+      // postgres.js can't bind a boolean array at all
+      // (https://github.com/porsager/postgres/issues/471). One equality per
+      // candidate has neither problem.
+      | "_in" if queryField.isArray || queryField.fieldType === Boolean =>
+        switch fieldValue->EntityFilter.asArray {
+        | [] => "FALSE"
+        | candidates =>
+          `(${candidates
+            ->Array.map(
+              candidate =>
+                `${column} = ${serializeParamOrThrow(
+                    ~queryField,
+                    ~fieldName,
+                    ~fieldValue=candidate,
+                    ~isArray=false,
+                  )}`,
+            )
+            ->Array.join(" OR ")})`
+        }
+      | "_in" =>
+        let param = serializeParamOrThrow(~queryField, ~fieldName, ~fieldValue, ~isArray=true)
+        switch queryField.fieldType {
+        // A bound array of strings is text[], which has no equality with an
+        // enum. The insert casts the same way.
+        | Enum({config}) => `${column} = ANY(${param}::TEXT[]::"${pgSchema}".${config.name}[])`
+        | _ => `${column} = ANY(${param})`
+        }
+      | _ =>
+        let sqlOperator = switch operator {
+        | "_eq" => "="
+        | "_gt" => ">"
+        | "_lt" => "<"
+        | "_gte" => ">="
+        | "_lte" => "<="
+        | _ =>
+          throw(
+            Persistence.StorageError({
+              message: `Failed loading "${table.tableName}" from storage. Unknown filter operator "${operator}".`,
+              reason: Utils.Error.make(`Unknown filter operator "${operator}"`),
+            }),
+          )
+        }
+        `${column} ${sqlOperator} ${serializeParamOrThrow(
+            ~queryField,
+            ~fieldName,
+            ~fieldValue,
+            ~isArray=false,
+          )}`
+      }
+      condition := (condition.contents === "" ? part : condition.contents ++ " AND " ++ part)
+    })
+  })
+
+  condition.contents
 }
 
 // The chain-id predicate a per-chain entity's row-level SQL needs, already
@@ -1709,7 +1739,7 @@ let make = (
   // Must match PG_CONTAINER in packages/cli/src/docker_env.rs
   let containerName = "envio-postgres"
   let psqlExecOptions: NodeJs.ChildProcess.execOptions = {
-    env: Dict.fromArray([("PGPASSWORD", pgPassword), ("PATH", %raw(`process.env.PATH`))]),
+    env: dict{"PGPASSWORD": pgPassword, "PATH": %raw(`process.env.PATH`)},
   }
 
   let cacheDirPath = NodeJs.Path.resolve([
@@ -2002,7 +2032,7 @@ let make = (
 
   let loadOrThrow = async (~filter: EntityFilter.t, ~table: Table.table) => {
     let params = []
-    let condition = makeFilterCondition(~filter, ~table, ~params)
+    let condition = makeFilterCondition(~filter, ~table, ~pgSchema, ~params)
     switch await sql->Postgres.preparedUnsafe(
       makeLoadQuery(~pgSchema, ~tableName=table.tableName, ~condition),
       params->Obj.magic,
@@ -2033,9 +2063,10 @@ let make = (
     let queryFields = table->Table.queryFields
     let columns = []
     let seen = Utils.Set.make()
-    let rec collect = (filter: EntityFilter.t) =>
-      switch filter {
-      | Eq({fieldName}) | Gt({fieldName}) | Lt({fieldName}) | In({fieldName}) =>
+    filters->Array.forEach(filter =>
+      filter
+      ->EntityFilter.entries
+      ->Utils.Dict.forEachWithKey((_, fieldName) =>
         switch queryFields->Utils.Dict.dangerouslyGetNonOption(fieldName) {
         | Some({pgDbFieldName}) =>
           if !(seen->Utils.Set.has(pgDbFieldName)) {
@@ -2044,9 +2075,8 @@ let make = (
           }
         | None => ()
         }
-      | And({filters}) => filters->Array.forEach(collect)
-      }
-    filters->Array.forEach(collect)
+      )
+    )
     columns
   }
 
@@ -2234,13 +2264,17 @@ let make = (
     }
 
     switch missing {
-    | [] =>
+    // A schema that declares no indexes has nothing to say about them, and one
+    // whose indexes are all in place says it once. Either way the line that
+    // matters is the indexer reporting itself ready, which finalization logs.
+    | [] if schemaIndexes->Utils.Array.notEmpty =>
       Logging.info({
         "storage": storageName,
         "msg": `All ${schemaIndexes
           ->Array.length
           ->Int.toString} schema indexes are already in place. Marking the indexer ready.`,
       })
+    | [] => ()
     | _ =>
       Logging.info({
         "storage": storageName,
@@ -2288,12 +2322,16 @@ let make = (
       }
     })
 
-    Logging.info({
-      "storage": storageName,
-      "msg": `Committed ${missing
-        ->Array.length
-        ->Int.toString} schema indexes and the ready timestamp in ${timeRef->formatSeconds}s.`,
-    })
+    // Only when something was built: the wait this closes is the index build,
+    // and the stamp on its own is not one anybody waited through.
+    if missing->Utils.Array.notEmpty {
+      Logging.info({
+        "storage": storageName,
+        "msg": `Committed ${missing
+          ->Array.length
+          ->Int.toString} schema indexes and the ready timestamp in ${timeRef->formatSeconds}s.`,
+      })
+    }
   }
 
   let setOrThrow = (

package/src/PgStorage.res.mjs

@@ -19,6 +19,7 @@ import * as ChainState from "./ChainState.res.mjs";
 import * as AddressRows from "./AddressRows.res.mjs";
 import * as Performance from "./bindings/Performance.res.mjs";
 import * as Persistence from "./Persistence.res.mjs";
+import * as EntityFilter from "./db/EntityFilter.res.mjs";
 import * as IndexCatalog from "./db/IndexCatalog.res.mjs";
 import * as IndexManager from "./db/IndexManager.res.mjs";
 import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
@@ -37,7 +38,8 @@ import * as S$RescriptSchema from "rescript-schema/src/S.res.mjs";
 import * as CheckpointSequence from "./db/CheckpointSequence.res.mjs";
 import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
 
-function makeClient() {
+function makeClient(maxConnectionsOpt) {
+  let maxConnections = maxConnectionsOpt !== undefined ? maxConnectionsOpt : Env.Db.maxConnections;
   return Postgres({
     host: Env.Db.host,
     port: Env.Db.port,
@@ -45,7 +47,7 @@ function makeClient() {
     username: Env.Db.user,
     password: Env.Db.password,
     ssl: Env.Db.ssl,
-    max: Env.Db.maxConnections,
+    max: maxConnections,
     onnotice: Primitive_object.equal(Env.userLogLevel, "warn") || Primitive_object.equal(Env.userLogLevel, "error") ? undefined : _str => {},
     transform: {
       undefined: null
@@ -301,7 +303,7 @@ function makeLoadQuery(pgSchema, tableName, condition) {
   return `SELECT * FROM "` + pgSchema + `"."` + tableName + `" WHERE ` + condition + `;`;
 }
 
-function makeFilterCondition(filter, table, params) {
+function makeFilterCondition(filter, table, pgSchema, params) {
   let getQueryFieldOrThrow = fieldName => {
     let queryField = Table.queryFields(table)[fieldName];
     if (queryField !== undefined) {
@@ -333,39 +335,76 @@ function makeFilterCondition(filter, table, params) {
     params.push(param);
     return `$` + params.length.toString();
   };
-  let scalarCondition = (fieldName, fieldValue, op) => {
-    let queryField = getQueryFieldOrThrow(fieldName);
-    return `"` + queryField.pgDbFieldName + `" ` + op + ` ` + serializeParamOrThrow(queryField, fieldName, fieldValue, false);
+  let condition = {
+    contents: ""
   };
-  switch (filter.operator) {
-    case "=" :
-      let fieldValue = filter.fieldValue;
-      let fieldName = filter.fieldName;
-      if (getQueryFieldOrThrow(fieldName).isChainId) {
-        return `"` + getQueryFieldOrThrow(fieldName).pgDbFieldName + `" = ` + ChainId.toString(ChainId.normalizeOrThrow(fieldValue));
-      } else {
-        return scalarCondition(fieldName, fieldValue, "=");
+  Utils.Dict.forEachWithKey(EntityFilter.entries(filter), (operators, fieldName) => {
+    let queryField = getQueryFieldOrThrow(fieldName);
+    Utils.Dict.forEachWithKey(operators, (fieldValue, operator) => {
+      let column = `"` + queryField.pgDbFieldName + `"`;
+      let part;
+      let exit = 0;
+      switch (operator) {
+        case "_eq" :
+          if (queryField.isChainId) {
+            part = column + ` = ` + ChainId.toString(ChainId.normalizeOrThrow(fieldValue));
+          } else {
+            exit = 1;
+          }
+          break;
+        case "_in" :
+          if (queryField.isArray || queryField.fieldType === "Boolean") {
+            let candidates = EntityFilter.asArray(fieldValue);
+            part = candidates.length !== 0 ? `(` + candidates.map(candidate => column + ` = ` + serializeParamOrThrow(queryField, fieldName, candidate, false)).join(" OR ") + `)` : "FALSE";
+          } else {
+            let param = serializeParamOrThrow(queryField, fieldName, fieldValue, true);
+            let match = queryField.fieldType;
+            let exit$1 = 0;
+            if (typeof match !== "object" || match.type !== "Enum") {
+              exit$1 = 2;
+            } else {
+              part = column + ` = ANY(` + param + `::TEXT[]::"` + pgSchema + `".` + match.config.name + `[])`;
+            }
+            if (exit$1 === 2) {
+              part = column + ` = ANY(` + param + `)`;
+            }
+          }
+          break;
+        default:
+          exit = 1;
       }
-    case ">" :
-      return scalarCondition(filter.fieldName, filter.fieldValue, ">");
-    case "<" :
-      return scalarCondition(filter.fieldName, filter.fieldValue, "<");
-    case "in" :
-      let fieldName$1 = filter.fieldName;
-      let queryField = getQueryFieldOrThrow(fieldName$1);
-      return `"` + queryField.pgDbFieldName + `" = ANY(` + serializeParamOrThrow(queryField, fieldName$1, filter.fieldValue, true) + `)`;
-    case "and" :
-      let filters = filter.filters;
-      if (filters.length !== 0) {
-        return `(` + filters.map(filter => makeFilterCondition(filter, table, params)).join(" AND ") + `)`;
+      if (exit === 1) {
+        let sqlOperator;
+        switch (operator) {
+          case "_eq" :
+            sqlOperator = "=";
+            break;
+          case "_gt" :
+            sqlOperator = ">";
+            break;
+          case "_gte" :
+            sqlOperator = ">=";
+            break;
+          case "_lt" :
+            sqlOperator = "<";
+            break;
+          case "_lte" :
+            sqlOperator = "<=";
+            break;
+          default:
+            throw {
+              RE_EXN_ID: Persistence.StorageError,
+              message: `Failed loading "` + table.tableName + `" from storage. Unknown filter operator "` + operator + `".`,
+              reason: new Error(`Unknown filter operator "` + operator + `"`),
+              Error: new Error()
+            };
+        }
+        part = column + ` ` + sqlOperator + ` ` + serializeParamOrThrow(queryField, fieldName, fieldValue, false);
       }
-      throw {
-        RE_EXN_ID: Persistence.StorageError,
-        message: `Failed loading "` + table.tableName + `" from storage. The "and" filter must contain at least one nested filter.`,
-        reason: new Error(`Empty "and" filter`),
-        Error: new Error()
-      };
-  }
+      condition.contents = condition.contents === "" ? part : condition.contents + " AND " + part;
+    });
+  });
+  return condition.contents;
 }
 
 function makeChainIdCondition(table, chainId) {
@@ -1032,16 +1071,10 @@ function make(sql, pgHost, pgSchema, pgPort, pgUser, pgDatabase, pgPassword, isH
   let chainIdMode = chainIdModeOpt !== undefined ? chainIdModeOpt : "int32";
   let isolated = isolatedOpt !== undefined ? isolatedOpt : false;
   let containerName = "envio-postgres";
-  let psqlExecOptions_env = Object.fromEntries([
-    [
-      "PGPASSWORD",
-      pgPassword
-    ],
-    [
-      "PATH",
-      process.env.PATH
-    ]
-  ]);
+  let psqlExecOptions_env = {
+    PGPASSWORD: pgPassword,
+    PATH: process.env.PATH
+  };
   let psqlExecOptions = {
     env: psqlExecOptions_env
   };
@@ -1222,7 +1255,7 @@ function make(sql, pgHost, pgSchema, pgPort, pgUser, pgDatabase, pgPassword, isH
   };
   let loadOrThrow = async (filter, table) => {
     let params = [];
-    let condition = makeFilterCondition(filter, table, params);
+    let condition = makeFilterCondition(filter, table, pgSchema, params);
     let rows;
     try {
       rows = await sql.unsafe(makeLoadQuery(pgSchema, table.tableName, condition), params, {prepare: true});
@@ -1251,12 +1284,8 @@ function make(sql, pgHost, pgSchema, pgPort, pgUser, pgDatabase, pgPassword, isH
     let queryFields = Table.queryFields(table);
     let columns = [];
     let seen = new Set();
-    let collect = filter => {
-      if (filter.operator === "and") {
-        filter.filters.forEach(collect);
-        return;
-      }
-      let match = queryFields[filter.fieldName];
+    filters.forEach(filter => Utils.Dict.forEachWithKey(EntityFilter.entries(filter), (param, fieldName) => {
+      let match = queryFields[fieldName];
       if (match === undefined) {
         return;
       }
@@ -1266,8 +1295,7 @@ function make(sql, pgHost, pgSchema, pgPort, pgUser, pgDatabase, pgPassword, isH
         columns.push(pgDbFieldName);
         return;
       }
-    };
-    filters.forEach(collect);
+    }));
     return columns;
   };
   let runAndVerify = async (sql, prepared) => {
@@ -1380,7 +1408,7 @@ function make(sql, pgHost, pgSchema, pgPort, pgUser, pgDatabase, pgPassword, isH
         msg: `Creating the ` + missing.length.toString() + ` remaining schema indexes before the indexer reports ready. Writes are paused until they are committed. ` + slowOnLargeDatabaseNotice,
         indexes: missing.map(prepared => prepared.name)
       });
-    } else {
+    } else if (Utils.$$Array.notEmpty(schemaIndexes)) {
       Logging.info({
         storage: storageName,
         msg: `All ` + schemaIndexes.length.toString() + ` schema indexes are already in place. Marking the indexer ready.`
@@ -1411,10 +1439,12 @@ function make(sql, pgHost, pgSchema, pgPort, pgUser, pgDatabase, pgPassword, isH
         ], {prepare: true});
       }
     });
-    return Logging.info({
-      storage: storageName,
-      msg: `Committed ` + missing.length.toString() + ` schema indexes and the ready timestamp in ` + formatSeconds(timeRef) + `s.`
-    });
+    if (Utils.$$Array.notEmpty(missing)) {
+      return Logging.info({
+        storage: storageName,
+        msg: `Committed ` + missing.length.toString() + ` schema indexes and the ready timestamp in ` + formatSeconds(timeRef) + `s.`
+      });
+    }
   };
   let setOrThrow$1 = (items, table, itemSchema) => setOrThrow(sql, items, table, itemSchema, pgSchema, setQueryCache, chainIdMode);
   let setEffectCacheOrThrow = async (table, itemSchema, items, initialize) => {
@@ -1636,7 +1666,7 @@ function make(sql, pgHost, pgSchema, pgPort, pgUser, pgDatabase, pgPassword, isH
 }
 
 function makeStorageFromEnv(config, sqlOpt, pgSchemaOpt, isHasuraEnabledOpt) {
-  let sql = sqlOpt !== undefined ? Primitive_option.valFromOption(sqlOpt) : makeClient();
+  let sql = sqlOpt !== undefined ? Primitive_option.valFromOption(sqlOpt) : makeClient(undefined);
   let pgSchema = pgSchemaOpt !== undefined ? pgSchemaOpt : Env.Db.publicSchema;
   let isHasuraEnabled = isHasuraEnabledOpt !== undefined ? isHasuraEnabledOpt : Env.Hasura.enabled;
   let tmp;

package/src/Server.res

@@ -0,0 +1,181 @@
+// The indexer's own HTTP surface: metrics for a scraper, health for an
+// orchestrator, and the console's view of the run. What it serves is handed to
+// it, so one process's readings and a supervised group's merged ones render the
+// same way.
+
+// The public console/state chain shape. Kept to exactly this field set for
+// backward compatibility with consumers like RACE — new metric fields stay off
+// the HTTP response.
+type chainData = {
+  chainId: ChainId.t,
+  poweredByHyperSync: bool,
+  firstEventBlockNumber: option<int>,
+  latestProcessedBlock: option<int>,
+  timestampCaughtUpToHeadOrEndblock: option<Date.t>,
+  numEventsProcessed: float,
+  latestFetchedBlockNumber: int,
+  // Need this for API backwards compatibility
+  @as("currentBlockHeight")
+  knownHeight: int,
+  numBatchesFetched: int,
+  startBlock: int,
+  endBlock: option<int>,
+  numAddresses: int,
+}
+@tag("status")
+type state =
+  | @as("disabled") Disabled({})
+  | @as("initializing") Initializing({})
+  | @as("active")
+  Active({
+      envioVersion: string,
+      chains: array<chainData>,
+      indexerStartTime: Date.t,
+      isPreRegisteringDynamicContracts: bool,
+      rollbackOnReorg: bool,
+    })
+
+let toChainData = (m: Metrics.chainMetrics): chainData => {
+  chainId: m.chainId,
+  poweredByHyperSync: m.poweredByHyperSync,
+  firstEventBlockNumber: m.firstEventBlockNumber,
+  latestProcessedBlock: m.latestProcessedBlock,
+  timestampCaughtUpToHeadOrEndblock: m.timestampCaughtUpToHeadOrEndblock,
+  numEventsProcessed: m.numEventsProcessed,
+  latestFetchedBlockNumber: m.latestFetchedBlockNumber,
+  knownHeight: m.knownHeight,
+  numBatchesFetched: m.numBatchesFetched,
+  startBlock: m.startBlock,
+  endBlock: m.endBlock,
+  numAddresses: m.numAddresses,
+}
+
+let chainDataSchema = S.schema((s): chainData => {
+  chainId: s.matches(ChainId.schema),
+  poweredByHyperSync: s.matches(S.bool),
+  firstEventBlockNumber: s.matches(S.option(S.int)),
+  latestProcessedBlock: s.matches(S.option(S.int)),
+  timestampCaughtUpToHeadOrEndblock: s.matches(S.option(S.datetime(S.string))),
+  numEventsProcessed: s.matches(S.float),
+  latestFetchedBlockNumber: s.matches(S.int),
+  knownHeight: s.matches(S.int),
+  numBatchesFetched: s.matches(S.int),
+  startBlock: s.matches(S.int),
+  endBlock: s.matches(S.option(S.int)),
+  numAddresses: s.matches(S.int),
+})
+let stateSchema = S.union([
+  S.literal(Disabled({})),
+  S.literal(Initializing({})),
+  S.schema(s => Active({
+    envioVersion: s.matches(S.string),
+    chains: s.matches(S.array(chainDataSchema)),
+    indexerStartTime: s.matches(S.datetime(S.string)),
+    // Keep the field, since Dev Console expects it to be present
+    isPreRegisteringDynamicContracts: false,
+    rollbackOnReorg: s.matches(S.bool),
+  })),
+])
+
+// Runtime state lives in the process-wide `EnvioGlobal` record (shared
+// across duplicate envio module instances); the slots are opaque there, so
+// cast them to the real types here.
+let startServer = (
+  ~getMetrics: unit => option<Metrics.t>,
+  ~envioVersion: string,
+  ~onSyncCache: unit => promise<unit>,
+  ~collectRuntime: unit => string,
+  ~isDevelopmentMode: bool,
+) => {
+  open Express
+
+  let app = make()
+
+  let consoleCorsMiddleware = (req, res, next) => {
+    switch req.headers->Dict.get("origin") {
+    | Some(origin) if origin === Env.prodEnvioAppUrl || origin === Env.envioAppUrl =>
+      res->setHeader("Access-Control-Allow-Origin", origin)
+    | _ => ()
+    }
+
+    res->setHeader("Access-Control-Allow-Methods", "GET, POST, PUT, DELETE, OPTIONS")
+    res->setHeader("Access-Control-Allow-Headers", "Origin, X-Requested-With, Content-Type, Accept")
+
+    if req.method === Rest.Options {
+      res->sendStatus(200)
+    } else {
+      next()
+    }
+  }
+  app->useFor("/console", consoleCorsMiddleware)
+  app->useFor("/metrics", consoleCorsMiddleware)
+  app->useFor("/metrics/runtime", consoleCorsMiddleware)
+
+  app->get("/healthz", (_req, res) => {
+    // this is the machine readable port used in kubernetes to check the health of this service.
+    //   aditional health information could be added in the future (info about errors, back-offs, etc).
+    res->sendStatus(200)
+  })
+
+  app->get("/console/state", (_req, res) => {
+    let state = if !isDevelopmentMode {
+      Disabled({})
+    } else {
+      switch getMetrics() {
+      | None => Initializing({})
+      | Some(metrics) =>
+        Active({
+          envioVersion,
+          chains: metrics.chains->Array.map(toChainData),
+          indexerStartTime: metrics.startTime,
+          isPreRegisteringDynamicContracts: false,
+          rollbackOnReorg: metrics.rollbackEnabled,
+        })
+      }
+    }
+
+    res->json(state->S.reverseConvertToJsonOrThrow(stateSchema))
+  })
+
+  app->post("/console/syncCache", (_req, res) => {
+    if isDevelopmentMode {
+      onSyncCache()
+      ->Promise.thenResolve(() => res->json(Boolean(true)))
+      // A dump that couldn't be made, or couldn't be confirmed, answers the
+      // same `false` a disabled console does. Leaving it unanswered would hold
+      // the request open for as long as the indexer runs.
+      ->Promise.catch(exn => {
+        Logging.errorWithExn(exn, "Failed to sync the effect cache")
+        res->json(Boolean(false))
+        Promise.resolve()
+      })
+      ->Promise.ignore
+    } else {
+      res->json(Boolean(false))
+    }
+  })
+
+  app->get("/metrics", (_req, res) => {
+    res->set("Content-Type", Metrics.contentType)
+    let _ = res->endWithData(Metrics.collect(~metrics=getMetrics()))
+  })
+
+  app->get("/metrics/runtime", (_req, res) => {
+    res->set("Content-Type", Metrics.contentType)
+    let _ = res->endWithData(collectRuntime())
+  })
+
+  let server = app->listen(Env.serverPort)
+  server->Express.onError(err => {
+    let code = (err->(Utils.magic: JsExn.t => {..}))["code"]
+    if code === "EADDRINUSE" {
+      Logging.error(
+        `Port ${Env.serverPort->Int.toString} is already in use. To fix this either:` ++
+        `\n  1. Kill the process using the port: lsof -ti :${Env.serverPort->Int.toString} | xargs kill -9` ++ `\n  2. Use a different port by setting the ENVIO_INDEXER_PORT environment variable: ENVIO_INDEXER_PORT=9899 envio start`,
+      )
+    } else {
+      Logging.errorWithExn(err, "Failed to start indexer server")
+    }
+    NodeJs.process->NodeJs.exitWithCode(Failure)
+  })
+}