envio 3.0.0-alpha.21 → 3.0.0-alpha.23

package/src/Core.res

@@ -0,0 +1,182 @@
+// Resolution order:
+//   1. Production: require("envio-{os}-{arch}") — platform-specific npm package
+//   2. Dev build:  find repo → cargo build --lib → load from target/debug/
+
+// NAPI encodes Rust `Option<T>` as `null | T` (never `undefined`), so the
+// tighter `Null.t` captures the exact boundary shape.
+type addon = {
+  getConfigJson: (~configPath: Null.t<string>, ~directory: Null.t<string>) => string,
+  runCli: (~args: array<string>, ~envioPackageDir: Null.t<string>) => promise<Null.t<string>>,
+  upsertPersistedState: (~json: string) => promise<unit>,
+}
+
+@module("node:module") external createRequire: string => {..} = "createRequire"
+@module("node:url") external fileURLToPath: string => string = "fileURLToPath"
+@val external importMetaUrl: string = "import.meta.url"
+@module("node:path") external pathDirname: string => string = "dirname"
+@module("node:path") @variadic external pathResolve: array<string> => string = "resolve"
+@module("node:fs") external existsSync: string => bool = "existsSync"
+@module("node:child_process")
+external execSyncRaw: (string, {..}) => string = "execSync"
+@val external processPlatform: string = "process.platform"
+@val external processArch: string = "process.arch"
+
+// Keeps `node:fs` / `node:child_process` imports alive for the %raw
+// loadDevAddon block, which references them as Nodefs / Nodechild_process.
+let _keepFs = existsSync
+let _keepCp = execSyncRaw
+
+let callRequire: ({..}, string) => addon = %raw(`(req, id) => req(id)`)
+
+let envioPackageDir = pathDirname(pathDirname(fileURLToPath(importMetaUrl)))
+
+// Runs `cargo build` on every invocation (like `cargo run`).
+let loadDevAddon: ({..}, string) => addon = %raw(`function(req, envioDir) {
+  var cp = Nodechild_process;
+  var path = Nodepath;
+  var fs = Nodefs;
+
+  var repoRoot = null;
+  var dir = path.resolve(envioDir);
+  for (var i = 0; i < 10; i++) {
+    dir = path.dirname(dir);
+    if (dir === path.dirname(dir)) break;
+    if (fs.existsSync(path.join(dir, "packages", "cli", "Cargo.toml"))) {
+      repoRoot = dir;
+      break;
+    }
+  }
+
+  if (!repoRoot) {
+    var result;
+    try {
+      result = cp.execSync("pnpm list envio --json", {
+        encoding: "utf8", timeout: 10000,
+        stdio: ["ignore", "pipe", "ignore"],
+      });
+    } catch (e) { return null; }
+
+    var parsed;
+    try {
+      var s = result.trim();
+      if (s.startsWith(",")) s = s.slice(1);
+      if (s.endsWith(",")) s = s.slice(0, -1);
+      parsed = JSON.parse(s);
+    } catch (e) { return null; }
+
+    var ver;
+    try {
+      var pkg = Array.isArray(parsed) ? parsed[0] : parsed;
+      ver = (pkg.dependencies || pkg.devDependencies || {}).envio.version;
+    } catch (e) { return null; }
+
+    if (!ver || !ver.startsWith("file:")) return null;
+    repoRoot = path.resolve(path.resolve(ver.replace("file:", "")), "..", "..");
+    if (!fs.existsSync(path.join(repoRoot, "packages", "cli", "Cargo.toml"))) return null;
+  }
+
+  var cliDir = path.join(repoRoot, "packages", "cli");
+  try {
+    cp.execSync("cargo build --lib", { cwd: cliDir, stdio: "inherit" });
+  } catch (e) {
+    throw new Error("Failed to build envio NAPI addon. Run 'cargo build --lib' in " + cliDir + " manually.");
+  }
+
+  var libName = process.platform === "darwin" ? "libenvio.dylib"
+    : process.platform === "win32" ? "envio.dll" : "libenvio.so";
+  var srcPath = path.join(repoRoot, "target", "debug", libName);
+  var nodePath = path.join(repoRoot, "target", "debug", "envio.node");
+  if (!fs.existsSync(srcPath)) {
+    throw new Error("cargo build succeeded but " + srcPath + " not found.");
+  }
+
+  if (!fs.existsSync(nodePath) || fs.statSync(nodePath).mtimeMs < fs.statSync(srcPath).mtimeMs) {
+    fs.copyFileSync(srcPath, nodePath);
+  }
+
+  return req(nodePath);
+}`)
+
+// Native `throw` so we can re-raise a caught JS error preserving its stack,
+// `code`, and any other fields a diagnostic might rely on.
+let rethrow: JsExn.t => 'a = %raw(`function(e) { throw e }`)
+
+let loadAddon = () => {
+  let req = createRequire(importMetaUrl)
+
+  // npm's `libc` field installs only the matching package on Linux, so the
+  // wrong name throws MODULE_NOT_FOUND immediately and the next candidate
+  // wins. An empty list means the host isn't a publish target.
+  let candidates = switch (processPlatform, processArch) {
+  | ("linux", "x64") => [`envio-linux-x64`, `envio-linux-x64-musl`]
+  | ("linux", "arm64") => [`envio-linux-arm64`]
+  | ("darwin", "x64") => [`envio-darwin-x64`]
+  | ("darwin", "arm64") => [`envio-darwin-arm64`]
+  | _ => []
+  }
+
+  // Only swallow MODULE_NOT_FOUND (the optional package isn't installed on
+  // this host). Any other failure — corrupt .node, ABI mismatch, dlopen
+  // error — is a real load failure and must surface.
+  let rec tryRequire = i =>
+    switch candidates[i] {
+    | None => None
+    | Some(pkg) =>
+      try Some(callRequire(req, pkg)) catch {
+      | exn =>
+        switch exn->JsExn.anyToExnInternal {
+        | JsExn(e) if (e->(Utils.magic: JsExn.t => {..}))["code"] === "MODULE_NOT_FOUND" =>
+          tryRequire(i + 1)
+        | JsExn(e) => rethrow(e)
+        | _ => throw(exn)
+        }
+      }
+    }
+
+  switch tryRequire(0) {
+  | Some(addon) => addon
+  | None =>
+    // Dev build fallback (cargo build on every run)
+    switch loadDevAddon(req, envioPackageDir)->(Utils.magic: addon => option<addon>) {
+    | Some(addon) => addon
+    | None =>
+      let host = `${processPlatform}-${processArch}`
+      let msg = if candidates->Array.length === 0 {
+        `envio doesn't support ${host}. Supported: linux-x64 (glibc/musl), linux-arm64, darwin-x64, darwin-arm64.`
+      } else {
+        `Couldn't load the envio native addon for ${host}. Reinstall envio (ensure optional dependencies aren't skipped).`
+      }
+      JsError.throwWithMessage(msg)
+    }
+  }
+}
+
+let addonRef: ref<option<addon>> = ref(None)
+
+let getAddon = () =>
+  switch addonRef.contents {
+  | Some(a) => a
+  | None => {
+      let a = loadAddon()
+      addonRef := Some(a)
+      a
+    }
+  }
+
+let getConfigJson = (~configPath=?, ~directory=?) => {
+  let addon = getAddon()
+  addon.getConfigJson(
+    ~configPath=configPath->Null.fromOption,
+    ~directory=directory->Null.fromOption,
+  )
+}
+
+let runCli = args => {
+  let addon = getAddon()
+  addon.runCli(~args, ~envioPackageDir=Null.make(envioPackageDir))
+}
+
+let upsertPersistedState = json => {
+  let addon = getAddon()
+  addon.upsertPersistedState(~json)
+}

