envio 2.27.5 → 2.28.0-alpha.1

package/src/LoadManager.res.js

@@ -2,7 +2,6 @@
 'use strict';
 
 var Utils = require("./Utils.res.js");
-var Internal = require("./Internal.res.js");
 var Belt_Array = require("rescript/lib/js/belt_Array.js");
 var Caml_js_exceptions = require("rescript/lib/js/caml_js_exceptions.js");
 
@@ -41,27 +40,34 @@ async function schedule(loadManager) {
               }
               
             });
-        if (!Utils.$$Array.isEmpty(inputsToLoad)) {
+        var isSuccess;
+        if (Utils.$$Array.isEmpty(inputsToLoad)) {
+          isSuccess = true;
+        } else {
           try {
             await group.load(inputsToLoad);
+            isSuccess = true;
           }
           catch (raw_exn){
             var exn = Caml_js_exceptions.internalToOCamlException(raw_exn);
-            var exn$1 = Internal.prettifyExn(exn);
+            var exn$1 = Utils.prettifyExn(exn);
             Belt_Array.forEach(currentInputKeys, (function (inputKey) {
                     var call = calls[inputKey];
                     call.reject(exn$1);
                   }));
+            isSuccess = false;
           }
         }
         if (Utils.$$Array.isEmpty(currentInputKeys)) {
           return ;
         }
-        currentInputKeys.forEach(function (inputKey) {
-              var call = calls[inputKey];
-              Utils.Dict.deleteInPlace(calls, inputKey);
-              call.resolve(group.getUnsafeInMemory(inputKey));
-            });
+        if (isSuccess) {
+          currentInputKeys.forEach(function (inputKey) {
+                var call = calls[inputKey];
+                Utils.Dict.deleteInPlace(calls, inputKey);
+                call.resolve(group.getUnsafeInMemory(inputKey));
+              });
+        }
         var latestGroup = groups[key];
         if (Utils.$$Array.isEmpty(Object.keys(latestGroup.calls))) {
           return Utils.Dict.deleteInPlace(groups, key);

package/src/Logging.res

@@ -183,5 +183,5 @@ let getUserLogger = (eventItem): Envio.logger => {
   warn: (message: string, ~params=?) => eventItem->logForItem(#uwarn, message, ~params?),
   error: (message: string, ~params=?) => eventItem->logForItem(#uerror, message, ~params?),
   errorWithExn: (message: string, exn) =>
-    eventItem->logForItem(#uerror, message, ~params={"err": exn->Internal.prettifyExn}),
+    eventItem->logForItem(#uerror, message, ~params={"err": exn->Utils.prettifyExn}),
 }

package/src/Logging.res.js

@@ -3,10 +3,10 @@
 
 var Pino = require("./bindings/Pino.res.js");
 var Pino$1 = require("pino");
+var Utils = require("./Utils.res.js");
 var Js_exn = require("rescript/lib/js/js_exn.js");
 var Js_dict = require("rescript/lib/js/js_dict.js");
 var Caml_obj = require("rescript/lib/js/caml_obj.js");
-var Internal = require("./Internal.res.js");
 var Caml_option = require("rescript/lib/js/caml_option.js");
 var EcsPinoFormat = require("@elastic/ecs-pino-format");
 
@@ -242,7 +242,7 @@ function getUserLogger(eventItem) {
             }),
           errorWithExn: (function (message, exn) {
               var params = {
-                err: Internal.prettifyExn(exn)
+                err: Utils.prettifyExn(exn)
               };
               getEventLogger(eventItem)["uerror"](params, message);
             })

package/src/Persistence.res

@@ -13,6 +13,12 @@ type effectCacheRecord = {
   mutable count: int,
 }
 
+type initialState = {
+  cleanRun: bool,
+  cache: dict<effectCacheRecord>,
+  chains: array<InternalTable.Chains.t>,
+}
+
 type operator = [#">" | #"="]
 
 type storage = {
@@ -22,10 +28,11 @@ type storage = {
   // Should initialize the storage so we can start interacting with it
   // Eg create connection, schema, tables, etc.
   initialize: (
+    ~chainConfigs: array<InternalConfig.chain>=?,
     ~entities: array<Internal.entityConfig>=?,
-    ~generalTables: array<Table.table>=?,
     ~enums: array<Internal.enumConfig<Internal.enum>>=?,
-  ) => promise<unit>,
+  ) => promise<initialState>,
+  loadInitialState: unit => promise<initialState>,
   @raises("StorageError")
   loadByIdsOrThrow: 'item. (
     ~ids: array<string>,
@@ -55,10 +62,6 @@ type storage = {
   ) => promise<unit>,
   // This is to download cache from the database to .envio/cache
   dumpEffectCache: unit => promise<unit>,
-  // This is not good, but the function does two things:
-  // - Gets info about existing cache tables
-  // - if withUpload is true, it also populates the cache from .envio/cache to the database
-  restoreEffectCache: (~withUpload: bool) => promise<array<effectCacheRecord>>,
 }
 
 exception StorageError({message: string, reason: exn})
@@ -66,11 +69,10 @@ exception StorageError({message: string, reason: exn})
 type storageStatus =
   | Unknown
   | Initializing(promise<unit>)
-  | Ready({cleanRun: bool, cache: dict<effectCacheRecord>})
+  | Ready(initialState)
 
 type t = {
   userEntities: array<Internal.entityConfig>,
-  staticTables: array<Table.table>,
   allEntities: array<Internal.entityConfig>,
   allEnums: array<Internal.enumConfig<Internal.enum>>,
   mutable storageStatus: storageStatus,
@@ -86,18 +88,15 @@ let entityHistoryActionEnumConfig: Internal.enumConfig<EntityHistory.RowAction.t
 
 let make = (
   ~userEntities,
-  ~dcRegistryEntityConfig,
   // TODO: Should only pass userEnums and create internal config in runtime
   ~allEnums,
-  ~staticTables,
   ~storage,
 ) => {
-  let allEntities = userEntities->Js.Array2.concat([dcRegistryEntityConfig])
+  let allEntities = userEntities->Js.Array2.concat([InternalTable.DynamicContractRegistry.config])
   let allEnums =
     allEnums->Js.Array2.concat([entityHistoryActionEnumConfig->Internal.fromGenericEnumConfig])
   {
     userEntities,
-    staticTables,
     allEntities,
     allEnums,
     storageStatus: Unknown,
@@ -106,17 +105,7 @@ let make = (
 }
 
 let init = {
-  let loadInitialCache = async (persistence, ~withUpload) => {
-    let effectCacheRecords = await persistence.storage.restoreEffectCache(~withUpload)
-    let cache = Js.Dict.empty()
-    effectCacheRecords->Js.Array2.forEach(record => {
-      Prometheus.EffectCacheCount.set(~count=record.count, ~effectName=record.effectName)
-      cache->Js.Dict.set(record.effectName, record)
-    })
-    cache
-  }
-
-  async (persistence, ~reset=false) => {
+  async (persistence, ~chainConfigs, ~reset=false) => {
     try {
       let shouldRun = switch persistence.storageStatus {
       | Unknown => true
@@ -135,17 +124,14 @@ let init = {
         if reset || !(await persistence.storage.isInitialized()) {
           Logging.info(`Initializing the indexer storage...`)
 
-          await persistence.storage.initialize(
+          let initialState = await persistence.storage.initialize(
             ~entities=persistence.allEntities,
-            ~generalTables=persistence.staticTables,
             ~enums=persistence.allEnums,
+            ~chainConfigs,
           )
 
           Logging.info(`The indexer storage is ready. Uploading cache...`)
-          persistence.storageStatus = Ready({
-            cleanRun: true,
-            cache: await loadInitialCache(persistence, ~withUpload=true),
-          })
+          persistence.storageStatus = Ready(initialState)
         } else if (
           // In case of a race condition,
           // we want to set the initial status to Ready only once.
@@ -155,10 +141,7 @@ let init = {
           }
         ) {
           Logging.info(`The indexer storage is ready.`)
-          persistence.storageStatus = Ready({
-            cleanRun: false,
-            cache: await loadInitialCache(persistence, ~withUpload=false),
-          })
+          persistence.storageStatus = Ready(await persistence.storage.loadInitialState())
         }
         resolveRef.contents()
       }
@@ -178,6 +161,15 @@ let getInitializedStorageOrThrow = persistence => {
   }
 }
 
+let getInitializedState = persistence => {
+  switch persistence.storageStatus {
+  | Unknown
+  | Initializing(_) =>
+    Js.Exn.raiseError(`Failed to access the initial state. The Persistence layer is not initialized.`)
+  | Ready(initialState) => initialState
+  }
+}
+
 let setEffectCacheOrThrow = async (persistence, ~effect: Internal.effect, ~items) => {
   switch persistence.storageStatus {
   | Unknown

package/src/Persistence.res.js

@@ -6,6 +6,7 @@ var Logging = require("./Logging.res.js");
 var Prometheus = require("./Prometheus.res.js");
 var EntityHistory = require("./db/EntityHistory.res.js");
 var ErrorHandling = require("./ErrorHandling.res.js");
+var InternalTable = require("./db/InternalTable.res.js");
 var Caml_exceptions = require("rescript/lib/js/caml_exceptions.js");
 var Caml_js_exceptions = require("rescript/lib/js/caml_js_exceptions.js");
 
@@ -24,12 +25,11 @@ var entityHistoryActionEnumConfig = {
   default: "SET"
 };
 
-function make(userEntities, dcRegistryEntityConfig, allEnums, staticTables, storage) {
-  var allEntities = userEntities.concat([dcRegistryEntityConfig]);
+function make(userEntities, allEnums, storage) {
+  var allEntities = userEntities.concat([InternalTable.DynamicContractRegistry.config]);
   var allEnums$1 = allEnums.concat([entityHistoryActionEnumConfig]);
   return {
           userEntities: userEntities,
-          staticTables: staticTables,
           allEntities: allEntities,
           allEnums: allEnums$1,
           storageStatus: "Unknown",
@@ -37,17 +37,7 @@ function make(userEntities, dcRegistryEntityConfig, allEnums, staticTables, stor
         };
 }
 
-async function loadInitialCache(persistence, withUpload) {
-  var effectCacheRecords = await persistence.storage.restoreEffectCache(withUpload);
-  var cache = {};
-  effectCacheRecords.forEach(function (record) {
-        Prometheus.EffectCacheCount.set(record.count, record.effectName);
-        cache[record.effectName] = record;
-      });
-  return cache;
-}
-
-async function init(persistence, resetOpt) {
+async function init(persistence, chainConfigs, resetOpt) {
   var reset = resetOpt !== undefined ? resetOpt : false;
   try {
     var promise = persistence.storageStatus;
@@ -75,12 +65,11 @@ async function init(persistence, resetOpt) {
     };
     if (reset || !await persistence.storage.isInitialized()) {
       Logging.info("Initializing the indexer storage...");
-      await persistence.storage.initialize(persistence.allEntities, persistence.staticTables, persistence.allEnums);
+      var initialState = await persistence.storage.initialize(chainConfigs, persistence.allEntities, persistence.allEnums);
       Logging.info("The indexer storage is ready. Uploading cache...");
       persistence.storageStatus = {
         TAG: "Ready",
-        cleanRun: true,
-        cache: await loadInitialCache(persistence, true)
+        _0: initialState
       };
     } else {
       var match = persistence.storageStatus;
@@ -90,8 +79,7 @@ async function init(persistence, resetOpt) {
         Logging.info("The indexer storage is ready.");
         persistence.storageStatus = {
           TAG: "Ready",
-          cleanRun: false,
-          cache: await loadInitialCache(persistence, false)
+          _0: await persistence.storage.loadInitialState()
         };
       }
       
@@ -113,6 +101,15 @@ function getInitializedStorageOrThrow(persistence) {
   }
 }
 
+function getInitializedState(persistence) {
+  var initialState = persistence.storageStatus;
+  if (typeof initialState !== "object" || initialState.TAG === "Initializing") {
+    return Js_exn.raiseError("Failed to access the initial state. The Persistence layer is not initialized.");
+  } else {
+    return initialState._0;
+  }
+}
+
 async function setEffectCacheOrThrow(persistence, effect, items) {
   var match = persistence.storageStatus;
   if (typeof match !== "object") {
@@ -121,7 +118,7 @@ async function setEffectCacheOrThrow(persistence, effect, items) {
   if (match.TAG === "Initializing") {
     return Js_exn.raiseError("Failed to access the indexer storage. The Persistence layer is not initialized.");
   }
-  var cache = match.cache;
+  var cache = match._0.cache;
   var storage = persistence.storage;
   var effectName = effect.name;
   var c = cache[effectName];
@@ -147,5 +144,6 @@ exports.entityHistoryActionEnumConfig = entityHistoryActionEnumConfig;
 exports.make = make;
 exports.init = init;
 exports.getInitializedStorageOrThrow = getInitializedStorageOrThrow;
+exports.getInitializedState = getInitializedState;
 exports.setEffectCacheOrThrow = setEffectCacheOrThrow;
 /* Logging Not a pure module */