envio/src/Env.res.mjs

A latency and sync speed optimized, developer friendly blockchain data indexer.

// Generated by ReScript, PLEASE EDIT WITH CARE

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_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";
import * as S$RescriptSchema from "rescript-schema/src/S.res.mjs";

import 'dotenv/config'
;

let envSafe = EnvSafe.make(undefined);

let updateSyncTimeOnRestart = EnvSafe.get(envSafe, "UPDATE_SYNC_TIME_ON_RESTART", S$RescriptSchema.bool, undefined, true, undefined, undefined);

let targetBufferSize = EnvSafe.get(envSafe, "ENVIO_INDEXING_MAX_BUFFER_SIZE", S$RescriptSchema.option(S$RescriptSchema.int), undefined, undefined, undefined, undefined);

let maxAddrInPartition = EnvSafe.get(envSafe, "MAX_PARTITION_SIZE", S$RescriptSchema.int, undefined, 5000, undefined, undefined);

let maxPartitionConcurrency = EnvSafe.get(envSafe, "ENVIO_MAX_PARTITION_CONCURRENCY", S$RescriptSchema.int, undefined, 10, undefined, undefined);

let inMemoryObjectsTarget = EnvSafe.get(envSafe, "ENVIO_IN_MEMORY_OBJECTS_TARGET", S$RescriptSchema.int, undefined, 100000, undefined, undefined);

let 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);

let tuiEnvVar = EnvSafe.get(envSafe, "ENVIO_TUI", S$RescriptSchema.option(S$RescriptSchema.bool), undefined, undefined, undefined, undefined);

let logLevelSchema = S$RescriptSchema.$$enum([
  "trace",
  "debug",
  "info",
  "warn",
  "error",
  "fatal",
  "udebug",
  "uinfo",
  "uwarn",
  "uerror",
  "silent"
]);

let logFilePath = EnvSafe.get(envSafe, "LOG_FILE", S$RescriptSchema.string, undefined, "logs/envio.log", undefined, undefined);

let userLogLevel = EnvSafe.get(envSafe, "LOG_LEVEL", S$RescriptSchema.option(logLevelSchema), undefined, undefined, undefined, undefined);

let defaultFileLogLevel = EnvSafe.get(envSafe, "FILE_LOG_LEVEL", logLevelSchema, undefined, "trace", undefined, undefined);

let prodEnvioAppUrl = "https://envio.dev";

let envioAppUrl = EnvSafe.get(envSafe, "ENVIO_APP", S$RescriptSchema.string, undefined, prodEnvioAppUrl, undefined, undefined);

let envioApiToken = EnvSafe.get(envSafe, "ENVIO_API_TOKEN", S$RescriptSchema.option(S$RescriptSchema.string), undefined, undefined, undefined, undefined);

let hyperSyncClientTimeoutMillis = EnvSafe.get(envSafe, "ENVIO_HYPERSYNC_CLIENT_TIMEOUT_MILLIS", S$RescriptSchema.int, undefined, 120000, undefined, undefined);

let hypersyncClientSerializationFormat = EnvSafe.get(envSafe, "ENVIO_HYPERSYNC_CLIENT_SERIALIZATION_FORMAT", HyperSyncClient.serializationFormatSchema, undefined, "CapnProto", undefined, undefined);

let hypersyncClientEnableQueryCaching = EnvSafe.get(envSafe, "ENVIO_HYPERSYNC_CLIENT_ENABLE_QUERY_CACHING", S$RescriptSchema.bool, undefined, true, undefined, undefined);

let hypersyncLogLevel = EnvSafe.get(envSafe, "ENVIO_HYPERSYNC_LOG_LEVEL", HyperSyncClient.logLevelSchema, undefined, "info", undefined, undefined);

let 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, Stdlib_Option.getOr(userLogLevel, "info")));

let host = EnvSafe.get(envSafe, "ENVIO_PG_HOST", S$RescriptSchema.string, undefined, undefined, "localhost", undefined);

let port = EnvSafe.get(envSafe, "ENVIO_PG_PORT", S$RescriptSchema.port(S$RescriptSchema.int, undefined), undefined, undefined, 5433, undefined);

let user = EnvSafe.get(envSafe, "ENVIO_PG_USER", S$RescriptSchema.string, undefined, undefined, "postgres", undefined);

let 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);

let database = EnvSafe.get(envSafe, "ENVIO_PG_DATABASE", S$RescriptSchema.string, undefined, undefined, "envio-dev", undefined);

let publicSchema = EnvSafe.get(envSafe, "ENVIO_PG_SCHEMA", S$RescriptSchema.string, undefined, EnvSafe.get(envSafe, "ENVIO_PG_PUBLIC_SCHEMA", S$RescriptSchema.string, undefined, "public", undefined, undefined), undefined, undefined);

let ssl = EnvSafe.get(envSafe, "ENVIO_PG_SSL_MODE", Postgres.sslOptionsSchema, undefined, undefined, false, undefined);

let maxConnections = EnvSafe.get(envSafe, "ENVIO_PG_MAX_CONNECTIONS", S$RescriptSchema.int, undefined, 2, undefined, undefined);

