envio 3.0.0-alpha.21 → 3.0.0-alpha.23

package/src/Persistence.res

@@ -21,8 +21,8 @@ type initialChainState = {
   progressBlockNumber: int,
   numEventsProcessed: float,
   firstEventBlockNumber: option<int>,
-  timestampCaughtUpToHeadOrEndblock: option<Js.Date.t>,
-  dynamicContracts: array<Internal.indexingContract>,
+  timestampCaughtUpToHeadOrEndblock: option<Date.t>,
+  indexingAddresses: array<Internal.indexingAddress>,
   sourceBlockNumber: int,
 }
 
@@ -49,6 +49,8 @@ type updatedEntity = {
 }
 
 type storage = {
+  // Identifier used as the `storage` label on Prometheus metrics.
+  name: string,
   // Should return true if we already have persisted data
   // and we can skip initialization
   isInitialized: unit => promise<bool>,
@@ -119,6 +121,9 @@ type storage = {
     ~updatedEffectsCache: array<updatedEffectCache>,
     ~updatedEntities: array<updatedEntity>,
   ) => promise<unit>,
+  // Release any long-lived resources (e.g. the postgres connection pool) so
+  // short-lived CLI commands like `db-migrate setup` can exit cleanly.
+  close: unit => promise<unit>,
 }
 
 type storageStatus =
