envio 3.0.0-alpha.0 → 3.0.0-alpha.10

package/src/Env.res

@@ -0,0 +1,252 @@
+// Loads the .env from the root working directory
+%%raw(`import 'dotenv/config'`)
+
+%%private(let envSafe = EnvSafe.make())
+
+// resets the timestampCaughtUpToHeadOrEndblock after a restart when true
+let updateSyncTimeOnRestart =
+  envSafe->EnvSafe.get("UPDATE_SYNC_TIME_ON_RESTART", S.bool, ~fallback=true)
+let targetBufferSize = envSafe->EnvSafe.get("ENVIO_INDEXING_MAX_BUFFER_SIZE", S.option(S.int))
+let maxAddrInPartition = envSafe->EnvSafe.get("MAX_PARTITION_SIZE", S.int, ~fallback=5_000)
+let maxPartitionConcurrency =
+  envSafe->EnvSafe.get("ENVIO_MAX_PARTITION_CONCURRENCY", S.int, ~fallback=10)
+let indexingBlockLag = envSafe->EnvSafe.get("ENVIO_INDEXING_BLOCK_LAG", S.option(S.int))
+
+// FIXME: This broke HS grafana dashboard. Should investigate it later. Maybe we should use :: as a default value?
+// We want to be able to set it to 0.0.0.0
+// to allow to passthrough the port from a Docker container
+// let serverHost = envSafe->EnvSafe.get("ENVIO_INDEXER_HOST", S.string, ~fallback="localhost")
+let serverPort =
+  envSafe->EnvSafe.get(
+    "ENVIO_INDEXER_PORT",
+    S.int->S.port,
+    ~fallback=envSafe->EnvSafe.get("METRICS_PORT", S.int->S.port, ~fallback=9898),
+  )
+
+let tuiOffEnvVar = envSafe->EnvSafe.get("TUI_OFF", S.bool, ~fallback=false)
+
+let logLevelSchema = S.enum([
+  #trace,
+  #debug,
+  #info,
+  #warn,
+  #error,
+  #fatal,
+  #udebug,
+  #uinfo,
+  #uwarn,
+  #uerror,
+  #silent,
+])
+let logFilePath = envSafe->EnvSafe.get("LOG_FILE", S.string, ~fallback="logs/envio.log")
+let userLogLevel = envSafe->EnvSafe.get("LOG_LEVEL", S.option(logLevelSchema))
+let defaultFileLogLevel = envSafe->EnvSafe.get("FILE_LOG_LEVEL", logLevelSchema, ~fallback=#trace)
+
+let prodEnvioAppUrl = "https://envio.dev"
+let envioAppUrl = envSafe->EnvSafe.get("ENVIO_APP", S.string, ~fallback=prodEnvioAppUrl)
+let envioApiToken = envSafe->EnvSafe.get("ENVIO_API_TOKEN", S.option(S.string))
+let hyperSyncClientTimeoutMillis =
+  envSafe->EnvSafe.get("ENVIO_HYPERSYNC_CLIENT_TIMEOUT_MILLIS", S.int, ~fallback=120_000)
+
+/** 
+This is the number of retries that the binary client makes before rejecting the promise with an error 
+Default is 0 so that the indexer can handle retries internally
+*/
+let hyperSyncClientMaxRetries =
+  envSafe->EnvSafe.get("ENVIO_HYPERSYNC_CLIENT_MAX_RETRIES", S.int, ~fallback=0)
+
+let hypersyncClientSerializationFormat =
+  envSafe->EnvSafe.get(
+    "ENVIO_HYPERSYNC_CLIENT_SERIALIZATION_FORMAT",
+    HyperSyncClient.serializationFormatSchema,
+    ~fallback=CapnProto,
+  )
+
+let hypersyncClientEnableQueryCaching =
+  envSafe->EnvSafe.get("ENVIO_HYPERSYNC_CLIENT_ENABLE_QUERY_CACHING", S.bool, ~fallback=true)
+
+module Benchmark = {
+  module SaveDataStrategy: {
+    type t
+    let schema: S.t<t>
+    let default: t
+    let shouldSaveJsonFile: t => bool
+    let shouldSavePrometheus: t => bool
+    let shouldSaveData: t => bool
+  } = {
+    @unboxed
+    type t = Bool(bool) | @as("json-file") JsonFile | @as("prometheus") Prometheus
+
+    let schema = S.enum([Bool(true), Bool(false), JsonFile, Prometheus])
+    let default = Bool(false)
+
+    let shouldSaveJsonFile = self =>
+      switch self {
+      | JsonFile | Bool(true) => true
+      | _ => false
+      }
+
+    let shouldSavePrometheus = _ => true
+
+    let shouldSaveData = self => self->shouldSavePrometheus || self->shouldSaveJsonFile
+  }
+
+  let saveDataStrategy =
+    envSafe->EnvSafe.get(
+      "ENVIO_SAVE_BENCHMARK_DATA",
+      SaveDataStrategy.schema,
+      ~fallback=SaveDataStrategy.default,
+    )
+
+  let shouldSaveData = saveDataStrategy->SaveDataStrategy.shouldSaveData
+
+  /**
+  StdDev involves saving sum of squares of data points, which could get very large.
+
+  Currently only do this for local runs on json-file and not prometheus.
+  */
+  let shouldSaveStdDev =
+    saveDataStrategy->SaveDataStrategy.shouldSaveJsonFile
+}
+
+let logStrategy =
+  envSafe->EnvSafe.get(
+    "LOG_STRATEGY",
+    S.enum([
+      Logging.EcsFile,
+      EcsConsole,
+      EcsConsoleMultistream,
+      FileOnly,
+      ConsoleRaw,
+      ConsolePretty,
+      Both,
+    ]),
+    ~fallback=ConsolePretty,
+  )
+
+Logging.setLogger(
+  Logging.makeLogger(
+    ~logStrategy,
+    ~logFilePath,
+    ~defaultFileLogLevel,
+    ~userLogLevel=userLogLevel->Belt.Option.getWithDefault(#info),
+  ),
+)
+
+module Db = {
+  let host = envSafe->EnvSafe.get("ENVIO_PG_HOST", S.string, ~devFallback="localhost")
+  let port = envSafe->EnvSafe.get("ENVIO_PG_PORT", S.int->S.port, ~devFallback=5433)
+  let user = envSafe->EnvSafe.get("ENVIO_PG_USER", S.string, ~devFallback="postgres")
+  let password = envSafe->EnvSafe.get(
+    "ENVIO_PG_PASSWORD",
+    S.string,
+    ~fallback={
+      envSafe->EnvSafe.get("ENVIO_POSTGRES_PASSWORD", S.string, ~fallback="testing")
+    },
+  )
+  let database = envSafe->EnvSafe.get("ENVIO_PG_DATABASE", S.string, ~devFallback="envio-dev")
+  let publicSchema = envSafe->EnvSafe.get("ENVIO_PG_PUBLIC_SCHEMA", S.string, ~fallback="public")
+  let ssl = envSafe->EnvSafe.get(
+    "ENVIO_PG_SSL_MODE",
+    Postgres.sslOptionsSchema,
+    //this is a dev fallback option for local deployments, shouldn't run in the prod env
+    //the SSL modes should be provided as string otherwise as 'require' | 'allow' | 'prefer' | 'verify-full'
+    ~devFallback=Bool(false),
+  )
+}
+
+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)
+  }
+}
+
+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
+  let enabled = envSafe->EnvSafe.get("ENVIO_HASURA", S.bool, ~fallback=true)
+
+  let responseLimit = switch envSafe->EnvSafe.get("ENVIO_HASURA_RESPONSE_LIMIT", S.option(S.int)) {
+  | Some(_) as s => s
+  | None => envSafe->EnvSafe.get("HASURA_RESPONSE_LIMIT", S.option(S.int))
+  }
+
+  let graphqlEndpoint =
+    envSafe->EnvSafe.get(
+      "HASURA_GRAPHQL_ENDPOINT",
+      S.string,
+      ~devFallback="http://localhost:8080/v1/metadata",
+    )
+
+  let url = graphqlEndpoint->Js.String2.slice(~from=0, ~to_=-("/v1/metadata"->Js.String2.length))
+
+  let role = envSafe->EnvSafe.get("HASURA_GRAPHQL_ROLE", S.string, ~devFallback="admin")
+
+  let secret = envSafe->EnvSafe.get("HASURA_GRAPHQL_ADMIN_SECRET", S.string, ~devFallback="testing")
+
+  let aggregateEntities = envSafe->EnvSafe.get(
+    "ENVIO_HASURA_PUBLIC_AGGREGATE",
+    S.union([
+      S.array(S.string),
+      // Temporary workaround: Hosted Service can't use commas in env vars for multiple entities.
+      // 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("&") {
+          | []
+          | [_] =>
+            s.fail(`Provide an array of entities in the JSON format.`)
+          | entities => entities
+          },
+      }),
+    ]),
+    ~fallback=[],
+  )
+}
+
+module Configurable = {
+  module SyncConfig = {
+    let initialBlockInterval =
+      envSafe->EnvSafe.get("ENVIO_RPC_INITIAL_BLOCK_INTERVAL", S.option(S.int))
+    let backoffMultiplicative =
+      envSafe->EnvSafe.get("ENVIO_RPC_BACKOFF_MULTIPLICATIVE", S.option(S.float))
+    let accelerationAdditive =
+      envSafe->EnvSafe.get("ENVIO_RPC_ACCELERATION_ADDITIVE", S.option(S.int))
+    let intervalCeiling = envSafe->EnvSafe.get("ENVIO_RPC_INTERVAL_CEILING", S.option(S.int))
+  }
+}
+
+module ThrottleWrites = {
+  let chainMetadataIntervalMillis =
+    envSafe->EnvSafe.get("ENVIO_THROTTLE_CHAIN_METADATA_INTERVAL_MILLIS", S.int, ~devFallback=500)
+  let pruneStaleDataIntervalMillis =
+    envSafe->EnvSafe.get(
+      "ENVIO_THROTTLE_PRUNE_STALE_DATA_INTERVAL_MILLIS",
+      S.int,
+      ~devFallback=30_000,
+    )
+
+  let liveMetricsBenchmarkIntervalMillis =
+    envSafe->EnvSafe.get(
+      "ENVIO_THROTTLE_LIVE_METRICS_BENCHMARK_INTERVAL_MILLIS",
+      S.int,
+      ~devFallback=1_000,
+    )
+
+  let jsonFileBenchmarkIntervalMillis =
+    envSafe->EnvSafe.get(
+      "ENVIO_THROTTLE_JSON_FILE_BENCHMARK_INTERVAL_MILLIS",
+      S.int,
+      ~devFallback=500,
+    )
+}
+
+// You need to close the envSafe after you're done with it so that it immediately tells you about your  misconfigured environment on startup.
+envSafe->EnvSafe.close

