envio 3.0.0-alpha.21 → 3.0.0-alpha.22

package/src/Env.res.mjs

@@ -1,9 +1,9 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
-import * as EnvSafe from "rescript-envsafe/src/EnvSafe.res.mjs";
+import * as EnvSafe from "./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 Belt_Option from "@rescript/runtime/lib/es6/Belt_Option.js";
 import * as HyperSyncClient from "./sources/HyperSyncClient.res.mjs";
 import * as S$RescriptSchema from "rescript-schema/src/S.res.mjs";
 import * as HypersyncClient from "@envio-dev/hypersync-client";
@@ -11,87 +11,87 @@ import * as HypersyncClient from "@envio-dev/hypersync-client";
 import 'dotenv/config'
 ;
 
-var envSafe = EnvSafe.make(undefined);
+let envSafe = EnvSafe.make(undefined);
 
-var updateSyncTimeOnRestart = EnvSafe.get(envSafe, "UPDATE_SYNC_TIME_ON_RESTART", S$RescriptSchema.bool, undefined, true, undefined, undefined);
+let 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);
+let 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);
+let 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);
+let maxPartitionConcurrency = EnvSafe.get(envSafe, "ENVIO_MAX_PARTITION_CONCURRENCY", S$RescriptSchema.int, undefined, 10, 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);
+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);
 
-var tuiOffEnvVar = EnvSafe.get(envSafe, "TUI_OFF", S$RescriptSchema.bool, undefined, false, undefined, undefined);
+let 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"
-    ]);
+let 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);
+let 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);
+let 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);
+let defaultFileLogLevel = EnvSafe.get(envSafe, "FILE_LOG_LEVEL", logLevelSchema, undefined, "trace", undefined, undefined);
 
-var prodEnvioAppUrl = "https://envio.dev";
+let prodEnvioAppUrl = "https://envio.dev";
 
-var envioAppUrl = EnvSafe.get(envSafe, "ENVIO_APP", S$RescriptSchema.string, undefined, prodEnvioAppUrl, undefined, undefined);
+let 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);
+let 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);
+let 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);
+let 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);
+let 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);
+let hypersyncClientEnableQueryCaching = EnvSafe.get(envSafe, "ENVIO_HYPERSYNC_CLIENT_ENABLE_QUERY_CACHING", S$RescriptSchema.bool, undefined, true, undefined, undefined);
 
-var hypersyncLogLevel = EnvSafe.get(envSafe, "ENVIO_HYPERSYNC_LOG_LEVEL", HyperSyncClient.logLevelSchema, undefined, "info", undefined, undefined);
+let hypersyncLogLevel = EnvSafe.get(envSafe, "ENVIO_HYPERSYNC_LOG_LEVEL", HyperSyncClient.logLevelSchema, undefined, "info", undefined, undefined);
 
 HypersyncClient.setLogLevel(hypersyncLogLevel);
 
-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);
+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, Belt_Option.getWithDefault(userLogLevel, "info")));
 
-var host = EnvSafe.get(envSafe, "ENVIO_PG_HOST", S$RescriptSchema.string, undefined, undefined, "localhost", undefined);
+let 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);
+let 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);
+let 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);
+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);
 
-var database = EnvSafe.get(envSafe, "ENVIO_PG_DATABASE", S$RescriptSchema.string, undefined, undefined, "envio-dev", undefined);
+let database = EnvSafe.get(envSafe, "ENVIO_PG_DATABASE", S$RescriptSchema.string, undefined, undefined, "envio-dev", undefined);
 
-var 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 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);
 
-var ssl = EnvSafe.get(envSafe, "ENVIO_PG_SSL_MODE", Postgres.sslOptionsSchema, undefined, undefined, false, undefined);
+let ssl = EnvSafe.get(envSafe, "ENVIO_PG_SSL_MODE", Postgres.sslOptionsSchema, undefined, undefined, false, undefined);
 
-var maxConnections = EnvSafe.get(envSafe, "ENVIO_PG_MAX_CONNECTIONS", S$RescriptSchema.$$int, undefined, 2, undefined, undefined);
+let maxConnections = EnvSafe.get(envSafe, "ENVIO_PG_MAX_CONNECTIONS", S$RescriptSchema.int, undefined, 2, undefined, undefined);
 
