envio 2.32.0-alpha.0 → 2.32.1

package/src/ReorgDetection.res.js

@@ -16,7 +16,7 @@ function reorgDetectedToLogParams(reorgDetected, shouldRollbackOnReorg) {
         };
 }
 
-function make(chainReorgCheckpoints, maxReorgDepth, shouldRollbackOnReorg, detectedReorgBlock) {
+function make(chainReorgCheckpoints, maxReorgDepth, shouldRollbackOnReorg) {
   var dataByBlockNumber = {};
   Belt_Array.forEach(chainReorgCheckpoints, (function (block) {
           dataByBlockNumber[block.block_number] = {
@@ -27,8 +27,7 @@ function make(chainReorgCheckpoints, maxReorgDepth, shouldRollbackOnReorg, detec
   return {
           shouldRollbackOnReorg: shouldRollbackOnReorg,
           maxReorgDepth: maxReorgDepth,
-          dataByBlockNumber: dataByBlockNumber,
-          detectedReorgBlock: detectedReorgBlock
+          dataByBlockNumber: dataByBlockNumber
         };
 }
 
@@ -79,12 +78,7 @@ function registerReorgGuard(self, reorgGuard, currentBlockHeight) {
   }
   if (maybeReorgDetected !== undefined) {
     return [
-            shouldRollbackOnReorg ? ({
-                  shouldRollbackOnReorg: self.shouldRollbackOnReorg,
-                  maxReorgDepth: self.maxReorgDepth,
-                  dataByBlockNumber: self.dataByBlockNumber,
-                  detectedReorgBlock: maybeReorgDetected.scannedBlock
-                }) : make([], maxReorgDepth, shouldRollbackOnReorg, undefined),
+            shouldRollbackOnReorg ? self : make([], maxReorgDepth, shouldRollbackOnReorg),
             {
               TAG: "ReorgDetected",
               _0: maybeReorgDetected
@@ -99,8 +93,7 @@ function registerReorgGuard(self, reorgGuard, currentBlockHeight) {
             {
               shouldRollbackOnReorg: shouldRollbackOnReorg,
               maxReorgDepth: maxReorgDepth,
-              dataByBlockNumber: dataByBlockNumberCopyInThreshold,
-              detectedReorgBlock: undefined
+              dataByBlockNumber: dataByBlockNumberCopyInThreshold
             },
             "NoReorg"
           ];
@@ -115,12 +108,8 @@ function getLatestValidScannedBlock(reorgDetection, blockNumbersAndHashes) {
   }
   var ascBlockNumberKeys = Object.keys(verifiedDataByBlockNumber);
   var getPrevScannedBlockNumber = function (idx) {
-    return Belt_Option.flatMap(Belt_Array.get(ascBlockNumberKeys, idx - 1 | 0), (function (key) {
-                  var v = verifiedDataByBlockNumber[key];
-                  if (v !== undefined) {
-                    return v.blockNumber;
-                  }
-                  
+    return Belt_Option.map(Belt_Array.get(ascBlockNumberKeys, idx - 1 | 0), (function (key) {
+                  return verifiedDataByBlockNumber[key].blockNumber;
                 }));
   };
   var _idx = 0;
@@ -131,8 +120,10 @@ function getLatestValidScannedBlock(reorgDetection, blockNumbersAndHashes) {
       return getPrevScannedBlockNumber(idx$1);
     }
     var scannedBlock = reorgDetection.dataByBlockNumber[blockNumberKey];
-    var verifiedBlockData = verifiedDataByBlockNumber[blockNumberKey];
-    if (verifiedBlockData.blockHash !== scannedBlock.blockHash) {
+    if (scannedBlock === undefined) {
+      return getPrevScannedBlockNumber(idx$1);
+    }
+    if (verifiedDataByBlockNumber[blockNumberKey].blockHash !== scannedBlock.blockHash) {
       return getPrevScannedBlockNumber(idx$1);
     }
     _idx = idx$1 + 1 | 0;
@@ -165,8 +156,7 @@ function rollbackToValidBlockNumber(param, blockNumber) {
   return {
           shouldRollbackOnReorg: param.shouldRollbackOnReorg,
           maxReorgDepth: param.maxReorgDepth,
-          dataByBlockNumber: newDataByBlockNumber,
-          detectedReorgBlock: undefined
+          dataByBlockNumber: newDataByBlockNumber
         };
 }
 

package/src/TableIndices.res

@@ -0,0 +1,110 @@
+module FieldValue = {
+  open Belt
+  @unboxed
+  type rec tNonOptional =
+    | String(string)
+    | BigInt(bigint)
+    | Int(int)
+    | BigDecimal(BigDecimal.t)
+    | Bool(bool)
+    | Array(array<tNonOptional>)
+
+  let rec toString = tNonOptional =>
+    switch tNonOptional {
+    | String(v) => v
+    | BigInt(v) => v->BigInt.toString
+    | Int(v) => v->Int.toString
+    | BigDecimal(v) => v->BigDecimal.toString
+    | Bool(v) => v ? "true" : "false"
+    | Array(v) => `[${v->Array.joinWith(",", toString)}]`
+    }
+
+  //This needs to be a castable type from any type that we
+  //support in entities so that we can create evaluations
+  //and serialize the types without parsing/wrapping them
+  type t = option<tNonOptional>
+
+  let toString = (value: t) =>
+    switch value {
+    | Some(v) => v->toString
+    | None => "undefined"
+    }
+
+  external castFrom: 'a => t = "%identity"
+  external castTo: t => 'a = "%identity"
+
+  let eq = (a, b) =>
+    switch (a, b) {
+    //For big decimal use custom equals operator otherwise let Caml_obj.equal do its magic
+    | (Some(BigDecimal(bdA)), Some(BigDecimal(bdB))) => BigDecimal.equals(bdA, bdB)
+    | (a, b) => a == b
+    }
+
+  let gt = (a, b) =>
+    switch (a, b) {
+    //For big decimal use custom equals operator otherwise let Caml_obj.equal do its magic
+    | (Some(BigDecimal(bdA)), Some(BigDecimal(bdB))) => BigDecimal.gt(bdA, bdB)
+    | (a, b) => a > b
+    }
+
+  let lt = (a, b) =>
+    switch (a, b) {
+    //For big decimal use custom equals operator otherwise let Caml_obj.equal do its magic
+    | (Some(BigDecimal(bdA)), Some(BigDecimal(bdB))) => BigDecimal.lt(bdA, bdB)
+    | (a, b) => a < b
+    }
+}
+
+module Operator = {
+  type t = Eq | Gt | Lt
+
+  let values = [Eq, Gt, Lt]
+}
+
+module SingleIndex = {
+  type t = {fieldName: string, fieldValue: FieldValue.t, operator: Operator.t}
+
+  let make = (~fieldName, ~fieldValue: 'a, ~operator) => {
+    fieldName,
+    fieldValue: FieldValue.castFrom(fieldValue),
+    operator,
+  }
+
+  // Should much hashing logic in InMemoryTable
+  let toString = ({fieldName, fieldValue, operator}) =>
+    `${fieldName}:${(operator :> string)}:${fieldValue->FieldValue.toString}`
+
+  let evaluate = (self: t, ~fieldName, ~fieldValue) =>
+    self.fieldName === fieldName &&
+      switch self.operator {
+      | Eq => fieldValue->FieldValue.eq(self.fieldValue)
+      | Gt => fieldValue->FieldValue.gt(self.fieldValue)
+      | Lt => fieldValue->FieldValue.lt(self.fieldValue)
+      }
+}
+
+module Index = {
+  //Next step is to support composite indexes
+  @unboxed
+  type t = Single(SingleIndex.t) //| Composite(array<SingleIndex.t>)
+
+  let makeSingle = (~fieldName, ~fieldValue, ~operator) => Single(
+    SingleIndex.make(~fieldName, ~fieldValue, ~operator),
+  )
+
+  let getFieldName = index =>
+    switch index {
+    | Single(index) => index.fieldName
+    }
+
+  let toString = index =>
+    switch index {
+    | Single(index) => index->SingleIndex.toString
+    }
+
+  let evaluate = (index: t, ~fieldName, ~fieldValue) =>
+    switch index {
+    | Single(index) => SingleIndex.evaluate(index, ~fieldName, ~fieldValue)
+    }
+}
+

package/src/TableIndices.res.js

@@ -0,0 +1,143 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+'use strict';
+
+var Caml_obj = require("rescript/lib/js/caml_obj.js");
+var Belt_Array = require("rescript/lib/js/belt_Array.js");
+
+function toString(tNonOptional) {
+  if (Array.isArray(tNonOptional)) {
+    return "[" + Belt_Array.joinWith(tNonOptional, ",", toString) + "]";
+  }
+  switch (typeof tNonOptional) {
+    case "string" :
+        return tNonOptional;
+    case "number" :
+        return String(tNonOptional);
+    case "bigint" :
+    case "object" :
+        return tNonOptional.toString();
+    case "boolean" :
+        if (tNonOptional) {
+          return "true";
+        } else {
+          return "false";
+        }
+    
+  }
+}
+
+function toString$1(value) {
+  if (value !== undefined) {
+    return toString(value);
+  } else {
+    return "undefined";
+  }
+}
+
+function eq(a, b) {
+  if (a !== undefined && typeof a === "object" && !Array.isArray(a) && b !== undefined && typeof b === "object" && !Array.isArray(b)) {
+    return a.isEqualTo(b);
+  } else {
+    return Caml_obj.equal(a, b);
+  }
+}
+
+function gt(a, b) {
+  if (a !== undefined && typeof a === "object" && !Array.isArray(a) && b !== undefined && typeof b === "object" && !Array.isArray(b)) {
+    return a.isGreaterThan(b);
+  } else {
+    return Caml_obj.greaterthan(a, b);
+  }
+}
+
+function lt(a, b) {
+  if (a !== undefined && typeof a === "object" && !Array.isArray(a) && b !== undefined && typeof b === "object" && !Array.isArray(b)) {
+    return a.isLessThan(b);
+  } else {
+    return Caml_obj.lessthan(a, b);
+  }
+}
+
+var FieldValue = {
+  toString: toString$1,
+  eq: eq,
+  gt: gt,
+  lt: lt
+};
+
+var values = [
+  "Eq",
+  "Gt",
+  "Lt"
+];
+
+var Operator = {
+  values: values
+};
+
+function make(fieldName, fieldValue, operator) {
+  return {
+          fieldName: fieldName,
+          fieldValue: fieldValue,
+          operator: operator
+        };
+}
+
+function toString$2(param) {
+  return param.fieldName + ":" + param.operator + ":" + toString$1(param.fieldValue);
+}
+
+function evaluate(self, fieldName, fieldValue) {
+  if (self.fieldName !== fieldName) {
+    return false;
+  }
+  var match = self.operator;
+  switch (match) {
+    case "Eq" :
+        return eq(fieldValue, self.fieldValue);
+    case "Gt" :
+        return gt(fieldValue, self.fieldValue);
+    case "Lt" :
+        return lt(fieldValue, self.fieldValue);
+    
+  }
+}
+
+var SingleIndex = {
+  make: make,
+  toString: toString$2,
+  evaluate: evaluate
+};
+
+function makeSingle(fieldName, fieldValue, operator) {
+  return {
+          fieldName: fieldName,
+          fieldValue: fieldValue,
+          operator: operator
+        };
+}
+
+function getFieldName(index) {
+  return index.fieldName;
+}
+
+function toString$3(index) {
+  return toString$2(index);
+}
+
+function evaluate$1(index, fieldName, fieldValue) {
+  return evaluate(index, fieldName, fieldValue);
+}
+
+var Index = {
+  makeSingle: makeSingle,
+  getFieldName: getFieldName,
+  toString: toString$3,
+  evaluate: evaluate$1
+};
+
+exports.FieldValue = FieldValue;
+exports.Operator = Operator;
+exports.SingleIndex = SingleIndex;
+exports.Index = Index;
+/* No side effect */

package/src/Types.ts

@@ -44,6 +44,11 @@ export type EffectContext = {
    * Define a new Effect using createEffect outside of the handler.
    */
   readonly effect: EffectCaller;
+  /**
+   * Whether to cache the result of the effect. Defaults to the effect's cache configuration.
+   * Set to false to disable caching for this specific call.
+   */
+  cache: boolean;
 };
 
 export type GenericContractRegister<Args> = (

package/src/bindings/Hrtime.res

@@ -39,3 +39,7 @@ let intFromMillis = toInt
 let intFromNanos = toInt
 let intFromSeconds = toInt
 let floatFromMillis = Utils.magic
+
+let millisBetween = (~from: timeRef, ~to: timeRef): int => {
+  to->toMillis->intFromMillis - from->toMillis->intFromMillis
+}

package/src/bindings/Hrtime.res.js

@@ -39,6 +39,10 @@ function floatFromMillis(prim) {
   return prim;
 }
 
+function millisBetween(from, to) {
+  return (toMillis(to) | 0) - (toMillis(from) | 0) | 0;
+}
+
 function makeTimer(prim) {
   return process.hrtime();
 }
@@ -63,4 +67,5 @@ exports.intFromMillis = intFromMillis;
 exports.intFromNanos = intFromNanos;
 exports.intFromSeconds = intFromSeconds;
 exports.floatFromMillis = floatFromMillis;
+exports.millisBetween = millisBetween;
 /* No side effect */

package/src/bindings/Hrtime.resi

@@ -22,3 +22,5 @@ let intFromMillis: milliseconds => int
 let intFromNanos: nanoseconds => int
 let intFromSeconds: seconds => int
 let floatFromMillis: milliseconds => float
+
+let millisBetween: (~from: timeRef, ~to: timeRef) => int

package/src/bindings/Lodash.res

@@ -0,0 +1,3 @@
+// TODO: Remove this file once we have our own impl of cloneDeep or it is no longer needed
+@module("./vendored-lodash-fns.js") external cloneDeep: 'a => 'a = "cloneDeep"
+

package/src/bindings/Lodash.res.js

@@ -0,0 +1,11 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+'use strict';
+
+var VendoredLodashFnsJs = require("./vendored-lodash-fns.js");
+
+function cloneDeep(prim) {
+  return VendoredLodashFnsJs.cloneDeep(prim);
+}
+
+exports.cloneDeep = cloneDeep;
+/* ./vendored-lodash-fns.js Not a pure module */