package/src/Core.res.mjs

@@ -0,0 +1,207 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Nodefs from "node:fs";
+import * as Nodeurl from "node:url";
+import * as Nodepath from "node:path";
+import * as Stdlib_Null from "@rescript/runtime/lib/es6/Stdlib_Null.js";
+import * as Nodemodule from "node:module";
+import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
+import * as Nodechild_process from "node:child_process";
+import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
+
+function _keepFs(prim) {
+  return Nodefs.existsSync(prim);
+}
+
+function _keepCp(prim0, prim1) {
+  return Nodechild_process.execSync(prim0, prim1);
+}
+
+let callRequire = ((req, id) => req(id));
+
+let envioPackageDir = Nodepath.dirname(Nodepath.dirname(Nodeurl.fileURLToPath(import.meta.url)));
+
+let loadDevAddon = (function(req, envioDir) {
+  var cp = Nodechild_process;
+  var path = Nodepath;
+  var fs = Nodefs;
+
+  var repoRoot = null;
+  var dir = path.resolve(envioDir);
+  for (var i = 0; i < 10; i++) {
+    dir = path.dirname(dir);
+    if (dir === path.dirname(dir)) break;
+    if (fs.existsSync(path.join(dir, "packages", "cli", "Cargo.toml"))) {
+      repoRoot = dir;
+      break;
+    }
+  }
+
+  if (!repoRoot) {
+    var result;
+    try {
+      result = cp.execSync("pnpm list envio --json", {
+        encoding: "utf8", timeout: 10000,
+        stdio: ["ignore", "pipe", "ignore"],
+      });
+    } catch (e) { return null; }
+
+    var parsed;
+    try {
+      var s = result.trim();
+      if (s.startsWith(",")) s = s.slice(1);
+      if (s.endsWith(",")) s = s.slice(0, -1);
+      parsed = JSON.parse(s);
+    } catch (e) { return null; }
+
+    var ver;
+    try {
+      var pkg = Array.isArray(parsed) ? parsed[0] : parsed;
+      ver = (pkg.dependencies || pkg.devDependencies || {}).envio.version;
+    } catch (e) { return null; }
+
+    if (!ver || !ver.startsWith("file:")) return null;
+    repoRoot = path.resolve(path.resolve(ver.replace("file:", "")), "..", "..");
+    if (!fs.existsSync(path.join(repoRoot, "packages", "cli", "Cargo.toml"))) return null;
+  }
+
+  var cliDir = path.join(repoRoot, "packages", "cli");
+  try {
+    cp.execSync("cargo build --lib", { cwd: cliDir, stdio: "inherit" });
+  } catch (e) {
+    throw new Error("Failed to build envio NAPI addon. Run 'cargo build --lib' in " + cliDir + " manually.");
+  }
+
+  var libName = process.platform === "darwin" ? "libenvio.dylib"
+    : process.platform === "win32" ? "envio.dll" : "libenvio.so";
+  var srcPath = path.join(repoRoot, "target", "debug", libName);
+  var nodePath = path.join(repoRoot, "target", "debug", "envio.node");
+  if (!fs.existsSync(srcPath)) {
+    throw new Error("cargo build succeeded but " + srcPath + " not found.");
+  }
+
+  if (!fs.existsSync(nodePath) || fs.statSync(nodePath).mtimeMs < fs.statSync(srcPath).mtimeMs) {
+    fs.copyFileSync(srcPath, nodePath);
+  }
+
+  return req(nodePath);
+});
+
+let rethrow = (function(e) { throw e });
+
+function loadAddon() {
+  let req = Nodemodule.createRequire(import.meta.url);
+  let match = process.platform;
+  let match$1 = process.arch;
+  let candidates;
+  switch (match) {
+    case "darwin" :
+      switch (match$1) {
+        case "arm64" :
+          candidates = [`envio-darwin-arm64`];
+          break;
+        case "x64" :
+          candidates = [`envio-darwin-x64`];
+          break;
+        default:
+          candidates = [];
+      }
+      break;
+    case "linux" :
+      switch (match$1) {
+        case "arm64" :
+          candidates = [`envio-linux-arm64`];
+          break;
+        case "x64" :
+          candidates = [
+            `envio-linux-x64`,
+            `envio-linux-x64-musl`
+          ];
+          break;
+        default:
+          candidates = [];
+      }
+      break;
+    default:
+      candidates = [];
+  }
+  let tryRequire = _i => {
+    while (true) {
+      let i = _i;
+      let pkg = candidates[i];
+      if (pkg === undefined) {
+        return;
+      }
+      try {
+        return callRequire(req, pkg);
+      } catch (raw_exn) {
+        let exn = Primitive_exceptions.internalToException(raw_exn);
+        let e = Primitive_exceptions.internalToException(exn);
+        if (e.RE_EXN_ID === "JsExn") {
+          let e$1 = e._1;
+          if (e$1.code !== "MODULE_NOT_FOUND") {
+            return rethrow(e$1);
+          }
+          _i = i + 1 | 0;
+          continue;
+        }
+        throw exn;
+      }
+    };
+  };
+  let addon = tryRequire(0);
+  if (addon !== undefined) {
+    return addon;
+  }
+  let addon$1 = loadDevAddon(req, envioPackageDir);
+  if (addon$1 !== undefined) {
+    return addon$1;
+  }
+  let host = process.platform + `-` + process.arch;
+  return Stdlib_JsError.throwWithMessage(candidates.length === 0 ? `envio doesn't support ` + host + `. Supported: linux-x64 (glibc/musl), linux-arm64, darwin-x64, darwin-arm64.` : `Couldn't load the envio native addon for ` + host + `. Reinstall envio (ensure optional dependencies aren't skipped).`);
+}
+
+let addonRef = {
+  contents: undefined
+};
+
+function getAddon() {
+  let a = addonRef.contents;
+  if (a !== undefined) {
+    return a;
+  }
+  let a$1 = loadAddon();
+  addonRef.contents = a$1;
+  return a$1;
+}
+
+function getConfigJson(configPath, directory) {
+  let addon = getAddon();
+  return addon.getConfigJson(Stdlib_Null.fromOption(configPath), Stdlib_Null.fromOption(directory));
+}
+
+function runCli(args) {
+  let addon = getAddon();
+  return addon.runCli(args, envioPackageDir);
+}
+
+function upsertPersistedState(json) {
+  let addon = getAddon();
+  return addon.upsertPersistedState(json);
+}
+
+export {
+  _keepFs,
+  _keepCp,
+  callRequire,
+  envioPackageDir,
+  loadDevAddon,
+  rethrow,
+  loadAddon,
+  addonRef,
+  getAddon,
+  getConfigJson,
+  runCli,
+  upsertPersistedState,
+}
+/* envioPackageDir Not a pure module */