-var Db = {
+let Db = {
   host: host,
   port: port,
   user: user,
@@ -102,53 +102,64 @@ var Db = {
   maxConnections: maxConnections
 };
 
-var host$1 = EnvSafe.get(envSafe, "ENVIO_CLICKHOUSE_SINK_HOST", S$RescriptSchema.option(S$RescriptSchema.string), undefined, undefined, undefined, undefined);
+let read = ((k) => {
+      const v = process.env[k];
+      return v === undefined || v === "" ? undefined : v;
+    });
 
-var database$1 = EnvSafe.get(envSafe, "ENVIO_CLICKHOUSE_SINK_DATABASE", S$RescriptSchema.option(S$RescriptSchema.string), undefined, undefined, undefined, undefined);
+function host$1() {
+  return read("ENVIO_CLICKHOUSE_HOST");
+}
 
-var username = host$1 !== undefined ? EnvSafe.get(envSafe, "ENVIO_CLICKHOUSE_SINK_USERNAME", S$RescriptSchema.string, undefined, undefined, undefined, undefined) : "";
+function database$1() {
+  return read("ENVIO_CLICKHOUSE_DATABASE");
+}
 
-var password$1 = host$1 !== undefined ? EnvSafe.get(envSafe, "ENVIO_CLICKHOUSE_SINK_PASSWORD", S$RescriptSchema.string, undefined, undefined, undefined, undefined) : "";
+function username() {
+  return read("ENVIO_CLICKHOUSE_USERNAME");
+}
+
+function password$1() {
+  return read("ENVIO_CLICKHOUSE_PASSWORD");
+}
 
-var ClickHouseSink = {
+let ClickHouse = {
   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);
+let 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);
+let 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);
+let 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);
+let 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);
+let url = graphqlEndpoint.slice(0, -"/v1/metadata".length | 0);
 
-var role = EnvSafe.get(envSafe, "HASURA_GRAPHQL_ROLE", S$RescriptSchema.string, undefined, undefined, "admin", undefined);
+let 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);
+let 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);
+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);
 
-var Hasura = {
+let Hasura = {
   enabled: enabled,
   responseLimit: responseLimit,
   graphqlEndpoint: graphqlEndpoint,
@@ -158,30 +169,30 @@ var Hasura = {
   aggregateEntities: aggregateEntities
 };
 
-var initialBlockInterval = EnvSafe.get(envSafe, "ENVIO_RPC_INITIAL_BLOCK_INTERVAL", S$RescriptSchema.option(S$RescriptSchema.$$int), undefined, undefined, undefined, undefined);
+let 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);
+let 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);
+let 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);
+let intervalCeiling = EnvSafe.get(envSafe, "ENVIO_RPC_INTERVAL_CEILING", S$RescriptSchema.option(S$RescriptSchema.int), undefined, undefined, undefined, undefined);
 
