envio 3.14.0 → 3.14.1-resolvers.2

package/src/Env.res

@@ -167,6 +167,141 @@ module ClickHouse = {
   let databaseEngine = () => read("ENVIO_CLICKHOUSE_DATABASE_ENGINE")
 }
 
+// The resolver process runs on its own, so its database connection comes from
+// the same ENVIO_PG_* vars the indexer's does -- point them wherever reads
+// should go. Only what genuinely differs from the indexer's shape gets a var
+// of its own.
+//
+// Read at call time rather than module load, for the same reason ClickHouse's
+// are: `envio dev` injects them after this module has been evaluated.
+module Resolvers = {
+  %%private(
+    let read: string => option<string> = %raw(`(k) => {
+      const v = process.env[k];
+      return v === undefined || v === "" ? undefined : v;
+    }`)
+
+    // `Int.fromString` is `parseInt`: it takes the leading digits and drops the
+    // rest, so "60s" reads as 60 and "1e3" as 1. For a duration that is a
+    // thousandfold error in the quiet direction -- "60s" meaning a minute
+    // becomes a 60ms loop -- so the parse only accepts what it can write back
+    // unchanged.
+    let parseWhole = raw => {
+      let trimmed = raw->String.trim
+      switch trimmed->Int.fromString {
+      | Some(value) if trimmed === value->Int.toString => Some(value)
+      | _ => None
+      }
+    }
+
+    let readInt = (key, ~fallback) =>
+      switch read(key) {
+      | None => fallback
+      | Some(raw) =>
+        switch raw->parseWhole {
+        | Some(value) if value > 0 => value
+        | _ =>
+          JsError.throwWithMessage(
+            `Invalid ${key} value: "${raw}". Expected a positive whole number.`,
+          )
+        }
+      }
+  )
+
+  let port = () =>
+    switch readInt("ENVIO_RESOLVERS_PORT", ~fallback=9900) {
+    | value if value <= 65535 => value
+    | value =>
+      // `readInt` only rejects zero and below, so an out-of-range port reached
+      // `listen` and failed there instead, naming neither the variable nor why.
+      JsError.throwWithMessage(
+        `Invalid ENVIO_RESOLVERS_PORT value: "${value->Int.toString}". A TCP port is 1 to 65535.`,
+      )
+    }
+
+  // Sized as concurrent heavy requests x per-request fan-out, not as the
+  // indexer's two long-lived connections: one resolver request can hold four
+  // at once.
+  let poolSize = () => readInt("ENVIO_RESOLVERS_POOL_SIZE", ~fallback=25)
+
+  let poolWaitTimeoutMs = () => readInt("ENVIO_RESOLVERS_POOL_WAIT_TIMEOUT_MS", ~fallback=10_000)
+
+  // `envio dev` sets this on the resolver process it spawns: locally the
+  // caller is the person who wrote the resolver, so an unexpected error's own
+  // message is what they need. Deployed, the caller may be the public internet
+  // and the message can carry a connection string.
+  let exposeErrors = () =>
+    switch read("ENVIO_RESOLVERS_EXPOSE_ERRORS") {
+    | None
+    | Some("false") => false
+    | Some("true") => true
+    | Some(other) =>
+      // Refused rather than read as false: a typo here silently keeps a
+      // resolver's own error messages off the wire, which is the opposite of
+      // what the person who set it wanted, and nothing would say so.
+      JsError.throwWithMessage(
+        `Invalid ENVIO_RESOLVERS_EXPOSE_ERRORS value: "${other}". Expected "true" or "false".`,
+      )
+    }
+
+  // The URL *Hasura* posts to, which is not the address this process binds:
+  // it is baked into every action, so Hasura has no other way to reach the
+  // resolvers.
+  let publicUrl = () => read("ENVIO_RESOLVERS_PUBLIC_URL")
+
+  // How often the metadata is re-asserted. 0 disables it, for a deployment
+  // where something else owns Hasura's metadata.
+  let metadataIntervalMs = () =>
+    switch read("ENVIO_RESOLVERS_METADATA_INTERVAL_MS") {
+    | None => 60_000
+    | Some(raw) =>
+      switch raw->parseWhole {
+      | Some(value) if value >= 0 => value
+      | _ =>
+        JsError.throwWithMessage(
+          `Invalid ENVIO_RESOLVERS_METADATA_INTERVAL_MS value: "${raw}". Expected a whole number of milliseconds, or 0 to disable.`,
+        )
+      }
+    }
+
+  // Required on every request to either route. Unset, the service cannot tell
+  // its callers apart from anything else that reaches the socket, and both
+  // routes take the role from the request body -- so anyone can claim `admin`.
+  let actionSecret = () => read("ENVIO_RESOLVERS_ACTION_SECRET")
+
+  // Unlocks resolvers declared `private`. Comma-separated so a rotation can
+  // present the old and new key at once; a private resolver with none of these
+  // configured is unreachable rather than open.
+  let privateKeys = () =>
+    switch read("ENVIO_RESOLVERS_PRIVATE_KEYS") {
+    | None => []
+    | Some(raw) =>
+      raw
+      ->String.split(",")
+      ->Array.map(String.trim)
+      ->Array.filter(key => key !== "")
+    }
+
+  // Read raw rather than through `Env.Hasura`, whose dev fallbacks would have
+  // this process apply metadata to a localhost Hasura nobody asked for. Only
+  // an endpoint someone set means "there is a Hasura to register with".
+  let hasuraEndpoint = () => read("HASURA_GRAPHQL_ENDPOINT")
+  let hasuraAdminSecret = () => read("HASURA_GRAPHQL_ADMIN_SECRET")
+
+  // Set where a transaction-mode pooler is the only way in. Those reject
+  // named prepared statements, so this gives up plan reuse.
+  let poolerBacked = () =>
+    switch read("ENVIO_RESOLVERS_POOLER_BACKED") {
+    | None
+    | Some("false") => false
+    | Some("true") => true
+    | Some(other) =>
+      JsError.throwWithMessage(
+        `Invalid ENVIO_RESOLVERS_POOLER_BACKED value: "${other}". Expected "true" or "false".`,
+      )
+    }
+}
+
 module Hasura = {
   // Disable it on HS indexer run, since we don't have Hasura credentials anyways
   // Also, it might be useful for some users who don't care about Hasura
@@ -184,7 +319,12 @@ module Hasura = {
       ~devFallback="http://localhost:8080/v1/metadata",
     )
 
-  let url = graphqlEndpoint->String.slice(~start=0, ~end=-("/v1/metadata"->String.length))
+  // Lazy on purpose. `graphqlEndpoint` is required in production, and a missing
+  // one arrives here as undefined -- slicing it threw a bare TypeError at import
+  // and killed the process before `EnvSafe.close` could say which variable was
+  // missing. Only the dev TUI reads this, so there is nothing to compute up
+  // front.
+  let url = () => graphqlEndpoint->String.slice(~start=0, ~end=-("/v1/metadata"->String.length))
 
   let role = envSafe->EnvSafe.get("HASURA_GRAPHQL_ROLE", S.string, ~devFallback="admin")
 

package/src/Env.res.mjs

@@ -3,6 +3,7 @@
 import * as EnvSafe from "./EnvSafe.res.mjs";
 import * as Logging from "./Logging.res.mjs";
 import * as Postgres from "./bindings/Postgres.res.mjs";
+import * as Stdlib_Int from "@rescript/runtime/lib/es6/Stdlib_Int.js";
 import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
 import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
 import * as HyperSyncClient from "./sources/HyperSyncClient.res.mjs";
@@ -147,6 +148,134 @@ let ClickHouse = {
   databaseEngine: databaseEngine
 };
 
+let read$1 = ((k) => {
+      const v = process.env[k];
+      return v === undefined || v === "" ? undefined : v;
+    });
+
+function parseWhole(raw) {
+  let trimmed = raw.trim();
+  let value = Stdlib_Int.fromString(trimmed, undefined);
+  if (value !== undefined && trimmed === value.toString()) {
+    return value;
+  }
+}
+
+function readInt(key, fallback) {
+  let raw = read$1(key);
+  if (raw === undefined) {
+    return fallback;
+  }
+  let value = parseWhole(raw);
+  if (value !== undefined && value > 0) {
+    return value;
+  }
+  return Stdlib_JsError.throwWithMessage(`Invalid ` + key + ` value: "` + raw + `". Expected a positive whole number.`);
+}
+
+function port$1() {
+  let value = readInt("ENVIO_RESOLVERS_PORT", 9900);
+  if (value <= 65535) {
+    return value;
+  } else {
+    return Stdlib_JsError.throwWithMessage(`Invalid ENVIO_RESOLVERS_PORT value: "` + value.toString() + `". A TCP port is 1 to 65535.`);
+  }
+}
+
+function poolSize() {
+  return readInt("ENVIO_RESOLVERS_POOL_SIZE", 25);
+}
+
+function poolWaitTimeoutMs() {
+  return readInt("ENVIO_RESOLVERS_POOL_WAIT_TIMEOUT_MS", 10000);
+}
+
+function exposeErrors() {
+  let other = read$1("ENVIO_RESOLVERS_EXPOSE_ERRORS");
+  if (other === undefined) {
+    return false;
+  }
+  switch (other) {
+    case "false" :
+      return false;
+    case "true" :
+      return true;
+    default:
+      return Stdlib_JsError.throwWithMessage(`Invalid ENVIO_RESOLVERS_EXPOSE_ERRORS value: "` + other + `". Expected "true" or "false".`);
+  }
+}
+
+function publicUrl() {
+  return read$1("ENVIO_RESOLVERS_PUBLIC_URL");
+}
+
+function metadataIntervalMs() {
+  let raw = read$1("ENVIO_RESOLVERS_METADATA_INTERVAL_MS");
+  if (raw === undefined) {
+    return 60000;
+  }
+  let value = parseWhole(raw);
+  if (value !== undefined) {
+    if (value >= 0) {
+      return value;
+    } else {
+      return Stdlib_JsError.throwWithMessage(`Invalid ENVIO_RESOLVERS_METADATA_INTERVAL_MS value: "` + raw + `". Expected a whole number of milliseconds, or 0 to disable.`);
+    }
+  } else {
+    return Stdlib_JsError.throwWithMessage(`Invalid ENVIO_RESOLVERS_METADATA_INTERVAL_MS value: "` + raw + `". Expected a whole number of milliseconds, or 0 to disable.`);
+  }
+}
+
+function actionSecret() {
+  return read$1("ENVIO_RESOLVERS_ACTION_SECRET");
+}
+
+function privateKeys() {
+  let raw = read$1("ENVIO_RESOLVERS_PRIVATE_KEYS");
+  if (raw !== undefined) {
+    return raw.split(",").map(prim => prim.trim()).filter(key => key !== "");
+  } else {
+    return [];
+  }
+}
+
+function hasuraEndpoint() {
+  return read$1("HASURA_GRAPHQL_ENDPOINT");
+}
+
+function hasuraAdminSecret() {
+  return read$1("HASURA_GRAPHQL_ADMIN_SECRET");
+}
+
+function poolerBacked() {
+  let other = read$1("ENVIO_RESOLVERS_POOLER_BACKED");
+  if (other === undefined) {
+    return false;
+  }
+  switch (other) {
+    case "false" :
+      return false;
+    case "true" :
+      return true;
+    default:
+      return Stdlib_JsError.throwWithMessage(`Invalid ENVIO_RESOLVERS_POOLER_BACKED value: "` + other + `". Expected "true" or "false".`);
+  }
+}
+
+let Resolvers = {
+  port: port$1,
+  poolSize: poolSize,
+  poolWaitTimeoutMs: poolWaitTimeoutMs,
+  exposeErrors: exposeErrors,
+  publicUrl: publicUrl,
+  metadataIntervalMs: metadataIntervalMs,
+  actionSecret: actionSecret,
+  privateKeys: privateKeys,
+  hasuraEndpoint: hasuraEndpoint,
+  hasuraAdminSecret: hasuraAdminSecret,
+  poolerBacked: poolerBacked
+};
+
 let enabled = EnvSafe.get(envSafe, "ENVIO_HASURA", S$RescriptSchema.bool, undefined, true, undefined, undefined);
 
 let s = EnvSafe.get(envSafe, "ENVIO_HASURA_RESPONSE_LIMIT", S$RescriptSchema.option(S$RescriptSchema.int), undefined, undefined, undefined, undefined);
@@ -155,7 +284,9 @@ let responseLimit = s !== undefined ? s : EnvSafe.get(envSafe, "HASURA_RESPONSE_
 
 let graphqlEndpoint = EnvSafe.get(envSafe, "HASURA_GRAPHQL_ENDPOINT", S$RescriptSchema.string, undefined, undefined, "http://localhost:8080/v1/metadata", undefined);
 
-let url = graphqlEndpoint.slice(0, -"/v1/metadata".length | 0);
+function url() {
+  return graphqlEndpoint.slice(0, -"/v1/metadata".length | 0);
+}
 
 let role = EnvSafe.get(envSafe, "HASURA_GRAPHQL_ROLE", S$RescriptSchema.string, undefined, undefined, "admin", undefined);
 
@@ -240,6 +371,7 @@ export {
   logStrategy,
   Db,
   ClickHouse,
+  Resolvers,
   Hasura,
   Configurable,
   ThrottleWrites,

package/src/HandlerLoader.res

@@ -77,15 +77,6 @@ let getAutoLoadFiles = async (~config: Config.t) => {
   }
 }
 
-type typeCheckResult = {
-  skipped?: string,
-  errors?: string,
-}
-
-@module("./HandlerTypeCheck.mjs")
-external checkTypesInWorker: (~cwd: string, ~files: array<string>) => promise<typeCheckResult> =
-  "check"
-
 let typeCheck = async (~config: Config.t, ~autoLoadFiles) => {
   // A contract's `handler:` may also be an auto-loaded file.
   let files =
@@ -96,10 +87,13 @@ let typeCheck = async (~config: Config.t, ~autoLoadFiles) => {
     ->Utils.Set.fromArray
     ->Utils.Set.toArray
   if files->Array.length > 0 {
-    switch await checkTypesInWorker(~cwd=NodeJs.Process.cwd(), ~files) {
-    | {errors} => JsError.throwWithMessage(`Handler files have type errors:\n\n${errors}`)
-    | {skipped} => Logging.warn(skipped)
-    | _ => ()
+    switch await HandlerTypeCheck.check(~cwd=NodeJs.Process.cwd(), ~files) {
+    | TypeErrors(errors) =>
+      JsError.throwWithMessage(
+        `The handler type check found errors. Fix them to start the indexer:\n\n${errors}`,
+      )
+    | Skipped(warning) => Logging.warn(warning)
+    | Passed => ()
     }
   }
 }

package/src/HandlerLoader.res.mjs

@@ -10,10 +10,10 @@ 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 HandlerTypeCheck from "./HandlerTypeCheck.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";
 
 function registerTsHooksWith(prim) {
   TsModuleHooksMjs.register(prim);
@@ -70,24 +70,18 @@ async function getAutoLoadFiles(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 {
+  let errors = await HandlerTypeCheck.check(Process.cwd(), files);
+  if (typeof errors !== "object") {
     return;
+  } else if (errors.TAG === "TypeErrors") {
+    return Stdlib_JsError.throwWithMessage(`The handler type check found errors. Fix them to start the indexer:\n\n` + errors._0);
+  } else {
+    return Logging.warn(errors._0);
   }
 }
 
@@ -111,7 +105,6 @@ export {
   importHandler,
   registerContractHandlers,
   getAutoLoadFiles,
-  checkTypesInWorker,
   typeCheck,
   registerAllHandlers,
 }

package/src/HandlerTypeCheck.res

@@ -0,0 +1,207 @@
+type result =
+  | Passed
+  | TypeErrors(string)
+  | Skipped(string)
+
+let timeoutSeconds = 30
+
+// tsc's pretty output reads the same from TypeScript 5 to 7: a diagnostic
+// starts unindented with its location, its code frame and related locations
+// follow indented, and `--listFiles` prints the program's files after the
+// last one, before the closing summary.
+let fileDiagnostic = /^(.+):\d+:\d+ - error TS(\d+): /
+let globalDiagnostic = /^error TS(\d+): /
+let summary = /^Found \d+ errors?\b/
+let thrownError = /^\w*Error: /
+
+let lines = output => output->String.replaceAll("\r\n", "\n")->String.split("\n")
+
+let rec findUp = (directory, name) => {
+  let candidate = NodeJs.Path.resolve([directory, name])->NodeJs.Path.toString
+  if NodeJs.Fs.existsSync(candidate) {
+    Some(candidate)
+  } else {
+    let parent = NodeJs.Path.dirname(directory)->NodeJs.Path.toString
+    parent === directory ? None : findUp(parent, name)
+  }
+}
+
+// The `tsc` the project's own scripts run. TypeScript 7 has no JavaScript API
+// to call instead, only this command.
+let resolveTsc = (~cwd) =>
+  try {
+    let manifest =
+      NodeJs.Module.createRequire(
+        NodeJs.Path.resolve([cwd, "package.json"])->NodeJs.Path.toString,
+      )->NodeJs.Module.resolve("typescript/package.json")
+    let bin = switch NodeJs.Fs.readFileSync(manifest)->JSON.parseOrThrow {
+    | JSON.Object(fields) =>
+      switch fields->Dict.get("bin") {
+      | Some(JSON.String(bin)) => Some(bin)
+      | Some(JSON.Object(bins)) =>
+        switch bins->Dict.get("tsc") {
+        | Some(JSON.String(bin)) => Some(bin)
+        | _ => None
+        }
+      | _ => None
+      }
+    | _ => None
+    }
+    bin->Option.map(bin =>
+      NodeJs.Path.resolve([
+        NodeJs.Path.dirname(manifest)->NodeJs.Path.toString,
+        bin,
+      ])->NodeJs.Path.toString
+    )
+  } catch {
+  | _ => None
+  }
+
+type run = {error: option<NodeJs.ChildProcess.execFileError>, output: string}
+
+let runTsc = (~tsc, ~cwd, args) =>
+  Promise.make((resolve, _) =>
+    NodeJs.ChildProcess.execFile(
+      NodeJs.Process.process->NodeJs.Process.execPath,
+      [tsc]->Array.concat(args),
+      {cwd, timeout: timeoutSeconds * 1000, maxBuffer: Float.Constants.positiveInfinity},
+      (error, stdout, stderr) =>
+        resolve({
+          error: error->Null.toOption,
+          output: NodeJs.Util.stripVTControlCharacters(stdout ++ stderr),
+        }),
+    )
+  )
+
+type diagnostic = {file: option<string>, code: int, lines: array<string>}
+
+// tsc type-checks nothing after a syntax error, an options error or a global
+// error, and an options error is reported at its line in tsconfig.json.
+let canStopTypeChecking = ({file, code}) =>
+  file->Option.isNone || code < 2000 || (code >= 5000 && code < 7000)
+
+// Paths compare relative to the project, which on Windows also ignores the
+// case of a drive letter tsc may print differently.
+let parse = (output, ~cwd) => {
+  let relative = file =>
+    NodeJs.Path.relative(cwd, NodeJs.Path.resolve([cwd, file])->NodeJs.Path.toString)
+  let diagnostics = []
+  let programFiles = Utils.Set.make()
+  let current = ref(None)
+  let start = (~file, ~code, line) => {
+    let diagnostic = {
+      file,
+      code: code->Int.fromString->Option.getOr(0),
+      lines: [line],
+    }
+    diagnostics->Array.push(diagnostic)
+    current := Some(diagnostic)
+  }
+  output
+  ->lines
+  ->Array.forEach(line =>
+    switch (
+      fileDiagnostic->RegExp.exec(line)->Option.map(RegExp.Result.matches),
+      globalDiagnostic->RegExp.exec(line)->Option.map(RegExp.Result.matches),
+    ) {
+    | (Some([Some(file), Some(code)]), _) => start(~file=Some(relative(file)), ~code, line)
+    | (_, Some([Some(code)])) => start(~file=None, ~code, line)
+    | _ if NodeJs.Path.isAbsolute(line) =>
+      programFiles->Utils.Set.add(relative(line))->ignore
+      current := None
+    | _ if summary->RegExp.test(line) => current := None
+    | _ => current.contents->Option.forEach(diagnostic => diagnostic.lines->Array.push(line))
+    }
+  )
+  (diagnostics, programFiles)
+}
+
+// Exit codes say nothing here: TypeScript 5 and 6 exit with 2 on type errors,
+// 7 with 1, and 1 is also how its launcher fails when the native compiler
+// isn't installed.
+let failure = ({error, output}) =>
+  switch error {
+  | Some({killed: true}) =>
+    `Skipped the handler type check: tsc didn't finish within ${timeoutSeconds->Int.toString} seconds.`
+  | _ =>
+    let reason =
+      output
+      ->lines
+      ->Array.find(line => thrownError->RegExp.test(line))
+      ->Option.getOr(output->String.trim)
+    `Skipped the handler type check: tsc failed to run:\n\n${reason}`
+  }
+
+let check = async (~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.
+  let skip = warning =>
+    NodeJs.Fs.existsSync(NodeJs.Path.resolve([cwd, "rescript.json"])->NodeJs.Path.toString)
+      ? Passed
+      : Skipped(warning)
+
+  switch (resolveTsc(~cwd), findUp(cwd, "tsconfig.json")) {
+  | (None, _) =>
+    skip(
+      "Skipped the handler type check: typescript isn't installed. Add it to devDependencies to type-check handlers on start.",
+    )
+  | (_, None) =>
+    skip(
+      "Skipped the handler type check: no tsconfig.json found. Add one, like the one envio init creates, to type-check handlers on start.",
+    )
+  | (Some(tsc), Some(tsconfig)) =>
+    // The project's own `tsc --noEmit`, minus the build info it would write.
+    // `explainFiles` would replace the listed files' absolute paths with
+    // relative ones and the reasons each is included.
+    let run = await runTsc(
+      ~tsc,
+      ~cwd,
+      [
+        "--project",
+        tsconfig,
+        "--noEmit",
+        "--incremental",
+        "false",
+        "--composite",
+        "false",
+        "--listFiles",
+        "--explainFiles",
+        "false",
+        "--pretty",
+      ],
+    )
+    let (diagnostics, programFiles) = run.output->parse(~cwd)
+    let report = diagnostics =>
+      diagnostics
+      ->Array.map(({lines}) => lines->Array.join("\n")->String.trimEnd)
+      ->Array.join("\n\n")
+    let handlers = files->Array.map(file => NodeJs.Path.relative(cwd, file))
+    let isHandler = ({file}) => file->Option.mapOr(false, file => handlers->Array.includes(file))
+    let errors = diagnostics->Array.filter(isHandler)
+    let stopping =
+      diagnostics->Array.filter(diagnostic =>
+        !isHandler(diagnostic) && canStopTypeChecking(diagnostic)
+      )
+    let unchecked = handlers->Array.filter(file => !(programFiles->Utils.Set.has(file)))
+    if run.error->Option.isSome && diagnostics->Array.length === 0 {
+      Skipped(failure(run))
+    } else if errors->Array.length > 0 {
+      TypeErrors(report(errors))
+    } else if stopping->Array.length > 0 {
+      let reason = report(stopping)
+      Skipped(
+        `Skipped the handler type check: tsc can't check the handlers until these errors are fixed:\n\n${reason}`,
+      )
+    } else if unchecked->Array.length > 0 {
+      let names = unchecked->Array.join(", ")
+      let tsconfig = NodeJs.Path.relative(cwd, tsconfig)
+      let pronoun = unchecked->Array.length === 1 ? "it" : "them"
+      Skipped(
+        `Skipped the handler type check: ${tsconfig} doesn't include ${names}. Add ${pronoun} to "include" to type-check ${pronoun} on start.`,
+      )
+    } else {
+      Passed
+    }
+  }
+}