package/src/Ecosystem.res

@@ -10,16 +10,37 @@ type t = {
   getNumber: Internal.eventBlock => int,
   getTimestamp: Internal.eventBlock => int,
   getId: Internal.eventBlock => string,
-  cleanUpRawEventFieldsInPlace: Js.Json.t => unit,
+  cleanUpRawEventFieldsInPlace: JSON.t => unit,
+  /** Method name that the block handler is exposed under on the public
+      `indexer` object — `"onBlock"` for chain-based ecosystems, `"onSlot"`
+      for SVM. Centralised here so adding a new ecosystem only requires a
+      new ecosystem record, not another switch in `Main.res`. */
+  onBlockMethodName: string,
+  /** Schema that unwraps the ecosystem-specific outer wrapper around the
+      user's `where`-returned filter (`block.number` on EVM, `block.height`
+      on Fuel, `slot` on SVM) and surfaces the raw inner `{_gte?, _lte?,
+      _every?}` chunk as `option<unknown>`. The inner chunk is then parsed
+      a second time in `Main.res` by the shared `blockRangeSchema` — that
+      keeps range-field validation in one place for every ecosystem. */
+  onBlockFilterSchema: S.t<option<unknown>>,
+  /** Schema that unwraps the ecosystem-specific `block` wrapper from the
+      user's `onEvent` `where` value (`block.number` on EVM, `block.height`
+      on Fuel) and surfaces the raw inner `{_gte?}` chunk as
+      `option<unknown>`. Separate from `onBlockFilterSchema` because event
+      block filters support only `_gte` (→ per-event `startBlock`) — `_lte`
+      and `_every` are rejected by the inner `eventBlockRangeSchema` in
+      `LogSelection.res`. SVM does not support event handlers, so its
+      schema always surfaces `None`. */
+  onEventBlockFilterSchema: S.t<option<unknown>>,
 }
 
 let makeOnBlockArgs = (~blockNumber: int, ~ecosystem: t, ~context): Internal.onBlockArgs => {
   switch ecosystem.name {
   | Svm => {slot: blockNumber, context}
   | _ => {
-      let blockEvent = Js.Dict.empty()
-      blockEvent->Js.Dict.set(ecosystem.blockNumberName, blockNumber->(Utils.magic: int => unknown))
-      {block: blockEvent->(Utils.magic: Js.Dict.t<unknown> => Internal.blockEvent), context}
+      let blockEvent = Dict.make()
+      blockEvent->Dict.set(ecosystem.blockNumberName, blockNumber->(Utils.magic: int => unknown))
+      {block: blockEvent->(Utils.magic: dict<unknown> => Internal.blockEvent), context}
     }
   }
 }

