envio 2.8.1 → 2.9.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "envio",
-  "version": "v2.8.1",
+  "version": "v2.9.0",
   "description": "A latency and sync speed optimized, developer friendly blockchain data indexer.",
   "bin": "./bin.js",
   "repository": {
@@ -23,15 +23,15 @@
   },
   "homepage": "https://envio.dev",
   "optionalDependencies": {
-    "envio-linux-x64": "v2.8.1",
-    "envio-linux-arm64": "v2.8.1",
-    "envio-darwin-x64": "v2.8.1",
-    "envio-darwin-arm64": "v2.8.1"
+    "envio-linux-x64": "v2.9.0",
+    "envio-linux-arm64": "v2.9.0",
+    "envio-darwin-x64": "v2.9.0",
+    "envio-darwin-arm64": "v2.9.0"
   },
   "dependencies": {
     "@envio-dev/hypersync-client": "0.6.2",
     "rescript": "11.1.3",
-    "rescript-schema": "8.2.0",
+    "rescript-schema": "8.1.0",
     "viem": "2.21.0"
   },
   "files": [

package/src/Enum.res

@@ -0,0 +1,22 @@
+// Graphql Enum Type Variants
+type enum<'a> = {
+  name: string,
+  variants: array<'a>,
+  schema: S.t<'a>,
+  default: 'a,
+}
+
+let make = (~name, ~variants) => {
+  name,
+  variants,
+  schema: Utils.Schema.enum(variants),
+  default: switch variants->Belt.Array.get(0) {
+  | Some(v) => v
+  | None => Js.Exn.raiseError("No variants defined for enum " ++ name)
+  },
+}
+
+module type S = {
+  type t
+  let enum: enum<t>
+}

package/src/LogSelection.res

@@ -0,0 +1,60 @@
+type topicSelection = {
+  topic0: array<EvmTypes.Hex.t>,
+  topic1: array<EvmTypes.Hex.t>,
+  topic2: array<EvmTypes.Hex.t>,
+  topic3: array<EvmTypes.Hex.t>,
+}
+
+exception MissingRequiredTopic0
+let makeTopicSelection = (~topic0, ~topic1=[], ~topic2=[], ~topic3=[]) =>
+  if topic0->Utils.Array.isEmpty {
+    Error(MissingRequiredTopic0)
+  } else {
+    {
+      topic0,
+      topic1,
+      topic2,
+      topic3,
+    }->Ok
+  }
+
+let hasFilters = ({topic1, topic2, topic3}: topicSelection) => {
+  [topic1, topic2, topic3]->Js.Array2.find(topic => !Utils.Array.isEmpty(topic))->Belt.Option.isSome
+}
+
+/**
+For a group of topic selections, if multiple only use topic0, then they can be compressed into one
+selection combining the topic0s
+*/
+let compressTopicSelectionsOrThrow = (topicSelections: array<topicSelection>) => {
+  let topic0sOfSelectionsWithoutFilters = []
+
+  let selectionsWithFilters = []
+
+  topicSelections->Belt.Array.forEach(selection => {
+    if selection->hasFilters {
+      selectionsWithFilters->Js.Array2.push(selection)->ignore
+    } else {
+      selection.topic0->Belt.Array.forEach(topic0 => {
+        topic0sOfSelectionsWithoutFilters->Js.Array2.push(topic0)->ignore
+      })
+    }
+  })
+
+  switch topic0sOfSelectionsWithoutFilters {
+  | [] => selectionsWithFilters
+  | topic0 =>
+    let selectionWithoutFilters = makeTopicSelection(~topic0)->Utils.unwrapResultExn
+    Belt.Array.concat([selectionWithoutFilters], selectionsWithFilters)
+  }
+}
+
+type t = {
+  addresses: array<Address.t>,
+  topicSelections: array<topicSelection>,
+}
+
+let makeOrThrow = (~addresses, ~topicSelections) => {
+  let topicSelections = compressTopicSelectionsOrThrow(topicSelections)
+  {addresses, topicSelections}
+}

package/src/Utils.res

