envio 2.16.1 → 2.17.1

package/src/Logging.res

@@ -0,0 +1,179 @@
+open Pino
+
+type logStrategyType =
+  | @as("ecs-file") EcsFile
+  | @as("ecs-console") EcsConsole
+  | @as("ecs-console-multistream") EcsConsoleMultistream
+  | @as("file-only") FileOnly
+  | @as("console-raw") ConsoleRaw
+  | @as("console-pretty") ConsolePretty
+  | @as("both-prettyconsole") Both
+
+let logLevels = [
+  // custom levels
+  ("udebug", 32),
+  ("uinfo", 34),
+  ("uwarn", 36),
+  ("uerror", 38),
+  // Default levels
+  ("trace", 10),
+  ("debug", 20),
+  ("info", 30),
+  ("warn", 40),
+  ("error", 50),
+  ("fatal", 60),
+]->Js.Dict.fromArray
+
+%%private(let logger = ref(None))
+
+let setLogger = (~logStrategy, ~logFilePath, ~defaultFileLogLevel, ~userLogLevel) => {
+  // Currently unused - useful if using multiple transports.
+  // let pinoRaw = {"target": "pino/file", "level": Config.userLogLevel}
+  let pinoFile: Transport.transportTarget = {
+    target: "pino/file",
+    options: {
+      "destination": logFilePath,
+      "append": true,
+      "mkdir": true,
+    }->Transport.makeTransportOptions,
+    level: defaultFileLogLevel,
+  }
+
+  let makeMultiStreamLogger =
+    MultiStreamLogger.make(~userLogLevel, ~defaultFileLogLevel, ~customLevels=logLevels, ...)
+
+  logger :=
+    Some(
+      switch logStrategy {
+      | EcsFile =>
+        makeWithOptionsAndTransport(
+          {
+            ...Pino.ECS.make(),
+            customLevels: logLevels,
+          },
+          Transport.make(pinoFile),
+        )
+      | EcsConsoleMultistream =>
+        makeMultiStreamLogger(~logFile=None, ~options=Some(Pino.ECS.make()))
+      | EcsConsole =>
+        make({
+          ...Pino.ECS.make(),
+          level: userLogLevel,
+          customLevels: logLevels,
+        })
+      | FileOnly =>
+        makeWithOptionsAndTransport(
+          {
+            customLevels: logLevels,
+            level: defaultFileLogLevel,
+          },
+          Transport.make(pinoFile),
+        )
+      | ConsoleRaw => makeMultiStreamLogger(~logFile=None, ~options=None)
+      | ConsolePretty => makeMultiStreamLogger(~logFile=None, ~options=None)
+      | Both => makeMultiStreamLogger(~logFile=Some(logFilePath), ~options=None)
+      },
+    )
+}
+
+let getLogger = () => {
+  switch logger.contents {
+  | Some(logger) => logger
+  | None => Js.Exn.raiseError("Unreachable code. Logger not initialized")
+  }
+}
+
+let setLogLevel = (level: Pino.logLevel) => {
+  getLogger()->setLevel(level)
+}
+
+let trace = message => {
+  getLogger().trace(message->createPinoMessage)
+}
+
+let debug = message => {
+  getLogger().debug(message->createPinoMessage)
+}
+
+let info = message => {
+  getLogger().info(message->createPinoMessage)
+}
+
+let warn = message => {
+  getLogger().warn(message->createPinoMessage)
+}
+
+let error = message => {
+  getLogger().error(message->createPinoMessage)
+}
+let errorWithExn = (error, message) => {
+  getLogger()->Pino.errorExn(message->createPinoMessageWithError(error))
+}
+
+let fatal = message => {
+  getLogger().fatal(message->createPinoMessage)
+}
+
+let childTrace = (logger, params: 'a) => {
+  logger.trace(params->createPinoMessage)
+}
+let childDebug = (logger, params: 'a) => {
+  logger.debug(params->createPinoMessage)
+}
+let childInfo = (logger, params: 'a) => {
+  logger.info(params->createPinoMessage)
+}
+let childWarn = (logger, params: 'a) => {
+  logger.warn(params->createPinoMessage)
+}
+let childError = (logger, params: 'a) => {
+  logger.error(params->createPinoMessage)
+}
+let childErrorWithExn = (logger, error, params: 'a) => {
+  logger->Pino.errorExn(params->createPinoMessageWithError(error))
+}
+
+let childFatal = (logger, params: 'a) => {
+  logger.fatal(params->createPinoMessage)
+}
+
+let createChild = (~params: 'a) => {
+  getLogger()->child(params->createChildParams)
+}
+let createChildFrom = (~logger: t, ~params: 'a) => {
+  logger->child(params->createChildParams)
+}
+
+let getEventLogger = (eventItem: Internal.eventItem) => {
+  switch eventItem.loggerCache {
+  | Some(l) => l
+  | None => {
+      let l = getLogger()->child(
+        {
+          "context": `Event '${eventItem.eventConfig.name}' for contract '${eventItem.eventConfig.contractName}'`,
+          "chainId": eventItem.chain->ChainMap.Chain.toChainId,
+          "block": eventItem.blockNumber,
+          "logIndex": eventItem.logIndex,
+        }->createChildParams,
+      )
+      eventItem.loggerCache = Some(l)
+      l
+    }
+  }
+}
+
+let getUserLogger = {
+  @inline
+  let log = (eventItem, level: Pino.logLevelUser, message: string, ~params) => {
+    (eventItem->getEventLogger->Utils.magic->Js.Dict.unsafeGet((level :> string)))(params, message)
+  }
+
+  (eventItem): Envio.logger => {
+    info: (message: string, ~params=?) => eventItem->log(#uinfo, message, ~params),
+    debug: (message: string, ~params=?) => eventItem->log(#udebug, message, ~params),
+    warn: (message: string, ~params=?) => eventItem->log(#uwarn, message, ~params),
+    error: (message: string, ~params=?) => eventItem->log(#uerror, message, ~params),
+    errorWithExn: (message: string, exn) =>
+      eventItem->log(#uerror, message, ~params={"err": exn->Internal.prettifyExn}),
+  }
+}

package/src/Time.res

@@ -0,0 +1,41 @@
+let resolvePromiseAfterDelay = (~delayMilliseconds) => Utils.delay(delayMilliseconds)
+
+let rec retryAsyncWithExponentialBackOff = async (
+  ~backOffMillis=100,
+  ~multiplicative=4,
+  ~retryCount=0,
+  ~maxRetries=5,
+  ~logger: Pino.t,
+  f: unit => promise<'a>,
+) => {
+  try {
+    await f()
+  } catch {
+  | exn =>
+    if retryCount < maxRetries {
+      let nextRetryCount = retryCount + 1
+      let log = retryCount === 0 ? Logging.childTrace : Logging.childWarn
+      logger->log({
+        "msg": `Retrying query ${nextRetryCount->Belt.Int.toString}/${maxRetries->Belt.Int.toString} in ${backOffMillis->Belt.Int.toString}ms - waiting for correct result.`,
+        "err": exn->Internal.prettifyExn,
+      })
+      await resolvePromiseAfterDelay(~delayMilliseconds=backOffMillis)
+
+      await f->retryAsyncWithExponentialBackOff(
+        ~backOffMillis=backOffMillis * multiplicative,
+        ~multiplicative,
+        ~retryCount=nextRetryCount,
+        ~maxRetries,
+        ~logger,
+      )
+    } else {
+      exn
+      ->ErrorHandling.make(
+        ~logger,
+        ~msg=`Failure. Max retries ${retryCount->Belt.Int.toString}/${maxRetries->Belt.Int.toString} exceeded`,
+      )
+      ->ErrorHandling.log
+      await Promise.reject(exn->Js.Exn.anyToExnInternal)
+    }
+  }
+}

package/src/Types.ts

@@ -0,0 +1,22 @@
+export type Invalid = never;
+
+export type Address = string;
+
+export type Logger = {
+  readonly debug: (
+    message: string,
+    params?: Record<string, unknown> | Error
+  ) => void;
+  readonly info: (
+    message: string,
+    params?: Record<string, unknown> | Error
+  ) => void;
+  readonly warn: (
+    message: string,
+    params?: Record<string, unknown> | Error
+  ) => void;
+  readonly error: (
+    message: string,
+    params?: Record<string, unknown> | Error
+  ) => void;
+};

package/src/Utils.res

@@ -22,6 +22,11 @@ module Object = {
   external defineProperty: ('obj, string, propertyDescriptor<'a>) => 'obj = "defineProperty"
 }
 
+module Error = {
+  @new
+  external make: string => exn = "Error"
+}
+
 module Option = {
   let mapNone = (opt: option<'a>, val: 'b): option<'b> => {
     switch opt {
@@ -123,6 +128,9 @@ module Math = {
 }
 
 module Array = {
+  @send
+  external forEachAsync: (array<'a>, 'a => promise<unit>) => unit = "forEach"
+
   @val external jsArrayCreate: int => array<'a> = "Array"
 
   /* Given a comaprator and two sorted lists, combine them into a single sorted list */
@@ -452,3 +460,10 @@ module Map = {
   @send external set: (t<'k, 'v>, 'k, 'v) => t<'k, 'v> = "set"
   @send external delete: (t<'k, 'v>, 'k) => bool = "delete"
 }
+
+module Proxy = {
+  type traps<'a> = {get?: (~target: 'a, ~prop: unknown) => unknown}
+
+  @new
+  external make: ('a, traps<'a>) => 'a = "Proxy"
+}

package/src/bindings/Express.res

@@ -7,7 +7,11 @@ type app
 @module external makeCjs: unit => app = "express"
 @module("express") external make: unit => app = "default"
 
-type req
+type req = private {
+  headers: dict<string>,
+  method: Rest.method,
+  query: dict<string>,
+}
 type res
 
 type handler = (req, res) => unit
@@ -16,14 +20,18 @@ type middleware = (req, res, unit => unit) => unit
 @module("express") external jsonMiddleware: unit => middleware = "json"
 
 @send external use: (app, middleware) => unit = "use"
+@send external useFor: (app, string, middleware) => unit = "use"
 
 @send external get: (app, string, handler) => unit = "get"
+@send external post: (app, string, handler) => unit = "post"
 
 type server
 
 @send external listen: (app, int) => server = "listen"
 
 // res methods
-@send external sendStatus: (res, int) => res = "sendStatus"
+@send external sendStatus: (res, int) => unit = "sendStatus"
 @send external set: (res, string, string) => unit = "set"
+@send external json: (res, Js.Json.t) => unit = "json"
 @send external endWithData: (res, 'a) => res = "end"
+@send external setHeader: (res, string, string) => unit = "setHeader"

package/src/bindings/NodeJs.res

@@ -0,0 +1,81 @@
+type t
+@module external process: t = "process"
+@send external exit: (t, unit) => unit = "exit"
+type exitCode = | @as(0) Success | @as(1) Failure
+@send external exitWithCode: (t, exitCode) => unit = "exit"
+
+module Util = {
+  @unboxed
+  type depth = Int(int) | @as(null) Null
+  @unboxed
+  type compact = Bool(bool) | Int(int)
+  @unboxed
+  type sorted = Bool(bool) | Fn((string, string) => int)
+  @unboxed
+  type getters = | @as(true) True | @as(false) False | @as("get") Get | @as("set") Set
+
+  @unbox
+  type inspectOptions = {
+    showHidden?: bool,
+    depth?: depth,
+    colors?: bool,
+    customInspect?: bool,
+    showProxy?: bool,
+    maxArrayLength?: int,
+    maxStringLength?: int,
+    breakLength?: int,
+    @as("compact") compact?: compact,
+    sorted?: sorted,
+    getters?: string,
+    numericSeparator?: bool,
+  }
+
+  @module("util") external inspect: ('a, inspectOptions) => string = "inspect"
+
+  let inspectObj = a => inspect(a, {showHidden: false, depth: Null, colors: true})
+}
+
+module Path = {
+  type t
+
+  @module("path") @variadic
+  external resolve: array<string> => t = "resolve"
+
+  @module("path") external join: (t, string) => t = "join"
+
+  external toString: t => string = "%identity"
+
+  external __dirname: t = "__dirname"
+}
+
+module Fs = {
+  type writeFileOptions = {
+    mode?: int,
+    // flag?: Flag.t,
+    encoding?: string,
+  }
+
+  module Promises = {
+    @module("fs") @scope("promises")
+    external writeFile: (
+      ~filepath: Path.t,
+      ~content: string,
+      ~options: writeFileOptions=?,
+    ) => promise<unit> = "writeFile"
+
+    @module("fs") @scope("promises")
+    external appendFile: (
+      ~filepath: Path.t,
+      ~content: string,
+      ~options: writeFileOptions=?,
+    ) => Js.Promise.t<unit> = "appendFile"
+
+    @module("fs") @scope("promises")
+    external access: Path.t => Js.Promise.t<unit> = "access"
+
+    type encoding = | @as("utf8") Utf8
+
+    @module("fs") @scope("promises")
+    external readFile: (~filepath: Path.t, ~encoding: encoding) => promise<string> = "readFile"
+  }
+}

package/src/db/EntityHistory.res

@@ -186,7 +186,7 @@ let fromTable = (table: table, ~schema: S.t<'entity>): t<'entity> => {
 
   let currentHistoryFields =
     currentChangeFieldNames->Belt.Array.map(fieldName =>
-      mkField(fieldName, Integer, ~isPrimaryKey=true)
+      mkField(fieldName, Integer, ~fieldSchema=S.never, ~isPrimaryKey=true)
     )
 
   let previousChangeFieldNames =
@@ -194,7 +194,7 @@ let fromTable = (table: table, ~schema: S.t<'entity>): t<'entity> => {
 
   let previousHistoryFields =
     previousChangeFieldNames->Belt.Array.map(fieldName =>
-      mkField(fieldName, Integer, ~isNullable=true)
+      mkField(fieldName, Integer, ~fieldSchema=S.never, ~isNullable=true)
     )
 
   let id = "id"
@@ -224,9 +224,9 @@ let fromTable = (table: table, ~schema: S.t<'entity>): t<'entity> => {
 
   let actionFieldName = "action"
 
-  let actionField = mkField(actionFieldName, Custom(RowAction.enum.name))
+  let actionField = mkField(actionFieldName, Custom(RowAction.enum.name), ~fieldSchema=S.never)
 
-  let serialField = mkField("serial", Serial, ~isNullable=true, ~isIndex=true)
+  let serialField = mkField("serial", Serial, ~fieldSchema=S.never, ~isNullable=true, ~isIndex=true)
 
   let dataFieldNames = dataFields->Belt.Array.map(field => field->getFieldName)
 

package/src/db/Table.res

@@ -19,6 +19,7 @@ type fieldType =
 type field = {
   fieldName: string,
   fieldType: fieldType,
+  fieldSchema: S.t<unknown>,
   isArray: bool,
   isNullable: bool,
   isPrimaryKey: bool,
@@ -36,18 +37,20 @@ type derivedFromField = {
 type fieldOrDerived = Field(field) | DerivedFrom(derivedFromField)
 
 let mkField = (
+  fieldName,
+  fieldType,
+  ~fieldSchema,
   ~default=?,
   ~isArray=false,
   ~isNullable=false,
   ~isPrimaryKey=false,
   ~isIndex=false,
   ~linkedEntity=?,
-  fieldName,
-  fieldType,
 ) =>
   {
     fieldName,
     fieldType,
+    fieldSchema: fieldSchema->S.toUnknown,
     isArray,
     isNullable,
     isPrimaryKey,

package/src/sources/Fuel.res

@@ -0,0 +1,37 @@
+type receiptType =
+  | @as(0) Call
+  | @as(1) Return
+  | @as(2) ReturnData
+  | @as(3) Panic
+  | @as(4) Revert
+  | @as(5) Log
+  | @as(6) LogData
+  // Transfer is to another contract, TransferOut is to wallet address
+  | @as(7) Transfer
+  | @as(8) TransferOut
+  | @as(9) ScriptResult
+  | @as(10) MessageOut
+  | @as(11) Mint
+  | @as(12) Burn
+
+@module("./vendored-fuel-abi-coder.js")
+external transpileAbi: Js.Json.t => Ethers.abi = "transpileAbi"
+
+@module("./vendored-fuel-abi-coder.js") @scope("AbiCoder")
+external getLogDecoder: (~abi: Ethers.abi, ~logId: string) => string => unknown = "getLogDecoder"
+
+module Receipt = {
+  @tag("receiptType")
+  type t =
+    | @as(0) Call({assetId: string, amount: bigint, to: string})
+    | @as(6) LogData({data: string, rb: bigint})
+    | @as(7) Transfer({amount: bigint, assetId: string, to: string})
+    | @as(8) TransferOut({amount: bigint, assetId: string, toAddress: string})
+    | @as(11) Mint({val: bigint, subId: string})
+    | @as(12) Burn({val: bigint, subId: string})
+
+  let getLogDataDecoder = (~abi: Ethers.abi, ~logId: string) => {
+    let decode = getLogDecoder(~abi, ~logId)
+    data => data->decode->Utils.magic
+  }
+}