package/src/Ecosystem.res.mjs

@@ -1,29 +1,28 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
-import * as Caml_option from "rescript/lib/es6/caml_option.js";
+import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
 
 function makeOnBlockArgs(blockNumber, ecosystem, context) {
-  var match = ecosystem.name;
+  let match = ecosystem.name;
   switch (match) {
     case "evm" :
     case "fuel" :
-        break;
+      break;
     case "svm" :
-        return {
-                slot: blockNumber,
-                context: context
-              };
-    
+      return {
+        slot: blockNumber,
+        context: context
+      };
   }
-  var blockEvent = {};
+  let blockEvent = {};
   blockEvent[ecosystem.blockNumberName] = blockNumber;
   return {
-          block: Caml_option.some(blockEvent),
-          context: context
-        };
+    block: Primitive_option.some(blockEvent),
+    context: context
+  };
 }
 
 export {
-  makeOnBlockArgs ,
+  makeOnBlockArgs,
 }
 /* No side effect */

package/src/Env.res

@@ -121,17 +121,24 @@ module Db = {
   let maxConnections = envSafe->EnvSafe.get("ENVIO_PG_MAX_CONNECTIONS", S.int, ~fallback=2)
 }
 
-module ClickHouseSink = {
-  let host = envSafe->EnvSafe.get("ENVIO_CLICKHOUSE_SINK_HOST", S.option(S.string))
-  let database = envSafe->EnvSafe.get("ENVIO_CLICKHOUSE_SINK_DATABASE", S.option(S.string))
-  let username = switch host {
-  | None => ""
-  | Some(_) => envSafe->EnvSafe.get("ENVIO_CLICKHOUSE_SINK_USERNAME", S.string)
-  }
-  let password = switch host {
-  | None => ""
-  | Some(_) => envSafe->EnvSafe.get("ENVIO_CLICKHOUSE_SINK_PASSWORD", S.string)
-  }
+// Required env vars are validated lazily in PgStorage when the user
+// opts into ClickHouse via `storage.clickhouse: true` in config.yaml.
+//
+// Reads run at call time instead of module load. `envio dev` injects these
+// vars into `process.env` after booting its ClickHouse container, and that
+// happens strictly after this module has already been evaluated — caching
+// at module load would lock in `None` and defeat the injection.
+module ClickHouse = {
+  %%private(
+    let read: string => option<string> = %raw(`(k) => {
+      const v = process.env[k];
+      return v === undefined || v === "" ? undefined : v;
+    }`)
+  )
+  let host = () => read("ENVIO_CLICKHOUSE_HOST")
+  let database = () => read("ENVIO_CLICKHOUSE_DATABASE")
+  let username = () => read("ENVIO_CLICKHOUSE_USERNAME")
+  let password = () => read("ENVIO_CLICKHOUSE_PASSWORD")
 }
 
 module Hasura = {
@@ -151,7 +158,7 @@ module Hasura = {
       ~devFallback="http://localhost:8080/v1/metadata",
     )
 
-  let url = graphqlEndpoint->Js.String2.slice(~from=0, ~to_=-("/v1/metadata"->Js.String2.length))
+  let url = graphqlEndpoint->String.slice(~start=0, ~end=-("/v1/metadata"->String.length))
 
   let role = envSafe->EnvSafe.get("HASURA_GRAPHQL_ROLE", S.string, ~devFallback="admin")
 
@@ -165,7 +172,7 @@ module Hasura = {
       // Will be removed once comma support is added — don't rely on this.
       S.string->S.transform(s => {
         parser: string =>
-          switch string->Js.String2.split("&") {
+          switch string->String.split("&") {
           | []
           | [_] =>
             s.fail(`Provide an array of entities in the JSON format.`)