let Db = {
  host: host,
  port: port,
  user: user,
  password: password,
  database: database,
  publicSchema: publicSchema,
  ssl: ssl,
  maxConnections: maxConnections
};

let read = ((k) => {
      const v = process.env[k];
      return v === undefined || v === "" ? undefined : v;
    });

let readAllowEmpty = ((k) => process.env[k]);

function host$1() {
  return read("ENVIO_CLICKHOUSE_HOST");
}

function database$1() {
  return read("ENVIO_CLICKHOUSE_DATABASE");
}

function username() {
  return read("ENVIO_CLICKHOUSE_USERNAME");
}

function password$1() {
  return readAllowEmpty("ENVIO_CLICKHOUSE_PASSWORD");
}

function replicated() {
  let other = read("ENVIO_CLICKHOUSE_REPLICATED");
  if (other !== undefined) {
    if (other === "true") {
      return true;
    } else {
      return Stdlib_JsError.throwWithMessage(`Invalid ENVIO_CLICKHOUSE_REPLICATED value: "` + other + `". Only "true" is accepted.`);
    }
  } else {
    return false;
  }
}

function databaseEngine() {
  return read("ENVIO_CLICKHOUSE_DATABASE_ENGINE");
}

let ClickHouse = {
  host: host$1,
  database: database$1,
  username: username,
  password: password$1,
  replicated: replicated,
  databaseEngine: databaseEngine
};

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);

let responseLimit = s !== undefined ? s : EnvSafe.get(envSafe, "HASURA_RESPONSE_LIMIT", S$RescriptSchema.option(S$RescriptSchema.int), undefined, undefined, undefined, undefined);

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);

let role = EnvSafe.get(envSafe, "HASURA_GRAPHQL_ROLE", S$RescriptSchema.string, undefined, undefined, "admin", undefined);

let secret = EnvSafe.get(envSafe, "HASURA_GRAPHQL_ADMIN_SECRET", S$RescriptSchema.string, undefined, undefined, "testing", undefined);

let aggregateEntities = EnvSafe.get(envSafe, "ENVIO_HASURA_PUBLIC_AGGREGATE", S$RescriptSchema.union([
  S$RescriptSchema.array(S$RescriptSchema.string),
  S$RescriptSchema.transform(S$RescriptSchema.string, s => ({
    p: string => {
      let entities = string.split("&");
      let 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);

let Hasura = {
  enabled: enabled,
  responseLimit: responseLimit,
  graphqlEndpoint: graphqlEndpoint,
  url: url,
  role: role,
  secret: secret,
  aggregateEntities: aggregateEntities
};

let initialBlockInterval = EnvSafe.get(envSafe, "ENVIO_RPC_INITIAL_BLOCK_INTERVAL", S$RescriptSchema.option(S$RescriptSchema.int), undefined, undefined, undefined, undefined);

let backoffMultiplicative = EnvSafe.get(envSafe, "ENVIO_RPC_BACKOFF_MULTIPLICATIVE", S$RescriptSchema.option(S$RescriptSchema.float), undefined, undefined, undefined, undefined);

let accelerationAdditive = EnvSafe.get(envSafe, "ENVIO_RPC_ACCELERATION_ADDITIVE", S$RescriptSchema.option(S$RescriptSchema.int), undefined, undefined, undefined, undefined);

let intervalCeiling = EnvSafe.get(envSafe, "ENVIO_RPC_INTERVAL_CEILING", S$RescriptSchema.option(S$RescriptSchema.int), undefined, undefined, undefined, undefined);

let SyncConfig = {
  initialBlockInterval: initialBlockInterval,
  backoffMultiplicative: backoffMultiplicative,
  accelerationAdditive: accelerationAdditive,
  intervalCeiling: intervalCeiling
};

let Configurable = {
  SyncConfig: SyncConfig
};

let chainMetadataIntervalMillis = EnvSafe.get(envSafe, "ENVIO_THROTTLE_CHAIN_METADATA_INTERVAL_MILLIS", S$RescriptSchema.int, undefined, undefined, 500, undefined);

let pruneStaleDataIntervalMillis = EnvSafe.get(envSafe, "ENVIO_THROTTLE_PRUNE_STALE_DATA_INTERVAL_MILLIS", S$RescriptSchema.int, undefined, undefined, 30000, undefined);

let ThrottleWrites = {
  chainMetadataIntervalMillis: chainMetadataIntervalMillis,
  pruneStaleDataIntervalMillis: pruneStaleDataIntervalMillis
};

EnvSafe.close(envSafe);

export {
  updateSyncTimeOnRestart,
  targetBufferSize,
  maxAddrInPartition,
  maxPartitionConcurrency,
  inMemoryObjectsTarget,
  serverPort,
  tuiEnvVar,
  logLevelSchema,
  logFilePath,
  userLogLevel,
  defaultFileLogLevel,
  prodEnvioAppUrl,
  envioAppUrl,
  envioApiToken,
  hyperSyncClientTimeoutMillis,
  hypersyncClientSerializationFormat,
  hypersyncClientEnableQueryCaching,
  hypersyncLogLevel,
  logStrategy,
  Db,
  ClickHouse,
  Hasura,
  Configurable,
  ThrottleWrites,
}
/*  Not a pure module */