package/src/Env.res.mjs

@@ -0,0 +1,271 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as EnvSafe from "rescript-envsafe/src/EnvSafe.res.mjs";
+import * as Logging from "./Logging.res.mjs";
+import * as Postgres from "./bindings/Postgres.res.mjs";
+import * as Belt_Option from "rescript/lib/es6/belt_Option.js";
+import * as Caml_option from "rescript/lib/es6/caml_option.js";
+import * as HyperSyncClient from "./sources/HyperSyncClient.res.mjs";
+import * as S$RescriptSchema from "rescript-schema/src/S.res.mjs";
+
+import 'dotenv/config'
+;
+
+var envSafe = EnvSafe.make(undefined);
+
+var updateSyncTimeOnRestart = EnvSafe.get(envSafe, "UPDATE_SYNC_TIME_ON_RESTART", S$RescriptSchema.bool, undefined, true, undefined, undefined);
+
+var targetBufferSize = EnvSafe.get(envSafe, "ENVIO_INDEXING_MAX_BUFFER_SIZE", S$RescriptSchema.option(S$RescriptSchema.$$int), undefined, undefined, undefined, undefined);
+
+var maxAddrInPartition = EnvSafe.get(envSafe, "MAX_PARTITION_SIZE", S$RescriptSchema.$$int, undefined, 5000, undefined, undefined);
+
+var maxPartitionConcurrency = EnvSafe.get(envSafe, "ENVIO_MAX_PARTITION_CONCURRENCY", S$RescriptSchema.$$int, undefined, 10, undefined, undefined);
+
+var indexingBlockLag = EnvSafe.get(envSafe, "ENVIO_INDEXING_BLOCK_LAG", S$RescriptSchema.option(S$RescriptSchema.$$int), undefined, undefined, undefined, undefined);
+
+var serverPort = EnvSafe.get(envSafe, "ENVIO_INDEXER_PORT", S$RescriptSchema.port(S$RescriptSchema.$$int, undefined), undefined, EnvSafe.get(envSafe, "METRICS_PORT", S$RescriptSchema.port(S$RescriptSchema.$$int, undefined), undefined, 9898, undefined, undefined), undefined, undefined);
+
+var tuiOffEnvVar = EnvSafe.get(envSafe, "TUI_OFF", S$RescriptSchema.bool, undefined, false, undefined, undefined);
+
+var logLevelSchema = S$RescriptSchema.$$enum([
+      "trace",
+      "debug",
+      "info",
+      "warn",
+      "error",
+      "fatal",
+      "udebug",
+      "uinfo",
+      "uwarn",
+      "uerror",
+      "silent"
+    ]);
+
+var logFilePath = EnvSafe.get(envSafe, "LOG_FILE", S$RescriptSchema.string, undefined, "logs/envio.log", undefined, undefined);
+
+var userLogLevel = EnvSafe.get(envSafe, "LOG_LEVEL", S$RescriptSchema.option(logLevelSchema), undefined, undefined, undefined, undefined);
+
+var defaultFileLogLevel = EnvSafe.get(envSafe, "FILE_LOG_LEVEL", logLevelSchema, undefined, "trace", undefined, undefined);
+
+var prodEnvioAppUrl = "https://envio.dev";
+
+var envioAppUrl = EnvSafe.get(envSafe, "ENVIO_APP", S$RescriptSchema.string, undefined, prodEnvioAppUrl, undefined, undefined);
+
+var envioApiToken = EnvSafe.get(envSafe, "ENVIO_API_TOKEN", S$RescriptSchema.option(S$RescriptSchema.string), undefined, undefined, undefined, undefined);
+
+var hyperSyncClientTimeoutMillis = EnvSafe.get(envSafe, "ENVIO_HYPERSYNC_CLIENT_TIMEOUT_MILLIS", S$RescriptSchema.$$int, undefined, 120000, undefined, undefined);
+
+var hyperSyncClientMaxRetries = EnvSafe.get(envSafe, "ENVIO_HYPERSYNC_CLIENT_MAX_RETRIES", S$RescriptSchema.$$int, undefined, 0, undefined, undefined);
+
+var hypersyncClientSerializationFormat = EnvSafe.get(envSafe, "ENVIO_HYPERSYNC_CLIENT_SERIALIZATION_FORMAT", HyperSyncClient.serializationFormatSchema, undefined, "CapnProto", undefined, undefined);
+
+var hypersyncClientEnableQueryCaching = EnvSafe.get(envSafe, "ENVIO_HYPERSYNC_CLIENT_ENABLE_QUERY_CACHING", S$RescriptSchema.bool, undefined, true, undefined, undefined);
+
+var schema = S$RescriptSchema.$$enum([
+      true,
+      false,
+      "json-file",
+      "prometheus"
+    ]);
+
+var $$default = false;
+
+function shouldSaveJsonFile(self) {
+  if (typeof self !== "boolean") {
+    if (self === "json-file") {
+      return true;
+    } else {
+      return false;
+    }
+  } else if (self) {
+    return true;
+  } else {
+    return false;
+  }
+}
+
+function shouldSavePrometheus(param) {
+  return true;
+}
+
+function shouldSaveData(self) {
+  return true;
+}
+
+var SaveDataStrategy = {
+  schema: schema,
+  $$default: $$default,
+  shouldSaveJsonFile: shouldSaveJsonFile,
+  shouldSavePrometheus: shouldSavePrometheus,
+  shouldSaveData: shouldSaveData
+};
+
+var saveDataStrategy = EnvSafe.get(envSafe, "ENVIO_SAVE_BENCHMARK_DATA", schema, undefined, Caml_option.some($$default), undefined, undefined);
+
+var shouldSaveData$1 = shouldSaveData(saveDataStrategy);
+
+var shouldSaveStdDev = shouldSaveJsonFile(saveDataStrategy);
+
+var Benchmark = {
+  SaveDataStrategy: SaveDataStrategy,
+  saveDataStrategy: saveDataStrategy,
+  shouldSaveData: shouldSaveData$1,
+  shouldSaveStdDev: shouldSaveStdDev
+};
+
+var logStrategy = EnvSafe.get(envSafe, "LOG_STRATEGY", S$RescriptSchema.$$enum([
+          "ecs-file",
+          "ecs-console",
+          "ecs-console-multistream",
+          "file-only",
+          "console-raw",
+          "console-pretty",
+          "both-prettyconsole"
+        ]), undefined, "console-pretty", undefined, undefined);
+
+Logging.setLogger(Logging.makeLogger(logStrategy, logFilePath, defaultFileLogLevel, Belt_Option.getWithDefault(userLogLevel, "info")));
+
+var host = EnvSafe.get(envSafe, "ENVIO_PG_HOST", S$RescriptSchema.string, undefined, undefined, "localhost", undefined);
+
+var port = EnvSafe.get(envSafe, "ENVIO_PG_PORT", S$RescriptSchema.port(S$RescriptSchema.$$int, undefined), undefined, undefined, 5433, undefined);
+
+var user = EnvSafe.get(envSafe, "ENVIO_PG_USER", S$RescriptSchema.string, undefined, undefined, "postgres", undefined);
+
+var password = EnvSafe.get(envSafe, "ENVIO_PG_PASSWORD", S$RescriptSchema.string, undefined, EnvSafe.get(envSafe, "ENVIO_POSTGRES_PASSWORD", S$RescriptSchema.string, undefined, "testing", undefined, undefined), undefined, undefined);
+
+var database = EnvSafe.get(envSafe, "ENVIO_PG_DATABASE", S$RescriptSchema.string, undefined, undefined, "envio-dev", undefined);
+
+var publicSchema = EnvSafe.get(envSafe, "ENVIO_PG_PUBLIC_SCHEMA", S$RescriptSchema.string, undefined, "public", undefined, undefined);
+
+var ssl = EnvSafe.get(envSafe, "ENVIO_PG_SSL_MODE", Postgres.sslOptionsSchema, undefined, undefined, false, undefined);
+
+var Db = {
+  host: host,
+  port: port,
+  user: user,
+  password: password,
+  database: database,
+  publicSchema: publicSchema,
+  ssl: ssl
+};
+
+var host$1 = EnvSafe.get(envSafe, "ENVIO_CLICKHOUSE_SINK_HOST", S$RescriptSchema.option(S$RescriptSchema.string), undefined, undefined, undefined, undefined);
+
+var database$1 = EnvSafe.get(envSafe, "ENVIO_CLICKHOUSE_SINK_DATABASE", S$RescriptSchema.option(S$RescriptSchema.string), undefined, undefined, undefined, undefined);
+
+var username = host$1 !== undefined ? EnvSafe.get(envSafe, "ENVIO_CLICKHOUSE_SINK_USERNAME", S$RescriptSchema.string, undefined, undefined, undefined, undefined) : "";
+
+var password$1 = host$1 !== undefined ? EnvSafe.get(envSafe, "ENVIO_CLICKHOUSE_SINK_PASSWORD", S$RescriptSchema.string, undefined, undefined, undefined, undefined) : "";
+
+var ClickHouseSink = {
+  host: host$1,
+  database: database$1,
+  username: username,
+  password: password$1
+};
+
+var enabled = EnvSafe.get(envSafe, "ENVIO_HASURA", S$RescriptSchema.bool, undefined, true, undefined, undefined);
+
+var s = EnvSafe.get(envSafe, "ENVIO_HASURA_RESPONSE_LIMIT", S$RescriptSchema.option(S$RescriptSchema.$$int), undefined, undefined, undefined, undefined);
+
+var responseLimit = s !== undefined ? s : EnvSafe.get(envSafe, "HASURA_RESPONSE_LIMIT", S$RescriptSchema.option(S$RescriptSchema.$$int), undefined, undefined, undefined, undefined);
+
+var graphqlEndpoint = EnvSafe.get(envSafe, "HASURA_GRAPHQL_ENDPOINT", S$RescriptSchema.string, undefined, undefined, "http://localhost:8080/v1/metadata", undefined);
+
+var url = graphqlEndpoint.slice(0, -"/v1/metadata".length | 0);
+
+var role = EnvSafe.get(envSafe, "HASURA_GRAPHQL_ROLE", S$RescriptSchema.string, undefined, undefined, "admin", undefined);
+
+var secret = EnvSafe.get(envSafe, "HASURA_GRAPHQL_ADMIN_SECRET", S$RescriptSchema.string, undefined, undefined, "testing", undefined);
+
+var aggregateEntities = EnvSafe.get(envSafe, "ENVIO_HASURA_PUBLIC_AGGREGATE", S$RescriptSchema.union([
+          S$RescriptSchema.array(S$RescriptSchema.string),
+          S$RescriptSchema.transform(S$RescriptSchema.string, (function (s) {
+                  return {
+                          p: (function (string) {
+                              var entities = string.split("&");
+                              var len = entities.length;
+                              if (len !== 1 && len !== 0) {
+                                return entities;
+                              } else {
+                                return s.fail("Provide an array of entities in the JSON format.", undefined);
+                              }
+                            })
+                        };
+                }))
+        ]), undefined, [], undefined, undefined);
+
+var Hasura = {
+  enabled: enabled,
+  responseLimit: responseLimit,
+  graphqlEndpoint: graphqlEndpoint,
+  url: url,
+  role: role,
+  secret: secret,
+  aggregateEntities: aggregateEntities
+};
+
+var initialBlockInterval = EnvSafe.get(envSafe, "ENVIO_RPC_INITIAL_BLOCK_INTERVAL", S$RescriptSchema.option(S$RescriptSchema.$$int), undefined, undefined, undefined, undefined);
+
+var backoffMultiplicative = EnvSafe.get(envSafe, "ENVIO_RPC_BACKOFF_MULTIPLICATIVE", S$RescriptSchema.option(S$RescriptSchema.$$float), undefined, undefined, undefined, undefined);
+
+var accelerationAdditive = EnvSafe.get(envSafe, "ENVIO_RPC_ACCELERATION_ADDITIVE", S$RescriptSchema.option(S$RescriptSchema.$$int), undefined, undefined, undefined, undefined);
+
+var intervalCeiling = EnvSafe.get(envSafe, "ENVIO_RPC_INTERVAL_CEILING", S$RescriptSchema.option(S$RescriptSchema.$$int), undefined, undefined, undefined, undefined);
+
+var SyncConfig = {
+  initialBlockInterval: initialBlockInterval,
+  backoffMultiplicative: backoffMultiplicative,
+  accelerationAdditive: accelerationAdditive,
+  intervalCeiling: intervalCeiling
+};
+
+var Configurable = {
+  SyncConfig: SyncConfig
+};
+
+var chainMetadataIntervalMillis = EnvSafe.get(envSafe, "ENVIO_THROTTLE_CHAIN_METADATA_INTERVAL_MILLIS", S$RescriptSchema.$$int, undefined, undefined, 500, undefined);
+
+var pruneStaleDataIntervalMillis = EnvSafe.get(envSafe, "ENVIO_THROTTLE_PRUNE_STALE_DATA_INTERVAL_MILLIS", S$RescriptSchema.$$int, undefined, undefined, 30000, undefined);
+
+var liveMetricsBenchmarkIntervalMillis = EnvSafe.get(envSafe, "ENVIO_THROTTLE_LIVE_METRICS_BENCHMARK_INTERVAL_MILLIS", S$RescriptSchema.$$int, undefined, undefined, 1000, undefined);
+
+var jsonFileBenchmarkIntervalMillis = EnvSafe.get(envSafe, "ENVIO_THROTTLE_JSON_FILE_BENCHMARK_INTERVAL_MILLIS", S$RescriptSchema.$$int, undefined, undefined, 500, undefined);
+
+var ThrottleWrites = {
+  chainMetadataIntervalMillis: chainMetadataIntervalMillis,
+  pruneStaleDataIntervalMillis: pruneStaleDataIntervalMillis,
+  liveMetricsBenchmarkIntervalMillis: liveMetricsBenchmarkIntervalMillis,
+  jsonFileBenchmarkIntervalMillis: jsonFileBenchmarkIntervalMillis
+};
+
+EnvSafe.close(envSafe);
+
+export {
+  updateSyncTimeOnRestart ,
+  targetBufferSize ,
+  maxAddrInPartition ,
+  maxPartitionConcurrency ,
+  indexingBlockLag ,
+  serverPort ,
+  tuiOffEnvVar ,
+  logLevelSchema ,
+  logFilePath ,
+  userLogLevel ,
+  defaultFileLogLevel ,
+  prodEnvioAppUrl ,
+  envioAppUrl ,
+  envioApiToken ,
+  hyperSyncClientTimeoutMillis ,
+  hyperSyncClientMaxRetries ,
+  hypersyncClientSerializationFormat ,
+  hypersyncClientEnableQueryCaching ,
+  Benchmark ,
+  logStrategy ,
+  Db ,
+  ClickHouseSink ,
+  Hasura ,
+  Configurable ,
+  ThrottleWrites ,
+}
+/*  Not a pure module */

