envio 3.14.0 → 3.14.1-resolvers.2

package/src/resolvers/ResolverProcess.res.mjs

@@ -0,0 +1,662 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Fs from "fs";
+import * as Env from "../Env.res.mjs";
+import * as Url from "url";
+import * as Path from "path";
+import * as Utils from "../Utils.res.mjs";
+import * as Config from "../Config.res.mjs";
+import * as DbJs from "./db.js";
+import * as Logging from "../Logging.res.mjs";
+import * as Nodefs from "node:fs";
+import * as Process from "process";
+import * as Nodepath from "node:path";
+import * as IndexJs from "./index.js";
+import * as ServerJs from "./server.js";
+import * as Stdlib_JsExn from "@rescript/runtime/lib/es6/Stdlib_JsExn.js";
+import * as HandlerLoader from "../HandlerLoader.res.mjs";
+import * as InternalTable from "../db/InternalTable.res.mjs";
+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 Stdlib_Promise from "@rescript/runtime/lib/es6/Stdlib_Promise.js";
+import * as CollisionsJs from "./collisions.js";
+import * as HasuraApplyJs from "./hasuraApply.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 Primitive_string from "@rescript/runtime/lib/es6/Primitive_string.js";
+import * as Promises from "node:fs/promises";
+import * as Nodechild_process from "node:child_process";
+import * as HasuraMetadataJs from "./hasuraMetadata.js";
+import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
+
+function buildRegisteredManifest(prim) {
+  return IndexJs.buildRegisteredManifest();
+}
+
+function getRegisteredResolvers(prim) {
+  return IndexJs.getRegisteredResolvers();
+}
+
+function buildHasuraMetadata(prim0, prim1) {
+  return HasuraMetadataJs.buildHasuraMetadata(prim0, prim1);
+}
+
+function applyResolverMetadata(prim) {
+  return HasuraApplyJs.applyResolverMetadata(prim);
+}
+
+function startMetadataReassert(prim) {
+  return HasuraApplyJs.startMetadataReassert(prim);
+}
+
+function checkCollisions(prim0, prim1) {
+  CollisionsJs.checkCollisions(prim0, prim1);
+}
+
+function schemaNamesOf(config) {
+  return {
+    entities: Config.getPgUserEntities(config).map(entity => entity.name),
+    enums: config.allEnums.map(enumConfig => enumConfig.name)
+  };
+}
+
+function createResolverPoolFromEnv(prim) {
+  return DbJs.createResolverPoolFromEnv(prim);
+}
+
+function startResolverServer(prim) {
+  return ServerJs.startResolverServer(prim);
+}
+
+let readyzProbeMs = ServerJs.READYZ_PROBE_MS;
+
+function toImportUrl(projectRoot, relativePath) {
+  return Url.pathToFileURL(Path.resolve(projectRoot, relativePath)).toString();
+}
+
+async function sourceFilesIn(absoluteDir, relativePath) {
+  let files;
+  try {
+    let iterator = Promises.glob("**/*.{js,mjs,ts}", {
+      cwd: absoluteDir
+    });
+    files = await Utils.$$Array.fromAsyncIterator(iterator);
+  } catch (raw_exn) {
+    let exn = Primitive_exceptions.internalToException(raw_exn);
+    files = Stdlib_JsError.throwWithMessage(`Failed to read the resolvers directory '` + relativePath + `'. Node 22 or newer is required for directory auto-loading. Cause: ` + Utils.prettifyExn(exn));
+  }
+  return files.filter(file => !(file.includes(".test.") || file.includes(".spec.") || file.includes("_test.") || file.endsWith(".d.ts"))).toSorted(Primitive_string.compare);
+}
+
+async function loadOrThrow(projectRoot, relativePath) {
+  let absolute = Path.resolve(projectRoot, relativePath);
+  let isDir;
+  let exit = 0;
+  let stats;
+  try {
+    stats = Nodefs.statSync(absolute);
+    exit = 1;
+  } catch (exn) {
+    isDir = false;
+  }
+  if (exit === 1) {
+    isDir = stats.isDirectory();
+  }
+  let relativePaths;
+  if (isDir) {
+    let files = await sourceFilesIn(absolute, relativePath);
+    if (Utils.$$Array.isEmpty(files)) {
+      Logging.warn(`'` + relativePath + `' is a directory with no .js, .mjs or .ts files in it, so no resolvers were loaded.`);
+    }
+    relativePaths = files.map(file => relativePath + `/` + file);
+  } else {
+    relativePaths = [relativePath];
+  }
+  HandlerLoader.registerTsHooks();
+  for (let index = 0, index_finish = relativePaths.length; index < index_finish; ++index) {
+    let path = relativePaths[index];
+    try {
+      await import(toImportUrl(projectRoot, path));
+    } catch (raw_exn) {
+      let exn$1 = Primitive_exceptions.internalToException(raw_exn);
+      let e = Primitive_exceptions.internalToException(exn$1);
+      let cause = e.RE_EXN_ID === "JsExn" ? Stdlib_Option.getOr(Stdlib_JsExn.message(e._1), "no message") : "unknown error";
+      Stdlib_JsError.throwWithMessage(`Failed to load the resolvers module '` + path + `' named by \`resolvers:\` in config.yaml. Cause: ` + cause);
+    }
+  }
+}
+
+let emptyManifest = { schemaVersion: 1, resolvers: [], types: [] };
+
+async function writeManifest(config, projectRoot) {
+  let relativePath = config.resolvers;
+  let match;
+  if (relativePath !== undefined) {
+    await loadOrThrow(projectRoot, relativePath);
+    let bundle = IndexJs.buildRegisteredManifest();
+    let prim1 = schemaNamesOf(config);
+    CollisionsJs.checkCollisions(bundle.manifest, prim1);
+    match = bundle;
+  } else {
+    match = {
+      manifest: emptyManifest,
+      sdl: ""
+    };
+  }
+  let dir = Path.resolve(projectRoot, ".envio");
+  await Fs.promises.mkdir(dir, {
+    recursive: true
+  });
+  await Fs.promises.writeFile(Path.join(dir, "resolvers.json"), JSON.stringify(match.manifest, undefined, 2) + "\n");
+  return await Fs.promises.writeFile(Path.join(dir, "resolvers.graphql"), match.sdl);
+}
+
+function hasuraTarget() {
+  let match = Env.Resolvers.hasuraEndpoint();
+  let match$1 = Env.Resolvers.hasuraAdminSecret();
+  if (match !== undefined) {
+    if (match$1 !== undefined) {
+      return {
+        TAG: "Ok",
+        _0: [
+          match,
+          match$1
+        ]
+      };
+    } else {
+      return {
+        TAG: "Error",
+        _0: "HASURA_GRAPHQL_ADMIN_SECRET is not set. Writing metadata is an admin operation, so Hasura will refuse without it."
+      };
+    }
+  } else {
+    return {
+      TAG: "Error",
+      _0: "HASURA_GRAPHQL_ENDPOINT is not set, so there is no Hasura to update. It is the full metadata URL, ending in /v1/metadata."
+    };
+  }
+}
+
+function handlerUrlOrThrow() {
+  let url = Env.Resolvers.publicUrl();
+  if (url !== undefined) {
+    return url;
+  } else {
+    return Stdlib_JsError.throwWithMessage("ENVIO_RESOLVERS_PUBLIC_URL is not set. It is the URL Hasura posts to, which is not the address the resolver process binds -- Hasura has no other way to reach the resolvers, and it is baked into every action.");
+  }
+}
+
+async function metadataJson(config, projectRoot, handlerUrl) {
+  let relativePath = config.resolvers;
+  let manifest;
+  if (relativePath !== undefined) {
+    await loadOrThrow(projectRoot, relativePath);
+    let bundle = IndexJs.buildRegisteredManifest();
+    let prim1 = schemaNamesOf(config);
+    CollisionsJs.checkCollisions(bundle.manifest, prim1);
+    manifest = bundle.manifest;
+  } else {
+    manifest = emptyManifest;
+  }
+  return HasuraMetadataJs.buildHasuraMetadata(manifest, {
+    handlerUrl: handlerUrl,
+    actionSecret: Env.Resolvers.actionSecret()
+  });
+}
+
+async function migrate(config, projectRoot) {
+  let target = hasuraTarget();
+  let match;
+  match = target.TAG === "Ok" ? target._0 : Stdlib_JsError.throwWithMessage(target._0);
+  let handlerUrl = handlerUrlOrThrow();
+  let metadata = await metadataJson(config, projectRoot, handlerUrl);
+  return await HasuraApplyJs.applyResolverMetadata({
+    endpoint: match[0],
+    adminSecret: match[1],
+    metadata: metadata
+  });
+}
+
+function cliEntry() {
+  return Path.resolve(Nodepath.dirname(Url.fileURLToPath(import.meta.url)), "..", "..", "bin.mjs");
+}
+
+function compatibilityOf(pool, pgSchema, envioInfo) {
+  return async () => {
+    let sql = pool.forResolver({
+      name: "readyz",
+      timeoutMs: readyzProbeMs
+    }).sql;
+    let rows;
+    try {
+      rows = await sql.unsafe(`SELECT "config" FROM "` + pgSchema + `"."` + InternalTable.EnvioInfo.table.tableName + `" LIMIT 1;`, []);
+    } catch (raw_exn) {
+      let exn = Primitive_exceptions.internalToException(raw_exn);
+      if (InternalTable.isUndefinedTable(exn)) {
+        return "The database has no envio_info table, so it was not initialized by this indexer.";
+      }
+      throw exn;
+    }
+    let row = rows[0];
+    if (row === undefined) {
+      return "The database records no config, so it cannot be checked against this build. It was initialized by an envio version that predates the check.";
+    }
+    let changedPaths = Config.diffPaths(JSON.parse(Primitive_option.valFromOption(row).config), envioInfo);
+    if (changedPaths.length !== 0) {
+      return `The database was indexed with a different config: ` + changedPaths.join(", ") + `. This build must not answer for it.`;
+    } else {
+      return null;
+    }
+  };
+}
+
+async function serve(config, projectRoot, port, exposeErrors, pgSchemaOpt, envioInfoOpt) {
+  let pgSchema = pgSchemaOpt !== undefined ? pgSchemaOpt : Env.Db.publicSchema;
+  let envioInfo = envioInfoOpt !== undefined ? envioInfoOpt : Config.toEnvioInfo(Config.getPublicConfigJson());
+  let exposeErrors$1 = Stdlib_Option.getOr(exposeErrors, Env.Resolvers.exposeErrors());
+  let relativePath = config.resolvers;
+  let relativePath$1 = relativePath !== undefined ? relativePath : Stdlib_JsError.throwWithMessage("There is nothing to serve: config.yaml has no `resolvers:` entry. Add one naming the module that declares them, e.g. `resolvers: src/Resolvers.ts`.");
+  await loadOrThrow(projectRoot, relativePath$1);
+  let manifest = IndexJs.buildRegisteredManifest().manifest;
+  let prim1 = schemaNamesOf(config);
+  CollisionsJs.checkCollisions(manifest, prim1);
+  let resolvers = IndexJs.getRegisteredResolvers();
+  if (Utils.$$Array.isEmpty(resolvers)) {
+    Logging.warn(`'` + relativePath$1 + `' declared no resolvers, so this process will answer nothing. Every resolver has to be created with createResolver at module scope to register.`);
+  }
+  let entities = {};
+  Config.getPgUserEntities(config).forEach(entity => {
+    entities[entity.name] = entity;
+  });
+  let hasuraTargetOrNone = hasuraTarget();
+  if (hasuraTargetOrNone.TAG === "Ok") {
+    handlerUrlOrThrow();
+    Env.Resolvers.metadataIntervalMs();
+  }
+  let pool = DbJs.createResolverPoolFromEnv({
+    entities: entities,
+    pgSchema: pgSchema
+  });
+  let server;
+  try {
+    server = await ServerJs.startResolverServer({
+      resolvers: resolvers,
+      pool: pool,
+      port: port,
+      exposeErrors: exposeErrors$1,
+      actionSecret: Env.Resolvers.actionSecret(),
+      privateKeys: Env.Resolvers.privateKeys(),
+      checkCompatible: compatibilityOf(pool, pgSchema, envioInfo)
+    });
+  } catch (exn) {
+    try {
+      await pool.end();
+    } catch (exn$1) {
+      
+    }
+    throw exn;
+  }
+  Logging.info(`Serving ` + resolvers.length.toString() + ` custom resolvers on port ` + server.port.toString());
+  let stopReassert;
+  if (hasuraTargetOrNone.TAG === "Ok") {
+    let match = hasuraTargetOrNone._0;
+    let adminSecret = match[1];
+    let endpoint = match[0];
+    let handlerUrl = handlerUrlOrThrow();
+    let metadata = HasuraMetadataJs.buildHasuraMetadata(manifest, {
+      handlerUrl: handlerUrl,
+      actionSecret: Env.Resolvers.actionSecret()
+    });
+    let intervalMs = Env.Resolvers.metadataIntervalMs();
+    let exit = 0;
+    let val;
+    try {
+      val = await HasuraApplyJs.applyResolverMetadata({
+        endpoint: endpoint,
+        adminSecret: adminSecret,
+        metadata: metadata
+      });
+      exit = 1;
+    } catch (raw_exn) {
+      let exn$2 = Primitive_exceptions.internalToException(raw_exn);
+      Logging.error(`Failed to register the custom resolvers with Hasura, so Hasura will not route to this process yet: ` + Utils.prettifyExn(exn$2) + `. ` + (
+        intervalMs === 0 ? "ENVIO_RESOLVERS_METADATA_INTERVAL_MS is 0, so this will not be retried." : `Retrying every ` + intervalMs.toString() + `ms.`
+      ));
+    }
+    if (exit === 1) {
+      Logging.info(val.applied ? `Registered custom resolvers with Hasura: ` + val.reasons.join("; ") : "Hasura already publishes these custom resolvers; nothing to register");
+    }
+    stopReassert = intervalMs === 0 ? () => {} : HasuraApplyJs.startMetadataReassert({
+        endpoint: endpoint,
+        adminSecret: adminSecret,
+        metadata: metadata,
+        intervalMs: intervalMs,
+        onApplied: reasons => Logging.warn(`Hasura had lost the custom resolvers and they were restored: ` + reasons.join("; ")),
+        onError: exn => Logging.error(`Failed to re-assert the custom resolver metadata: ` + Utils.prettifyExn(exn))
+      });
+  } else {
+    Logging.info(hasuraTargetOrNone._0 + ` Nothing was registered with Hasura; this process still answers /hasura-action and /resolve.`);
+    stopReassert = () => {};
+  }
+  let stopped = {
+    contents: undefined
+  };
+  let shutdown = () => {
+    let promise = stopped.contents;
+    if (promise !== undefined) {
+      return promise;
+    }
+    let promise$1 = (async () => {
+      stopReassert();
+      try {
+        await Promise.race([
+          server.close(),
+          Utils.delay(5000)
+        ]);
+      } catch (exn) {
+        
+      }
+      try {
+        await pool.end();
+        return;
+      } catch (exn$1) {
+        return;
+      }
+    })();
+    stopped.contents = promise$1;
+    return promise$1;
+  };
+  return {
+    server: server,
+    pool: pool,
+    shutdown: shutdown
+  };
+}
+
+function handleSignals(running) {
+  [
+    "SIGTERM",
+    "SIGINT"
+  ].forEach(signal => {
+    process.on(signal, () => {
+      Logging.info(`Received ` + signal + `, draining custom resolvers...`);
+      (async () => {
+        await running.shutdown();
+        Process.exit(0);
+      })();
+    });
+  });
+}
+
+async function waitForHealthz(port) {
+  let deadline = Date.now() + 20000;
+  let attempt = async () => {
+    let answered;
+    let exit = 0;
+    let response;
+    try {
+      response = await fetch(`http://127.0.0.1:` + port.toString() + `/healthz`, {
+        method: "GET"
+      });
+      exit = 1;
+    } catch (exn) {
+      answered = false;
+    }
+    if (exit === 1) {
+      answered = response.ok;
+    }
+    if (answered) {
+      return true;
+    } else if (Date.now() > deadline) {
+      return false;
+    } else {
+      await Utils.delay(200);
+      return await attempt();
+    }
+  };
+  return await attempt();
+}
+
+function stopChild(child) {
+  return new Promise((resolve, param) => {
+    let match = child.pid;
+    if (match !== undefined) {
+      child.on("exit", (param, param$1) => resolve());
+      child.kill("SIGTERM");
+      (async () => {
+        await Utils.delay(5000);
+        return resolve();
+      })();
+      return;
+    } else {
+      return resolve();
+    }
+  });
+}
+
+async function startForDev(config, projectRoot) {
+  let match = config.resolvers;
+  if (match === undefined) {
+    return;
+  }
+  if (Primitive_object.equal(process.env["ENVIO_RESOLVERS_EXTERNAL"], "true")) {
+    Logging.info("ENVIO_RESOLVERS_EXTERNAL=true — not starting resolvers here. Run `envio resolvers` in another terminal, and envio-serve against .envio/serve-project.");
+    return;
+  }
+  let configFile = Stdlib_Option.getOr(process.env["ENVIO_CONFIG"], "config.yaml");
+  let port = Env.Resolvers.port();
+  let childEnv = Object.assign({}, process.env);
+  childEnv["ENVIO_RESOLVERS_PORT"] = port.toString();
+  childEnv["ENVIO_RESOLVERS_EXPOSE_ERRORS"] = "true";
+  childEnv["ENVIO_CONFIG"] = configFile;
+  if (Env.Hasura.enabled) {
+    let endpoint = Env.Resolvers.hasuraEndpoint();
+    let endpoint$1;
+    if (endpoint !== undefined) {
+      endpoint$1 = endpoint;
+    } else {
+      let hasuraPort = Stdlib_Option.getOr(process.env["HASURA_EXTERNAL_PORT"], "8080");
+      endpoint$1 = `http://localhost:` + hasuraPort + `/v1/metadata`;
+    }
+    childEnv["HASURA_GRAPHQL_ENDPOINT"] = endpoint$1;
+    childEnv["HASURA_GRAPHQL_ADMIN_SECRET"] = Stdlib_Option.getOr(Env.Resolvers.hasuraAdminSecret(), "testing");
+    let match$1 = Env.Resolvers.publicUrl();
+    if (match$1 !== undefined) {
+      
+    } else {
+      childEnv["ENVIO_RESOLVERS_PUBLIC_URL"] = `http://host.docker.internal:` + port.toString() + `/hasura-action`;
+    }
+  }
+  let resolverChild = Nodechild_process.spawn(process.execPath, [
+    cliEntry(),
+    "resolvers"
+  ], {
+    env: childEnv,
+    stdio: "inherit",
+    detached: false,
+    cwd: projectRoot
+  });
+  resolverChild.on("exit", (code, signal) => {
+    if (!(code == null) && code === 0) {
+      return;
+    }
+    if (signal == null) {
+      if (code == null) {
+        return Logging.info("Custom resolvers stopped.");
+      } else {
+        return Logging.error(`The custom resolvers process exited with code ` + code.toString() + `. The indexer keeps running; fix the resolver and run \`envio dev\` again.`);
+      }
+    } else {
+      return Logging.info(`Custom resolvers stopped (` + signal + `).`);
+    }
+  });
+  if (!await waitForHealthz(port)) {
+    Logging.warn(`The custom resolvers process did not answer /healthz on port ` + port.toString() + ` within ` + (20).toString() + `s. Its own output above says why.`);
+  }
+  await writeManifest(config, projectRoot);
+  let serveDir = Path.resolve(projectRoot, ".envio", "serve-project");
+  await Fs.promises.mkdir(serveDir, {
+    recursive: true
+  });
+  let envioDir = Path.resolve(projectRoot, ".envio");
+  let root = Path.resolve(projectRoot);
+  [
+    [
+      Path.resolve(root, configFile),
+      "config.yaml"
+    ],
+    [
+      Path.resolve(root, "schema.graphql"),
+      "schema.graphql"
+    ],
+    [
+      envioDir + `/resolvers.json`,
+      "resolvers.json"
+    ]
+  ].forEach(param => {
+    let from = param[0];
+    if (Nodefs.existsSync(from)) {
+      Nodefs.copyFileSync(from, serveDir + `/` + param[1]);
+      return;
+    }
+  });
+  let serveChild = {
+    contents: undefined
+  };
+  let bin = process.env["ENVIO_SERVE_BIN"];
+  let exit = 0;
+  if (bin !== undefined && Nodefs.existsSync(bin)) {
+    let servePort = Stdlib_Option.getOr(process.env["ENVIO_SERVE_PORT"], "8080");
+    let startServe = () => {
+      let serveEnv = Object.assign({}, process.env);
+      serveEnv["ENVIO_SERVE_RESOLVERS_URL"] = `http://127.0.0.1:` + port.toString();
+      let child = Nodechild_process.spawn(bin, [
+        "--directory",
+        serveDir,
+        "--config",
+        "config.yaml",
+        "--port",
+        servePort
+      ], {
+        env: serveEnv,
+        stdio: "inherit",
+        detached: false
+      });
+      child.unref();
+      serveChild.contents = Primitive_option.some(child);
+      Logging.info(`Custom resolvers ready — GraphQL with custom fields on port ` + servePort);
+    };
+    let pool = DbJs.createResolverPoolFromEnv({
+      entities: {},
+      pgSchema: Env.Db.publicSchema
+    });
+    let sql = pool.forResolver({
+      name: "dev-wait",
+      timeoutMs: 5000
+    }).sql;
+    let waitForTables = async attempt => {
+      if (attempt >= 120) {
+        Logging.warn("Timed out waiting for the indexer's tables; starting envio-serve anyway.");
+        startServe();
+        return await pool.end();
+      }
+      let count;
+      let exit = 0;
+      let rows;
+      try {
+        rows = await sql.unsafe("SELECT count(*)::int AS n FROM information_schema.tables WHERE table_schema = $1;", [Env.Db.publicSchema]);
+        exit = 1;
+      } catch (exn) {
+        count = 0;
+      }
+      if (exit === 1) {
+        count = Stdlib_Option.mapOr(rows[0], 0, row => row.n);
+      }
+      if (count > 0) {
+        startServe();
+        return await pool.end();
+      } else {
+        await Utils.delay(1000);
+        return await waitForTables(attempt + 1 | 0);
+      }
+    };
+    Stdlib_Promise.$$catch(waitForTables(0), exn => {
+      Logging.warn(`Stopped waiting for the resolver tables: ` + Utils.prettifyExn(exn));
+      return Promise.resolve();
+    });
+  } else {
+    exit = 1;
+  }
+  if (exit === 1) {
+    if (Env.Hasura.enabled) {
+      Logging.info(`Custom resolvers are published by Hasura as actions. Set ENVIO_SERVE_BIN to serve them through envio-serve instead.`);
+    } else {
+      Logging.warn(`Resolvers are declared, but ENVIO_HASURA=false and ENVIO_SERVE_BIN is unset, so nothing publishes them. ` + (`Drop ENVIO_HASURA=false to have Hasura serve them as actions, or point ENVIO_SERVE_BIN at an envio-serve binary and run it against ` + serveDir + `.`));
+    }
+  }
+  let stop = async () => {
+    let child = serveChild.contents;
+    if (child !== undefined) {
+      await stopChild(Primitive_option.valFromOption(child));
+    }
+    return await stopChild(resolverChild);
+  };
+  let killChildren = () => {
+    let child = serveChild.contents;
+    if (child !== undefined) {
+      Primitive_option.valFromOption(child).kill("SIGTERM");
+    }
+    resolverChild.kill("SIGTERM");
+  };
+  process.on("exit", killChildren);
+  [
+    "SIGTERM",
+    "SIGINT"
+  ].forEach(signal => {
+    process.on(signal, () => {
+      killChildren();
+      Process.exit(0);
+    });
+  });
+  return {
+    port: port,
+    pid: resolverChild.pid,
+    stop: stop
+  };
+}
+
+let closeGracePeriodMs = 5000;
+
+let healthzTimeoutMs = 20000;
+
+export {
+  buildRegisteredManifest,
+  getRegisteredResolvers,
+  buildHasuraMetadata,
+  applyResolverMetadata,
+  startMetadataReassert,
+  checkCollisions,
+  schemaNamesOf,
+  createResolverPoolFromEnv,
+  startResolverServer,
+  readyzProbeMs,
+  toImportUrl,
+  sourceFilesIn,
+  loadOrThrow,
+  emptyManifest,
+  writeManifest,
+  hasuraTarget,
+  handlerUrlOrThrow,
+  metadataJson,
+  migrate,
+  closeGracePeriodMs,
+  cliEntry,
+  compatibilityOf,
+  serve,
+  handleSignals,
+  healthzTimeoutMs,
+  waitForHealthz,
+  stopChild,
+  startForDev,
+}
+/* readyzProbeMs Not a pure module */