@@ -222,6 +222,8 @@ let unwrapResultExn = res =>
 external queueMicrotask: (unit => unit) => unit = "queueMicrotask"
 
 module Schema = {
+  let enum = items => S.union(items->Belt.Array.mapU(S.literal))
+
   let getNonOptionalFieldNames = schema => {
     let acc = []
     switch schema->S.classify {

package/src/bindings/BigInt.res

@@ -0,0 +1,57 @@
+%%private(
+  @inline
+  let unsafeToOption: (unit => 'a) => option<'a> = unsafeFunc => {
+    try {
+      unsafeFunc()->Some
+    } catch {
+    | Js.Exn.Error(_obj) => None
+    }
+  }
+)
+
+// constructors and methods
+@val external fromInt: int => bigint = "BigInt"
+@val external fromStringUnsafe: string => bigint = "BigInt"
+@val external fromUnknownUnsafe: unknown => bigint = "BigInt"
+let fromString = str => unsafeToOption(() => str->fromStringUnsafe)
+@send external toString: bigint => string = "toString"
+let toInt = (b: bigint): option<int> => b->toString->Belt.Int.fromString
+
+//silence unused var warnings for raw bindings
+@@warning("-27")
+// operation
+let add = (a: bigint, b: bigint): bigint => %raw("a + b")
+let sub = (a: bigint, b: bigint): bigint => %raw("a - b")
+let mul = (a: bigint, b: bigint): bigint => %raw("a * b")
+let div = (a: bigint, b: bigint): bigint => %raw("b > 0n ? a / b : 0n")
+let pow = (a: bigint, b: bigint): bigint => %raw("a ** b")
+let mod = (a: bigint, b: bigint): bigint => %raw("b > 0n ? a % b : 0n")
+
+// comparison
+let eq = (a: bigint, b: bigint): bool => %raw("a === b")
+let neq = (a: bigint, b: bigint): bool => %raw("a !== b")
+let gt = (a: bigint, b: bigint): bool => %raw("a > b")
+let gte = (a: bigint, b: bigint): bool => %raw("a >= b")
+let lt = (a: bigint, b: bigint): bool => %raw("a < b")
+let lte = (a: bigint, b: bigint): bool => %raw("a <= b")
+
+module Bitwise = {
+  let shift_left = (a: bigint, b: bigint): bigint => %raw("a << b")
+  let shift_right = (a: bigint, b: bigint): bigint => %raw("a >> b")
+  let logor = (a: bigint, b: bigint): bigint => %raw("a | b")
+  let logand = (a: bigint, b: bigint): bigint => %raw("a & b")
+}
+
+let zero = fromInt(0)
+
+let schema =
+  S.string
+  ->S.setName("BigInt")
+  ->S.transform(s => {
+    parser: (. string) =>
+      switch string->fromString {
+      | Some(bigInt) => bigInt
+      | None => s.fail(. "The string is not valid BigInt")
+      },
+    serializer: (. bigint) => bigint->toString,
+  })

package/src/bindings/Express.res

@@ -0,0 +1,29 @@
+// Inspired by https://github.com/bloodyowl/rescript-express
+
+type app
+
+// "default" &  seem to conflict a bit right now
+// https://github.com/rescript-lang/rescript-compiler/issues/5004
+@module external makeCjs: unit => app = "express"
+@module("express") external make: unit => app = "default"
+
+type req
+type res
+
+type handler = (req, res) => unit
+type middleware = (req, res, unit => unit) => unit
+
+@module("express") external jsonMiddleware: unit => middleware = "json"
+
+@send external use: (app, middleware) => unit = "use"
+
+@send external get: (app, string, handler) => unit = "get"
+
+type server
+
+@send external listen: (app, int) => server = "listen"
+
+// res methods
+@send external sendStatus: (res, int) => res = "sendStatus"
+@send external set: (res, string, string) => unit = "set"
+@send external endWithData: (res, 'a) => res = "end"

package/src/bindings/Postgres.res

@@ -0,0 +1,98 @@
+type sql
+
+type undefinedTransform = | @as(undefined) Undefined | @as(null) Null
+
+type transformConfig = {
+  undefined?: undefinedTransform, // Transforms undefined values (eg. to null) (default: undefined)
+  // column?: 'c => 'd, // Transforms incoming column names (default: fn)
+  // value?: 'e => 'f, // Transforms incoming row values (default: fn)
+  // row?: 'g => 'h, // Transforms entire rows (default: fn)
+}
+
+type connectionConfig = {
+  applicationName?: string, // Default application_name (default: 'postgres.js')
+  // Other connection parameters, see https://www.postgresql.org/docs/current/runtime-config-client.html
+}
+type streamDuplex
+type buffer
+type secureContext
+
+type onread = {
+  buffer: Js.Nullable.t<array<int>> => array<int>,
+  callback: (int, array<int>) => unit,
+}
+
+type tlsConnectOptions = {
+  enableTrace?: bool,
+  host?: string /* Default: "localhost" */,
+  port?: int,
+  path?: string,
+  socket?: streamDuplex,
+  allowHalfOpen?: bool /* Default: false */,
+  rejectUnauthorized?: bool /* Default: true */,
+  pskCallback?: unit => unit,
+  @as("ALPNProtocols") alpnProtocols?: array<string>, //| array<Buffer> | array<typedArray> | array<DataView> | Buffer | typedArray | DataView,
+  servername?: string,
+  checkServerIdentity?: 'a. (string, 'a) => option<Js.Exn.t>,
+  session?: buffer,
+  minDHSize?: int /* Default: 1024 */,
+  highWaterMark?: int /* Default: 16 * 1024 */,
+  secureContext?: secureContext,
+  onread?: onread,
+  /* Additional properties from tls.createSecureContext() and socket.connect() */
+  // [key: string]: Js.Json.t,
+}
+
+@unboxed
+type sslOptions =
+  | Bool(bool)
+  | TLSConnectOptions(tlsConnectOptions)
+  | @as("require") Require
+  | @as("allow") Allow
+  | @as("prefer") Prefer
+  | @as("verify-full") VerifyFull
+
+let sslOptionsSchema: S.schema<sslOptions> = Utils.Schema.enum([
+  Bool(true),
+  Bool(false),
+  Require,
+  Allow,
+  Prefer,
+  VerifyFull,
+  //No schema created for tlsConnectOptions obj
+])
+
+type poolConfig = {
+  host?: string, // Postgres ip address[es] or domain name[s] (default: '')
+  port?: int, // Postgres server port[s] (default: 5432)
+  path?: string, // unix socket path (usually '/tmp') (default: '')
+  database?: string, // Name of database to connect to (default: '')
+  username?: string, // Username of database user (default: '')
+  password?: string, // Password of database user (default: '')
+  ssl?: sslOptions, // true, prefer, require, tls.connect options (default: false)
+  max?: int, // Max number of connections (default: 10)
+  maxLifetime?: option<int>, // Max lifetime in seconds (more info below) (default: null)
+  idleTimeout?: int, // Idle connection timeout in seconds (default: 0)
+  connectTimeout?: int, // Connect timeout in seconds (default: 30)
+  prepare?: bool, // Automatic creation of prepared statements (default: true)
+  // types?: array<'a>, // Array of custom types, see more below (default: [])
+  onnotice?: string => unit, // Default console.log, set false to silence NOTICE (default: fn)
+  onParameter?: (string, string) => unit, // (key, value) when server param change (default: fn)
+  debug?: 'a. 'a => unit, //(connection, query, params, types) => unit, // Is called with (connection, query, params, types) (default: fn)
+  socket?: unit => unit, // fn returning custom socket to use (default: fn)
+  transform?: transformConfig,
+  connection?: connectionConfig,
+  targetSessionAttrs?: option<string>, // Use 'read-write' with multiple hosts to ensure only connecting to primary (default: null)
+  fetchTypes?: bool, // Automatically fetches types on connect on initial connection. (default: true)
+}
+
+@module
+external makeSql: (~config: poolConfig) => sql = "postgres"
+
+@send external beginSql: (sql, sql => array<promise<unit>>) => promise<unit> = "begin"
+
+// TODO: can explore this approach (https://forum.rescript-lang.org/t/rfc-support-for-tagged-template-literals/3744)
+// @send @variadic
+// external sql:  array<string>  => (sql, array<string>) => int = "sql"
+
+@send external unsafe: (sql, string) => promise<'a> = "unsafe"

package/src/bindings/Promise.res

@@ -0,0 +1,52 @@
+type t<+'a> = promise<'a>
+
+@new
+external make: ((@uncurry 'a => unit, 'e => unit) => unit) => t<'a> = "Promise"
+
+@val @scope("Promise")
+external resolve: 'a => t<'a> = "resolve"
+
+@send external then: (t<'a>, @uncurry 'a => t<'b>) => t<'b> = "then"
+
+@send
+external thenResolve: (t<'a>, @uncurry 'a => 'b) => t<'b> = "then"
+
+@send external finally: (t<'a>, unit => unit) => t<'a> = "finally"
+
+@scope("Promise") @val
+external reject: exn => t<_> = "reject"
+
+@scope("Promise") @val
+external all: array<t<'a>> => t<array<'a>> = "all"
+
+@scope("Promise") @val
+external all2: ((t<'a>, t<'b>)) => t<('a, 'b)> = "all"
+
+@scope("Promise") @val
+external all3: ((t<'a>, t<'b>, t<'c>)) => t<('a, 'b, 'c)> = "all"
+
+@scope("Promise") @val
+external all4: ((t<'a>, t<'b>, t<'c>, t<'d>)) => t<('a, 'b, 'c, 'd)> = "all"
+
+@scope("Promise") @val
+external all5: ((t<'a>, t<'b>, t<'c>, t<'d>, t<'e>)) => t<('a, 'b, 'c, 'd, 'e)> = "all"
+
+@scope("Promise") @val
+external all6: ((t<'a>, t<'b>, t<'c>, t<'d>, t<'e>, t<'f>)) => t<('a, 'b, 'c, 'd, 'e, 'f)> = "all"
+
+@send
+external catch: (t<'a>, @uncurry exn => t<'a>) => t<'a> = "catch"
+
+let catch = (promise: promise<'a>, callback: exn => promise<'a>): promise<'a> => {
+  catch(promise, err => {
+    callback(Js.Exn.anyToExnInternal(err))
+  })
+}
+
+@scope("Promise") @val
+external race: array<t<'a>> => t<'a> = "race"
+
+external done: promise<'a> => unit = "%ignore"
+
+external unsafe_async: 'a => promise<'a> = "%identity"
+external unsafe_await: promise<'a> => 'a = "?await"