package/src/Envio.gen.ts

@@ -13,7 +13,9 @@ import type {S_t as RescriptSchema_S_t} from 'rescript-schema/RescriptSchema.gen
 
 export type blockEvent = { readonly number: number };
 
-export type fuelBlockEvent = { readonly height: number; readonly chainId: number };
+export type fuelBlockEvent = { readonly height: number };
+
+export type svmOnBlockArgs<context> = { readonly slot: number; readonly context: context };
 
 export type onBlockArgs<block,context> = { readonly block: block; readonly context: context };
 
@@ -25,6 +27,12 @@ export type onBlockOptions<chain> = {
   readonly endBlock?: number
 };
 
+export type whereOperations<entity,fieldType> = {
+  readonly eq: (_1:fieldType) => Promise<entity[]>; 
+  readonly gt: (_1:fieldType) => Promise<entity[]>; 
+  readonly lt: (_1:fieldType) => Promise<entity[]>
+};
+
 export type logger = $$logger;
 
 export type effect<input,output> = $$effect<input,output>;

package/src/Envio.res

@@ -2,18 +2,14 @@
 // Should be an entry point after we get rid of the generated project.
 // Don't forget to keep index.d.ts in sync with this file.
 
-// EVM block event with 'number' field for backward compatibility
 @genType
-type blockEvent = {
-  number: int,
-}
+type blockEvent = {number: int}
 
-// Fuel block event with 'height' field
 @genType
-type fuelBlockEvent = {
-  height: int,
-  chainId: int,
-}
+type fuelBlockEvent = {height: int}
+
+@genType
+type svmOnBlockArgs<'context> = {slot: int, context: 'context}
 
 @genType
 type onBlockArgs<'block, 'context> = {
@@ -30,6 +26,13 @@ type onBlockOptions<'chain> = {
   endBlock?: int,
 }
 
+@genType
+type whereOperations<'entity, 'fieldType> = {
+  eq: 'fieldType => promise<array<'entity>>,
+  gt: 'fieldType => promise<array<'entity>>,
+  lt: 'fieldType => promise<array<'entity>>,
+}
+
 @genType.import(("./Types.ts", "Logger"))
 type logger = {
   debug: 'params. (string, ~params: {..} as 'params=?) => unit,