envio 2.31.1 → 2.32.0

package/src/Prometheus.res.js

@@ -688,19 +688,34 @@ var ProgressBatchCount = {
   increment: increment$5
 };
 
+var gauge$20 = makeOrThrow$1("envio_progress_latency", "The latency in milliseconds between the latest processed event creation and the time it was written to storage.", chainIdLabelsSchema);
+
+function set$19(latencyMs, chainId) {
+  handleInt$1(gauge$20, chainId, latencyMs);
+}
+
+var ProgressLatency = {
+  gauge: gauge$20,
+  set: set$19
+};
+
 var effectLabelsSchema = S$RescriptSchema.object(function (s) {
       return s.f("effect", S$RescriptSchema.string);
     });
 
-var gauge$20 = makeOrThrow$1("envio_effect_calls_count", "The number of calls to the effect. Including both handler execution and cache hits.", effectLabelsSchema);
+var timeCounter$2 = makeOrThrow("envio_effect_calls_time", "Processing time taken to call the Effect function. (milliseconds)", effectLabelsSchema);
 
-function set$19(callsCount, effectName) {
-  handleInt$1(gauge$20, effectName, callsCount);
-}
+var sumTimeCounter = makeOrThrow("envio_effect_calls_sum_time", "Cumulative time spent calling the Effect function during the indexing process. (milliseconds)", effectLabelsSchema);
 
-var EffectCallsCount = {
-  gauge: gauge$20,
-  set: set$19
+var totalCallsCount = makeOrThrow("envio_effect_calls_count", "Cumulative number of resolved Effect function calls during the indexing process.", effectLabelsSchema);
+
+var activeCallsCount = makeOrThrow$1("envio_effect_active_calls_count", "The number of Effect function calls that are currently running.", effectLabelsSchema);
+
+var EffectCalls = {
+  timeCounter: timeCounter$2,
+  sumTimeCounter: sumTimeCounter,
+  totalCallsCount: totalCallsCount,
+  activeCallsCount: activeCallsCount
 };
 
 var gauge$21 = makeOrThrow$1("envio_effect_cache_count", "The number of items in the effect cache.", effectLabelsSchema);
@@ -725,13 +740,24 @@ var EffectCacheInvalidationsCount = {
   increment: increment$6
 };
 
+var gauge$22 = makeOrThrow$1("envio_effect_queue_count", "The number of effect calls waiting in the rate limit queue.", effectLabelsSchema);
+
+function set$21(count, effectName) {
+  handleInt$1(gauge$22, effectName, count);
+}
+
+var EffectQueueCount = {
+  gauge: gauge$22,
+  set: set$21
+};
+
 var operationLabelsSchema = S$RescriptSchema.object(function (s) {
       return s.f("operation", S$RescriptSchema.string);
     });
 
-var timeCounter$2 = makeOrThrow("envio_storage_load_time", "Processing time taken to load data from storage. (milliseconds)", operationLabelsSchema);
+var timeCounter$3 = makeOrThrow("envio_storage_load_time", "Processing time taken to load data from storage. (milliseconds)", operationLabelsSchema);
 
-var totalTimeCounter = makeOrThrow("envio_storage_load_total_time", "Cumulative time spent loading data from storage during the indexing process. (milliseconds)", operationLabelsSchema);
+var sumTimeCounter$1 = makeOrThrow("envio_storage_load_sum_time", "Cumulative time spent loading data from storage during the indexing process. (milliseconds)", operationLabelsSchema);
 
 var counter$7 = makeOrThrow("envio_storage_load_count", "Cumulative number of successful storage load operations during the indexing process.", operationLabelsSchema);
 
@@ -758,10 +784,10 @@ function endOperation(timerRef, operation, whereSize, size) {
   var operationRef = operations[operation];
   operationRef.pendingCount = operationRef.pendingCount - 1 | 0;
   if (operationRef.pendingCount === 0) {
-    handleInt(timeCounter$2, operation, Hrtime.intFromMillis(Hrtime.toMillis(Hrtime.timeSince(operationRef.timerRef))));
+    handleInt(timeCounter$3, operation, Hrtime.intFromMillis(Hrtime.toMillis(Hrtime.timeSince(operationRef.timerRef))));
     Utils.Dict.deleteInPlace(operations, operation);
   }
-  handleInt(totalTimeCounter, operation, Hrtime.intFromMillis(Hrtime.toMillis(Hrtime.timeSince(timerRef))));
+  handleInt(sumTimeCounter$1, operation, Hrtime.intFromMillis(Hrtime.toMillis(Hrtime.timeSince(timerRef))));
   increment(counter$7, operation);
   handleInt(whereSizeCounter, operation, whereSize);
   handleInt(sizeCounter, operation, size);
@@ -769,8 +795,8 @@ function endOperation(timerRef, operation, whereSize, size) {
 
 var StorageLoad = {
   operationLabelsSchema: operationLabelsSchema,
-  timeCounter: timeCounter$2,
-  totalTimeCounter: totalTimeCounter,
+  timeCounter: timeCounter$3,
+  sumTimeCounter: sumTimeCounter$1,
   counter: counter$7,
   whereSizeCounter: whereSizeCounter,
   sizeCounter: sizeCounter,
@@ -824,9 +850,11 @@ exports.ProcessingMaxBatchSize = ProcessingMaxBatchSize;
 exports.ProgressBlockNumber = ProgressBlockNumber;
 exports.ProgressEventsCount = ProgressEventsCount;
 exports.ProgressBatchCount = ProgressBatchCount;
+exports.ProgressLatency = ProgressLatency;
 exports.effectLabelsSchema = effectLabelsSchema;
-exports.EffectCallsCount = EffectCallsCount;
+exports.EffectCalls = EffectCalls;
 exports.EffectCacheCount = EffectCacheCount;
 exports.EffectCacheInvalidationsCount = EffectCacheInvalidationsCount;
+exports.EffectQueueCount = EffectQueueCount;
 exports.StorageLoad = StorageLoad;
 /* loadEntitiesDurationCounter Not a pure module */

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/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 */