-var SyncConfig = {
+let SyncConfig = {
   initialBlockInterval: initialBlockInterval,
   backoffMultiplicative: backoffMultiplicative,
   accelerationAdditive: accelerationAdditive,
   intervalCeiling: intervalCeiling
 };
 
-var Configurable = {
+let Configurable = {
   SyncConfig: SyncConfig
 };
 
-var chainMetadataIntervalMillis = EnvSafe.get(envSafe, "ENVIO_THROTTLE_CHAIN_METADATA_INTERVAL_MILLIS", S$RescriptSchema.$$int, undefined, undefined, 500, undefined);
+let 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);
+let pruneStaleDataIntervalMillis = EnvSafe.get(envSafe, "ENVIO_THROTTLE_PRUNE_STALE_DATA_INTERVAL_MILLIS", S$RescriptSchema.int, undefined, undefined, 30000, undefined);
 
-var ThrottleWrites = {
+let ThrottleWrites = {
   chainMetadataIntervalMillis: chainMetadataIntervalMillis,
   pruneStaleDataIntervalMillis: pruneStaleDataIntervalMillis
 };
@@ -189,29 +200,29 @@ var ThrottleWrites = {
 EnvSafe.close(envSafe);
 
 export {
-  updateSyncTimeOnRestart ,
-  targetBufferSize ,
-  maxAddrInPartition ,
-  maxPartitionConcurrency ,
-  serverPort ,
-  tuiOffEnvVar ,
-  logLevelSchema ,
-  logFilePath ,
-  userLogLevel ,
-  defaultFileLogLevel ,
-  prodEnvioAppUrl ,
-  envioAppUrl ,
-  envioApiToken ,
-  hyperSyncClientTimeoutMillis ,
-  hyperSyncClientMaxRetries ,
-  hypersyncClientSerializationFormat ,
-  hypersyncClientEnableQueryCaching ,
-  hypersyncLogLevel ,
-  logStrategy ,
-  Db ,
-  ClickHouseSink ,
-  Hasura ,
-  Configurable ,
-  ThrottleWrites ,
+  updateSyncTimeOnRestart,
+  targetBufferSize,
+  maxAddrInPartition,
+  maxPartitionConcurrency,
+  serverPort,
+  tuiOffEnvVar,
+  logLevelSchema,
+  logFilePath,
+  userLogLevel,
+  defaultFileLogLevel,
+  prodEnvioAppUrl,
+  envioAppUrl,
+  envioApiToken,
+  hyperSyncClientTimeoutMillis,
+  hyperSyncClientMaxRetries,
+  hypersyncClientSerializationFormat,
+  hypersyncClientEnableQueryCaching,
+  hypersyncLogLevel,
+  logStrategy,
+  Db,
+  ClickHouse,
+  Hasura,
+  Configurable,
+  ThrottleWrites,
 }
 /*  Not a pure module */

package/src/EnvSafe.res

@@ -0,0 +1,269 @@
+// Vendored from rescript-envsafe v5.0.0 (https://github.com/DZakh/rescript-envsafe).
+// Kept in-tree so it's compiled with our ReScript toolchain and the emitted
+// JS artifacts stay under our control (upstream's published JS may lag or
+// target a different ReScript version). Diff against the v5.0.0 source when
+// pulling upstream fixes. See LICENSE for attribution.
+@@uncurried
+
+%%private(external magic: 'a => 'b = "%identity")
+
+module Stdlib = {
+  module Dict = {
+    @get_index external get: (dict<'a>, string) => option<'a> = ""
+  }
+
+  module Option = {
+    @inline
+    let forEach = (option, fn) => {
+      switch option {
+      | Some(v) => fn(v)
+      | None => ()
+      }
+    }
+  }
+
+  module Window = {
+    let alert = (message: string): unit => {
+      message->ignore
+      if %raw(`typeof window !== 'undefined' && window.alert`) {
+        %raw(`window.alert(message)`)
+      }
+    }
+  }
+
+  module Exn = {
+    type error
+
+    @new
+    external makeError: string => error = "Error"
+    @new
+    external makeTypeError: string => error = "TypeError"
+
+    let raiseError = (error: error): 'a => error->magic->throw
+  }
+}
+
+module Error = {
+  @inline
+  let panic = message =>
+    Stdlib.Exn.raiseError(Stdlib.Exn.makeError(`[rescript-envsafe] ${message}`))
+}
+
+type env = dict<string>
+type invalidIssue = {name: string, error: S.error, input: option<string>}
+type missingIssue = {name: string, input: option<string>}
+type t = {
+  env: env,
+  mutable isLocked: bool,
+  mutable maybeMissingIssues: option<array<missingIssue>>,
+  mutable maybeInvalidIssues: option<array<invalidIssue>>,
+}
+
+module Env = {
+  @val
+  external // FIXME: process might be missing
+  default: dict<string> = "process.env"
+}
+
+let mixinMissingIssue = (envSafe, issue) => {
+  switch envSafe.maybeMissingIssues {
+  | Some(missingIssues) => missingIssues->Array.push(issue)->ignore
+  | None => envSafe.maybeMissingIssues = Some([issue])
+  }
+}
+
+let mixinInvalidIssue = (envSafe, issue: invalidIssue) => {
+  switch envSafe.maybeInvalidIssues {
+  | Some(invalidIssues) => invalidIssues->Array.push(issue)->ignore
+  | None => envSafe.maybeInvalidIssues = Some([issue])
+  }
+}
+
+let make = (~env=Env.default) => {
+  {env, isLocked: false, maybeMissingIssues: None, maybeInvalidIssues: None}
+}
+
+let close = envSafe => {
+  if envSafe.isLocked {
+    Error.panic("EnvSafe is already closed.")
+  }
+  envSafe.isLocked = true
+  switch (envSafe.maybeMissingIssues, envSafe.maybeInvalidIssues) {
+  | (None, None) => ()
+  | (maybeMissingIssues, maybeInvalidIssues) => {
+      let text = {
+        let line = "========================================"
+        let output = [line]
+
+        maybeInvalidIssues->Stdlib.Option.forEach(invalidIssues => {
+          output->Array.push("❌ Invalid environment variables:")->ignore
+          invalidIssues->Array.forEach(issue => {
+            output->Array.push(`    ${issue.name}: ${issue.error->S.Error.message}`)->ignore
+          })
+        })
+
+        maybeMissingIssues->Stdlib.Option.forEach(missingIssues => {
+          output->Array.push("💨 Missing environment variables:")->ignore
+          missingIssues->Array.forEach(issue => {
+            output
+            ->Array.push(
+              `    ${issue.name}: ${switch issue.input {
+                | Some("") => "Disallowed empty string"
+                | _ => "Missing value"
+                }}`,
+            )
+            ->ignore
+          })
+        })
+
+        output->Array.push(line)->ignore
+        output->Array.joinUnsafe("\n")
+      }
+
+      Console.error(text)
+      Stdlib.Window.alert(text)
+      Stdlib.Exn.raiseError(Stdlib.Exn.makeTypeError(text))
+    }
+  }
+}
+
+let boolCoerce = string =>
+  switch string {
+  | "true"
+  | "t"
+  | "1" =>
+    true->magic
+  | "false"
+  | "f"
+  | "0" =>
+    false->magic
+  | _ => string
+  }
+
+let numberCoerce = string => {
+  let float = %raw(`+string`)
+  if Float.isNaN(float) {
+    string
+  } else {
+    float->magic
+  }
+}
+
+let bigintCoerce = string => {
+  try string->BigInt.fromStringOrThrow->magic catch {
+  | _ => string
+  }
+}
+
+let jsonCoerce = string => {
+  try string->JSON.parseOrThrow->magic catch {
+  | _ => string
+  }
+}
+
+@inline
+let prepareUnionSchemaCoercion = schema => {
+  schema->S.preprocess(s => {
+    let tagged = switch s.schema->S.classify {
+    | Option(optionalSchema) => optionalSchema->S.classify
+    | tagged => tagged
+    }
+    switch tagged {
+    | Literal(Boolean(_))
+    | Bool => {
+        parser: unknown => unknown->magic->boolCoerce->magic,
+      }
+    | Literal(BigInt(_))
+    | BigInt => {
+        parser: unknown => unknown->magic->bigintCoerce->magic,
+      }
+    | Literal(Number(_))
+    | Int
+    | Float => {
+        parser: unknown => unknown->magic->numberCoerce->magic,
+      }
+    | String
+    | Literal(String(_))
+    | Union(_)
+    | Never => {}
+    | _ => {
+        parser: unknown => unknown->magic->jsonCoerce->magic,
+      }
+    }
+  })
+}
+
+let get = (
+  envSafe,
+  name,
+  schema,
+  ~allowEmpty=false,
+  ~fallback as maybeFallback=?,
+  ~devFallback as maybeDevFallback=?,
+  ~input as maybeInlinedInput=?,
+) => {
+  if envSafe.isLocked {
+    Error.panic("EnvSafe is closed. Make a new one to get access to environment variables.")
+  }
+  let input = switch maybeInlinedInput {
+  | Some(inlinedInput) => inlinedInput
+  | None => envSafe.env->Stdlib.Dict.get(name)
+  }
+  let isMissing = switch (input, allowEmpty) {
+  | (None, _)
+  | (Some(""), false) => true
+  | _ => false
+  }
+  let isOptional = switch schema->S.classify {
+  | Option(_) => true
+  | _ => false
+  }
+  if isMissing && !isOptional {
+    switch (maybeDevFallback, maybeFallback) {
+    | (Some(devFallback), _)
+      if envSafe.env->Stdlib.Dict.get("NODE_ENV") !== Some("production") => devFallback
+    | (_, Some(fallback)) => fallback
+    | _ => {
+        envSafe->mixinMissingIssue({name, input})
+        %raw(`undefined`)
+      }
+    }
+  } else {
+    let tagged = switch schema->S.classify {
+    | Option(optionalSchema) => optionalSchema->S.classify
+    | tagged => tagged
+    }
+    let input = switch input {
+    | Some("") if !allowEmpty => None
+    | None => None
+    | Some(string) =>
+      switch tagged {
+      | Literal(Boolean(_))
+      | Bool =>
+        string->boolCoerce
+      | Literal(BigInt(_))
+      | BigInt =>
+        string->bigintCoerce
+      | Literal(Number(_))
+      | Int
+      | Float =>
+        string->numberCoerce
+      | String
+      | Literal(String(_))
+      | Never
+      | Union(_) => string
+      | _ => string->jsonCoerce
+      }->Some
+    }
+    let schema = switch tagged {
+    | Union(_) => prepareUnionSchemaCoercion(schema)
+    | _ => schema
+    }
+    try input->S.parseOrThrow(schema) catch {
+    | S.Raised(error) => {
+        envSafe->mixinInvalidIssue({name, error, input})
+        %raw(`undefined`)
+      }
+    }
+  }
+}