@@ -142,10 +147,9 @@ let make = (
   ~allEnums,
   ~storage,
 ) => {
-  let allEntities =
-    userEntities->Js.Array2.concat([InternalTable.DynamicContractRegistry.entityConfig])
+  let allEntities = userEntities->Array.concat([InternalTable.EnvioAddresses.entityConfig])
   let allEnums =
-    allEnums->Js.Array2.concat([EntityHistory.RowAction.config->Table.fromGenericEnumConfig])
+    allEnums->Array.concat([EntityHistory.RowAction.config->Table.fromGenericEnumConfig])
   {
     userEntities,
     allEntities,
@@ -192,8 +196,8 @@ let init = {
           Logging.info(`Found existing indexer storage. Resuming indexing state...`)
           let initialState = await persistence.storage.resumeInitialState()
           persistence.storageStatus = Ready(initialState)
-          let progress = Js.Dict.empty()
-          initialState.chains->Js.Array2.forEach(c => {
+          let progress = Dict.make()
+          initialState.chains->Array.forEach(c => {
             progress->Utils.Dict.setByInt(c.id, c.progressBlockNumber)
           })
           Logging.info({
@@ -213,7 +217,7 @@ let getInitializedStorageOrThrow = persistence => {
   switch persistence.storageStatus {
   | Unknown
   | Initializing(_) =>
-    Js.Exn.raiseError(`Failed to access the indexer storage. The Persistence layer is not initialized.`)
+    JsError.throwWithMessage(`Failed to access the indexer storage. The Persistence layer is not initialized.`)
   | Ready(_) => persistence.storage
   }
 }
@@ -222,7 +226,7 @@ let getInitializedState = persistence => {
   switch persistence.storageStatus {
   | Unknown
   | Initializing(_) =>
-    Js.Exn.raiseError(`Failed to access the initial state. The Persistence layer is not initialized.`)
+    JsError.throwWithMessage(`Failed to access the initial state. The Persistence layer is not initialized.`)
   | Ready(initialState) => initialState
   }
 }
@@ -237,9 +241,9 @@ let writeBatch = (
   switch persistence.storageStatus {
   | Unknown
   | Initializing(_) =>
-    Js.Exn.raiseError(`Failed to access the indexer storage. The Persistence layer is not initialized.`)
+    JsError.throwWithMessage(`Failed to access the indexer storage. The Persistence layer is not initialized.`)
   | Ready({cache}) =>
-    let updatedEntities = persistence.allEntities->Belt.Array.keepMapU(entityConfig => {
+    let updatedEntities = persistence.allEntities->Belt.Array.keepMap(entityConfig => {
       let updates =
         inMemoryStore
         ->InMemoryStore.getInMemTable(~entityConfig)
@@ -259,47 +263,40 @@ let writeBatch = (
       ~allEntities=persistence.allEntities,
       ~updatedEntities,
       ~updatedEffectsCache={
-        inMemoryStore.effects
-        ->Js.Dict.keys
-        ->Belt.Array.keepMapU(effectName => {
-          let inMemTable = inMemoryStore.effects->Js.Dict.unsafeGet(effectName)
+        let acc = []
+        inMemoryStore.effects->Utils.Dict.forEach(inMemTable => {
           let {idsToStore, dict, effect, invalidationsCount} = inMemTable
           switch idsToStore {
-          | [] => None
-          | ids => {
-              let items = Belt.Array.makeUninitializedUnsafe(ids->Belt.Array.length)
-              ids->Belt.Array.forEachWithIndex((index, id) => {
-                items->Js.Array2.unsafe_set(
-                  index,
-                  (
-                    {
-                      id,
-                      output: dict->Js.Dict.unsafeGet(id),
-                    }: Internal.effectCacheItem
-                  ),
-                )
-              })
-              Some({
-                let effectName = effect.name
-                let effectCacheRecord = switch cache->Utils.Dict.dangerouslyGetNonOption(
-                  effectName,
-                ) {
-                | Some(c) => c
-                | None => {
-                    let c = {effectName, count: 0}
-                    cache->Js.Dict.set(effectName, c)
-                    c
-                  }
-                }
-                let shouldInitialize = effectCacheRecord.count === 0
-                effectCacheRecord.count =
-                  effectCacheRecord.count + items->Js.Array2.length - invalidationsCount
-                Prometheus.EffectCacheCount.set(~count=effectCacheRecord.count, ~effectName)
-                {effect, items, shouldInitialize}
-              })
+          | [] => ()
+          | ids =>
+            let items = Belt.Array.makeUninitializedUnsafe(ids->Belt.Array.length)
+            ids->Belt.Array.forEachWithIndex((index, id) => {
+              items->Array.setUnsafe(
+                index,
+                (
+                  {
+                    id,
+                    output: dict->Dict.getUnsafe(id),
+                  }: Internal.effectCacheItem
+                ),
+              )
+            })
+            let effectName = effect.name
+            let effectCacheRecord = switch cache->Utils.Dict.dangerouslyGetNonOption(effectName) {
+            | Some(c) => c
+            | None =>
+              let c = {effectName, count: 0}
+              cache->Dict.set(effectName, c)
+              c
             }
+            let shouldInitialize = effectCacheRecord.count === 0
+            effectCacheRecord.count =
+              effectCacheRecord.count + items->Array.length - invalidationsCount
+            Prometheus.EffectCacheCount.set(~count=effectCacheRecord.count, ~effectName)
+            acc->Array.push({effect, items, shouldInitialize})->ignore
           }
         })
+        acc
       },
     )
   }
@@ -314,49 +311,48 @@ let prepareRollbackDiff = async (
     ~rollbackTargetCheckpointId,
   )
 
-  let deletedEntities = Js.Dict.empty()
-  let setEntities = Js.Dict.empty()
+  let deletedEntities = Dict.make()
+  let setEntities = Dict.make()
 
-  let _ =
-    await persistence.allEntities
-    ->Belt.Array.map(async entityConfig => {
-      let entityTable = inMemStore->InMemoryStore.getInMemTable(~entityConfig)
+  let _ = await persistence.allEntities
+  ->Belt.Array.map(async entityConfig => {
+    let entityTable = inMemStore->InMemoryStore.getInMemTable(~entityConfig)
 
-      let (removedIdsResult, restoredEntitiesResult) = await persistence.storage.getRollbackData(
-        ~entityConfig,
-        ~rollbackTargetCheckpointId,
-      )
+    let (removedIdsResult, restoredEntitiesResult) = await persistence.storage.getRollbackData(
+      ~entityConfig,
+      ~rollbackTargetCheckpointId,
+    )
 
-      // Process removed IDs
-      removedIdsResult->Js.Array2.forEach(data => {
-        deletedEntities->Utils.Dict.push(entityConfig.name, data["id"])
-        entityTable->InMemoryTable.Entity.set(
-          Delete({
-            entityId: data["id"],
-            checkpointId: rollbackDiffCheckpointId,
-          }),
-          ~shouldSaveHistory=false,
-          ~containsRollbackDiffChange=true,
-        )
-      })
+    // Process removed IDs
+    removedIdsResult->Array.forEach(data => {
+      deletedEntities->Utils.Dict.push(entityConfig.name, data["id"])
+      entityTable->InMemoryTable.Entity.set(
+        Delete({
+          entityId: data["id"],
+          checkpointId: rollbackDiffCheckpointId,
+        }),
+        ~shouldSaveHistory=false,
+        ~containsRollbackDiffChange=true,
+      )
+    })
 
-      let restoredEntities = restoredEntitiesResult->S.parseOrThrow(entityConfig.rowsSchema)
+    let restoredEntities = restoredEntitiesResult->S.parseOrThrow(entityConfig.rowsSchema)
 
-      // Process restored entities
-      restoredEntities->Belt.Array.forEach((entity: Internal.entity) => {
-        setEntities->Utils.Dict.push(entityConfig.name, entity.id)
-        entityTable->InMemoryTable.Entity.set(
-          Set({
-            entityId: entity.id,
-            checkpointId: rollbackDiffCheckpointId,
-            entity,
-          }),
-          ~shouldSaveHistory=false,
-          ~containsRollbackDiffChange=true,
-        )
-      })
+    // Process restored entities
+    restoredEntities->Belt.Array.forEach((entity: Internal.entity) => {
+      setEntities->Utils.Dict.push(entityConfig.name, entity.id)
+      entityTable->InMemoryTable.Entity.set(
+        Set({
+          entityId: entity.id,
+          checkpointId: rollbackDiffCheckpointId,
+          entity,
+        }),
+        ~shouldSaveHistory=false,
+        ~containsRollbackDiffChange=true,
+      )
     })
-    ->Promise.all
+  })
+  ->Promise.all
 
   {
     "inMemStore": inMemStore,

package/src/Persistence.res.mjs

@@ -2,37 +2,36 @@
 
 import * as Utils from "./Utils.res.mjs";
 import * as Config from "./Config.res.mjs";
-import * as Js_exn from "rescript/lib/es6/js_exn.js";
 import * as Logging from "./Logging.res.mjs";
-import * as Belt_Array from "rescript/lib/es6/belt_Array.js";
+import * as Belt_Array from "@rescript/runtime/lib/es6/Belt_Array.js";
 import * as Prometheus from "./Prometheus.res.mjs";
 import * as EntityHistory from "./db/EntityHistory.res.mjs";
 import * as ErrorHandling from "./ErrorHandling.res.mjs";
 import * as InMemoryStore from "./InMemoryStore.res.mjs";
 import * as InMemoryTable from "./InMemoryTable.res.mjs";
-import * as Caml_exceptions from "rescript/lib/es6/caml_exceptions.js";
+import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
 import * as S$RescriptSchema from "rescript-schema/src/S.res.mjs";
-import * as Caml_js_exceptions from "rescript/lib/es6/caml_js_exceptions.js";
+import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
 
-var StorageError = /* @__PURE__ */Caml_exceptions.create("Persistence.StorageError");
+let StorageError = /* @__PURE__ */Primitive_exceptions.create("Persistence.StorageError");
 
 function make(userEntities, allEnums, storage) {
-  var allEntities = userEntities.concat([Config.DynamicContractRegistry.entityConfig]);
-  var allEnums$1 = allEnums.concat([EntityHistory.RowAction.config]);
+  let allEntities = userEntities.concat([Config.EnvioAddresses.entityConfig]);
+  let allEnums$1 = allEnums.concat([EntityHistory.RowAction.config]);
   return {
-          userEntities: userEntities,
-          allEntities: allEntities,
-          allEnums: allEnums$1,
-          storageStatus: "Unknown",
-          storage: storage
-        };
+    userEntities: userEntities,
+    allEntities: allEntities,
+    allEnums: allEnums$1,
+    storageStatus: "Unknown",
+    storage: storage
+  };
 }
 
 async function init(persistence, chainConfigs, resetOpt) {
-  var reset = resetOpt !== undefined ? resetOpt : false;
+  let reset = resetOpt !== undefined ? resetOpt : false;
   try {
-    var promise = persistence.storageStatus;
-    var shouldRun;
+    let promise = persistence.storageStatus;
+    let shouldRun;
     if (typeof promise !== "object") {
       shouldRun = true;
     } else if (promise.TAG === "Initializing") {
@@ -42,172 +41,172 @@ async function init(persistence, chainConfigs, resetOpt) {
       shouldRun = reset;
     }
     if (!shouldRun) {
-      return ;
+      return;
     }
-    var resolveRef = {
+    let resolveRef = {
       contents: null
     };
-    var promise$1 = new Promise((function (resolve, param) {
-            resolveRef.contents = resolve;
-          }));
+    let promise$1 = new Promise((resolve, param) => {
+      resolveRef.contents = resolve;
+    });
     persistence.storageStatus = {
       TAG: "Initializing",
       _0: promise$1
     };
     if (reset || !await persistence.storage.isInitialized()) {
-      Logging.info("Initializing the indexer storage...");
-      var initialState = await persistence.storage.initialize(chainConfigs, persistence.allEntities, persistence.allEnums);
-      Logging.info("The indexer storage is ready. Starting indexing!");
+      Logging.info(`Initializing the indexer storage...`);
+      let initialState = await persistence.storage.initialize(chainConfigs, persistence.allEntities, persistence.allEnums);
+      Logging.info(`The indexer storage is ready. Starting indexing!`);
       persistence.storageStatus = {
         TAG: "Ready",
         _0: initialState
       };
     } else {
-      var match = persistence.storageStatus;
-      var tmp;
-      tmp = typeof match !== "object" || match.TAG !== "Initializing" ? false : true;
+      let match = persistence.storageStatus;
+      let tmp;
+      tmp = typeof match !== "object" ? false : match.TAG === "Initializing";
       if (tmp) {
-        Logging.info("Found existing indexer storage. Resuming indexing state...");
-        var initialState$1 = await persistence.storage.resumeInitialState();
+        Logging.info(`Found existing indexer storage. Resuming indexing state...`);
+        let initialState$1 = await persistence.storage.resumeInitialState();
         persistence.storageStatus = {
           TAG: "Ready",
           _0: initialState$1
         };
-        var progress = {};
-        initialState$1.chains.forEach(function (c) {
-              progress[c.id] = c.progressBlockNumber;
-            });
+        let progress = {};
+        initialState$1.chains.forEach(c => {
+          progress[c.id] = c.progressBlockNumber;
+        });
         Logging.info({
-              msg: "Successfully resumed indexing state! Continuing from the last checkpoint.",
-              progress: progress
-            });
+          msg: `Successfully resumed indexing state! Continuing from the last checkpoint.`,
+          progress: progress
+        });
       }
-      
     }
     return resolveRef.contents();
-  }
-  catch (raw_exn){
-    var exn = Caml_js_exceptions.internalToOCamlException(raw_exn);
-    return ErrorHandling.mkLogAndRaise(undefined, "Failed to initialize the indexer storage.", exn);
+  } catch (raw_exn) {
+    let exn = Primitive_exceptions.internalToException(raw_exn);
+    return ErrorHandling.mkLogAndRaise(undefined, `Failed to initialize the indexer storage.`, exn);
   }
 }
 
 function getInitializedStorageOrThrow(persistence) {
-  var match = persistence.storageStatus;
+  let match = persistence.storageStatus;
   if (typeof match !== "object" || match.TAG === "Initializing") {
-    return Js_exn.raiseError("Failed to access the indexer storage. The Persistence layer is not initialized.");
+    return Stdlib_JsError.throwWithMessage(`Failed to access the indexer storage. The Persistence layer is not initialized.`);
   } else {
     return persistence.storage;
   }
 }
 
 function getInitializedState(persistence) {
-  var initialState = persistence.storageStatus;
+  let 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.");
+    return Stdlib_JsError.throwWithMessage(`Failed to access the initial state. The Persistence layer is not initialized.`);
   } else {
     return initialState._0;
   }
 }
 
 function writeBatch(persistence, batch, config, inMemoryStore, isInReorgThreshold) {
-  var match = persistence.storageStatus;
+  let match = persistence.storageStatus;
   if (typeof match !== "object") {
-    return Js_exn.raiseError("Failed to access the indexer storage. The Persistence layer is not initialized.");
+    return Stdlib_JsError.throwWithMessage(`Failed to access the indexer storage. The Persistence layer is not initialized.`);
   }
   if (match.TAG === "Initializing") {
-    return Js_exn.raiseError("Failed to access the indexer storage. The Persistence layer is not initialized.");
+    return Stdlib_JsError.throwWithMessage(`Failed to access the indexer storage. The Persistence layer is not initialized.`);
   }
-  var cache = match._0.cache;
-  var updatedEntities = Belt_Array.keepMapU(persistence.allEntities, (function (entityConfig) {
-          var updates = InMemoryTable.Entity.updates(InMemoryStore.getInMemTable(inMemoryStore, entityConfig));
-          if (Utils.$$Array.isEmpty(updates)) {
-            return ;
-          } else {
-            return {
-                    entityConfig: entityConfig,
-                    updates: updates
-                  };
-          }
-        }));
-  return persistence.storage.writeBatch(batch, InMemoryTable.values(inMemoryStore.rawEvents), inMemoryStore.rollbackTargetCheckpointId, isInReorgThreshold, config, persistence.allEntities, Belt_Array.keepMapU(Object.keys(inMemoryStore.effects), (function (effectName) {
-                    var inMemTable = inMemoryStore.effects[effectName];
-                    var idsToStore = inMemTable.idsToStore;
-                    var invalidationsCount = inMemTable.invalidationsCount;
-                    var effect = inMemTable.effect;
-                    var dict = inMemTable.dict;
-                    if (idsToStore.length === 0) {
-                      return ;
-                    }
-                    var items = new Array(idsToStore.length);
-                    Belt_Array.forEachWithIndex(idsToStore, (function (index, id) {
-                            items[index] = {
-                              id: id,
-                              output: dict[id]
-                            };
-                          }));
-                    var effectName$1 = effect.name;
-                    var c = cache[effectName$1];
-                    var effectCacheRecord;
-                    if (c !== undefined) {
-                      effectCacheRecord = c;
-                    } else {
-                      var c$1 = {
-                        effectName: effectName$1,
-                        count: 0
-                      };
-                      cache[effectName$1] = c$1;
-                      effectCacheRecord = c$1;
-                    }
-                    var shouldInitialize = effectCacheRecord.count === 0;
-                    return effectCacheRecord.count = (effectCacheRecord.count + items.length | 0) - invalidationsCount | 0, Prometheus.EffectCacheCount.set(effectCacheRecord.count, effectName$1), {
-                            effect: effect,
-                            items: items,
-                            shouldInitialize: shouldInitialize
-                          };
-                  })), updatedEntities);
+  let cache = match._0.cache;
+  let updatedEntities = Belt_Array.keepMap(persistence.allEntities, entityConfig => {
+    let updates = InMemoryTable.Entity.updates(InMemoryStore.getInMemTable(inMemoryStore, entityConfig));
+    if (Utils.$$Array.isEmpty(updates)) {
+      return;
+    } else {
+      return {
+        entityConfig: entityConfig,
+        updates: updates
+      };
+    }
+  });
+  let acc = [];
+  return persistence.storage.writeBatch(batch, InMemoryTable.values(inMemoryStore.rawEvents), inMemoryStore.rollbackTargetCheckpointId, isInReorgThreshold, config, persistence.allEntities, (Utils.Dict.forEach(inMemoryStore.effects, inMemTable => {
+    let idsToStore = inMemTable.idsToStore;
+    let invalidationsCount = inMemTable.invalidationsCount;
+    let effect = inMemTable.effect;
+    let dict = inMemTable.dict;
+    if (idsToStore.length === 0) {
+      return;
+    }
+    let items = new Array(idsToStore.length);
+    Belt_Array.forEachWithIndex(idsToStore, (index, id) => {
+      items[index] = {
+        id: id,
+        output: dict[id]
+      };
+    });
+    let effectName = effect.name;
+    let c = cache[effectName];
+    let effectCacheRecord;
+    if (c !== undefined) {
+      effectCacheRecord = c;
+    } else {
+      let c$1 = {
+        effectName: effectName,
+        count: 0
+      };
+      cache[effectName] = c$1;
+      effectCacheRecord = c$1;
+    }
+    let shouldInitialize = effectCacheRecord.count === 0;
+    effectCacheRecord.count = (effectCacheRecord.count + items.length | 0) - invalidationsCount | 0;
+    Prometheus.EffectCacheCount.set(effectCacheRecord.count, effectName);
+    acc.push({
+      effect: effect,
+      items: items,
+      shouldInitialize: shouldInitialize
+    });
+  }), acc), updatedEntities);
 }
 
 async function prepareRollbackDiff(persistence, rollbackTargetCheckpointId, rollbackDiffCheckpointId) {
-  var inMemStore = InMemoryStore.make(persistence.allEntities, rollbackTargetCheckpointId);
-  var deletedEntities = {};
-  var setEntities = {};
-  await Promise.all(Belt_Array.map(persistence.allEntities, (async function (entityConfig) {
-              var entityTable = InMemoryStore.getInMemTable(inMemStore, entityConfig);
-              var match = await persistence.storage.getRollbackData(entityConfig, rollbackTargetCheckpointId);
-              match[0].forEach(function (data) {
-                    Utils.Dict.push(deletedEntities, entityConfig.name, data.id);
-                    InMemoryTable.Entity.set(entityTable, {
-                          type: "DELETE",
-                          entityId: data.id,
-                          checkpointId: rollbackDiffCheckpointId
-                        }, false, true);
-                  });
-              var restoredEntities = S$RescriptSchema.parseOrThrow(match[1], entityConfig.rowsSchema);
-              return Belt_Array.forEach(restoredEntities, (function (entity) {
-                            Utils.Dict.push(setEntities, entityConfig.name, entity.id);
-                            InMemoryTable.Entity.set(entityTable, {
-                                  type: "SET",
-                                  entityId: entity.id,
-                                  entity: entity,
-                                  checkpointId: rollbackDiffCheckpointId
-                                }, false, true);
-                          }));
-            })));
+  let inMemStore = InMemoryStore.make(persistence.allEntities, rollbackTargetCheckpointId);
+  let deletedEntities = {};
+  let setEntities = {};
+  await Promise.all(Belt_Array.map(persistence.allEntities, async entityConfig => {
+    let entityTable = InMemoryStore.getInMemTable(inMemStore, entityConfig);
+    let match = await persistence.storage.getRollbackData(entityConfig, rollbackTargetCheckpointId);
+    match[0].forEach(data => {
+      Utils.Dict.push(deletedEntities, entityConfig.name, data.id);
+      InMemoryTable.Entity.set(entityTable, {
+        type: "DELETE",
+        entityId: data.id,
+        checkpointId: rollbackDiffCheckpointId
+      }, false, true);
+    });
+    let restoredEntities = S$RescriptSchema.parseOrThrow(match[1], entityConfig.rowsSchema);
+    return Belt_Array.forEach(restoredEntities, entity => {
+      Utils.Dict.push(setEntities, entityConfig.name, entity.id);
+      InMemoryTable.Entity.set(entityTable, {
+        type: "SET",
+        entityId: entity.id,
+        entity: entity,
+        checkpointId: rollbackDiffCheckpointId
+      }, false, true);
+    });
+  }));
   return {
-          inMemStore: inMemStore,
-          deletedEntities: deletedEntities,
-          setEntities: setEntities
-        };
+    inMemStore: inMemStore,
+    deletedEntities: deletedEntities,
+    setEntities: setEntities
+  };
 }
 
 export {
-  StorageError ,
-  make ,
-  init ,
-  getInitializedStorageOrThrow ,
-  getInitializedState ,
-  writeBatch ,
-  prepareRollbackDiff ,
+  StorageError,
+  make,
+  init,
+  getInitializedStorageOrThrow,
+  getInitializedState,
+  writeBatch,
+  prepareRollbackDiff,
 }
 /* Utils Not a pure module */