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

package/src/InMemoryStore.res.mjs

@@ -1,51 +1,48 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
-import * as $$Array from "rescript/lib/es6/array.js";
 import * as Utils from "./Utils.res.mjs";
 import * as Config from "./Config.res.mjs";
-import * as Js_dict from "rescript/lib/es6/js_dict.js";
-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 EventUtils from "./EventUtils.res.mjs";
+import * as Stdlib_Dict from "@rescript/runtime/lib/es6/Stdlib_Dict.js";
 import * as ErrorHandling from "./ErrorHandling.res.mjs";
 import * as InMemoryTable from "./InMemoryTable.res.mjs";
-import * as Caml_exceptions from "rescript/lib/es6/caml_exceptions.js";
+import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
 
 function hashRawEventsKey(key) {
   return EventUtils.getEventIdKeyString(key.chainId, key.eventId);
 }
 
-var UndefinedEntity = /* @__PURE__ */Caml_exceptions.create("InMemoryStore.EntityTables.UndefinedEntity");
+let UndefinedEntity = /* @__PURE__ */Primitive_exceptions.create("InMemoryStore.EntityTables.UndefinedEntity");
 
 function make(entities) {
-  var init = {};
-  Belt_Array.forEach(entities, (function (entityConfig) {
-          init[entityConfig.name] = InMemoryTable.Entity.make();
-        }));
+  let init = {};
+  Belt_Array.forEach(entities, entityConfig => {
+    init[entityConfig.name] = InMemoryTable.Entity.make();
+  });
   return init;
 }
 
 function get(self, entityName) {
-  var table = self[entityName];
+  let table = self[entityName];
   if (table !== undefined) {
     return table;
   } else {
     return ErrorHandling.mkLogAndRaise(undefined, "Unexpected, entity InMemoryTable is undefined", {
-                RE_EXN_ID: UndefinedEntity,
-                entityName: entityName
-              });
+      RE_EXN_ID: UndefinedEntity,
+      entityName: entityName
+    });
   }
 }
 
 function clone(self) {
-  return Js_dict.fromArray(Belt_Array.map(Js_dict.entries(self), (function (param) {
-                    return [
-                            param[0],
-                            InMemoryTable.Entity.clone(param[1])
-                          ];
-                  })));
+  return Object.fromEntries(Belt_Array.map(Object.entries(self), param => [
+    param[0],
+    InMemoryTable.Entity.clone(param[1])
+  ]));
 }
 
-var EntityTables = {
+let EntityTables = {
   UndefinedEntity: UndefinedEntity,
   make: make,
   get: get,
@@ -54,36 +51,34 @@ var EntityTables = {
 
 function make$1(entities, rollbackTargetCheckpointId) {
   return {
-          rawEvents: InMemoryTable.make(hashRawEventsKey),
-          entities: make(entities),
-          effects: {},
-          rollbackTargetCheckpointId: rollbackTargetCheckpointId
-        };
+    rawEvents: InMemoryTable.make(hashRawEventsKey),
+    entities: make(entities),
+    effects: {},
+    rollbackTargetCheckpointId: rollbackTargetCheckpointId
+  };
 }
 
 function clone$1(self) {
   return {
-          rawEvents: InMemoryTable.clone(self.rawEvents),
-          entities: clone(self.entities),
-          effects: Js_dict.map((function (table) {
-                  return {
-                          idsToStore: $$Array.copy(table.idsToStore),
-                          invalidationsCount: table.invalidationsCount,
-                          dict: Utils.Dict.shallowCopy(table.dict),
-                          effect: table.effect
-                        };
-                }), self.effects),
-          rollbackTargetCheckpointId: self.rollbackTargetCheckpointId
-        };
+    rawEvents: InMemoryTable.clone(self.rawEvents),
+    entities: clone(self.entities),
+    effects: Stdlib_Dict.mapValues(self.effects, table => ({
+      idsToStore: table.idsToStore.slice(),
+      invalidationsCount: table.invalidationsCount,
+      dict: Utils.Dict.shallowCopy(table.dict),
+      effect: table.effect
+    })),
+    rollbackTargetCheckpointId: self.rollbackTargetCheckpointId
+  };
 }
 
 function getEffectInMemTable(inMemoryStore, effect) {
-  var key = effect.name;
-  var table = inMemoryStore.effects[key];
+  let key = effect.name;
+  let table = inMemoryStore.effects[key];
   if (table !== undefined) {
     return table;
   }
-  var table$1 = {
+  let table$1 = {
     idsToStore: [],
     invalidationsCount: 0,
     dict: {},
@@ -102,61 +97,50 @@ function isRollingBack(inMemoryStore) {
 }
 
 function setBatchDcs(inMemoryStore, batch, shouldSaveHistory) {
-  var inMemTable = getInMemTable(inMemoryStore, Config.DynamicContractRegistry.entityConfig);
-  var itemIdx = 0;
-  for(var checkpoint = 0 ,checkpoint_finish = batch.checkpointIds.length; checkpoint < checkpoint_finish; ++checkpoint){
-    var checkpointId = batch.checkpointIds[checkpoint];
-    var chainId = batch.checkpointChainIds[checkpoint];
-    var checkpointEventsProcessed = batch.checkpointEventsProcessed[checkpoint];
-    for(var idx = 0; idx < checkpointEventsProcessed; ++idx){
-      var item = batch.items[itemIdx + idx | 0];
-      var dcs = item.dcs;
+  let inMemTable = getInMemTable(inMemoryStore, Config.EnvioAddresses.entityConfig);
+  let itemIdx = 0;
+  for (let checkpoint = 0, checkpoint_finish = batch.checkpointIds.length; checkpoint < checkpoint_finish; ++checkpoint) {
+    let checkpointId = batch.checkpointIds[checkpoint];
+    let chainId = batch.checkpointChainIds[checkpoint];
+    let checkpointEventsProcessed = batch.checkpointEventsProcessed[checkpoint];
+    for (let idx = 0; idx < checkpointEventsProcessed; ++idx) {
+      let item = batch.items[itemIdx + idx | 0];
+      let dcs = item.dcs;
       if (dcs !== undefined) {
-        for(var dcIdx = 0 ,dcIdx_finish = dcs.length; dcIdx < dcIdx_finish; ++dcIdx){
-          var dc = dcs[dcIdx];
-          var entity_id = Config.DynamicContractRegistry.makeId(chainId, dc.address);
-          var entity_registering_event_block_number = item.blockNumber;
-          var entity_registering_event_log_index = item.logIndex;
-          var entity_registering_event_block_timestamp = item.timestamp;
-          var entity_registering_event_contract_name = item.eventConfig.contractName;
-          var entity_registering_event_name = item.eventConfig.name;
-          var entity_registering_event_src_address = item.event.srcAddress;
-          var entity_contract_address = dc.address;
-          var entity_contract_name = dc.contractName;
-          var entity = {
+        for (let dcIdx = 0, dcIdx_finish = dcs.length; dcIdx < dcIdx_finish; ++dcIdx) {
+          let dc = dcs[dcIdx];
+          let entity_id = Config.EnvioAddresses.makeId(chainId, dc.address);
+          let entity_registration_block = item.blockNumber;
+          let entity_registration_log_index = item.logIndex;
+          let entity_contract_name = dc.contractName;
+          let entity = {
             id: entity_id,
             chain_id: chainId,
-            registering_event_block_number: entity_registering_event_block_number,
-            registering_event_log_index: entity_registering_event_log_index,
-            registering_event_block_timestamp: entity_registering_event_block_timestamp,
-            registering_event_contract_name: entity_registering_event_contract_name,
-            registering_event_name: entity_registering_event_name,
-            registering_event_src_address: entity_registering_event_src_address,
-            contract_address: entity_contract_address,
+            registration_block: entity_registration_block,
+            registration_log_index: entity_registration_log_index,
             contract_name: entity_contract_name
           };
           InMemoryTable.Entity.set(inMemTable, {
-                type: "SET",
-                entityId: entity_id,
-                entity: entity,
-                checkpointId: checkpointId
-              }, shouldSaveHistory, undefined);
+            type: "SET",
+            entityId: entity_id,
+            entity: entity,
+            checkpointId: checkpointId
+          }, shouldSaveHistory, undefined);
         }
       }
-      
     }
     itemIdx = itemIdx + checkpointEventsProcessed | 0;
   }
 }
 
 export {
-  hashRawEventsKey ,
-  EntityTables ,
+  hashRawEventsKey,
+  EntityTables,
   make$1 as make,
   clone$1 as clone,
-  getEffectInMemTable ,
-  getInMemTable ,
-  isRollingBack ,
-  setBatchDcs ,
+  getEffectInMemTable,
+  getInMemTable,
+  isRollingBack,
+  setBatchDcs,
 }
 /* Utils Not a pure module */

package/src/InMemoryTable.res

@@ -1,31 +1,29 @@
-open Belt
-
 type t<'key, 'val> = {
   dict: dict<'val>,
   hash: 'key => string,
 }
 
 let make = (~hash): t<'key, 'val> => {
-  dict: Js.Dict.empty(),
+  dict: Dict.make(),
   hash,
 }
 
-let set = (self: t<'key, 'val>, key, value) => self.dict->Js.Dict.set(key->self.hash, value)
+let set = (self: t<'key, 'val>, key, value) => self.dict->Dict.set(key->self.hash, value)
 
-let setByHash = (self: t<'key, 'val>, hash, value) => self.dict->Js.Dict.set(hash, value)
+let setByHash = (self: t<'key, 'val>, hash, value) => self.dict->Dict.set(hash, value)
 
 let hasByHash = (self: t<'key, 'val>, hash) => {
   self.dict->Utils.Dict.has(hash)
 }
 
 let getUnsafeByHash = (self: t<'key, 'val>, hash) => {
-  self.dict->Js.Dict.unsafeGet(hash)
+  self.dict->Dict.getUnsafe(hash)
 }
 
 let get = (self: t<'key, 'val>, key: 'key) =>
   self.dict->Utils.Dict.dangerouslyGetNonOption(key->self.hash)
 
-let values = (self: t<'key, 'val>) => self.dict->Js.Dict.values
+let values = (self: t<'key, 'val>) => self.dict->Dict.valuesToArray
 
 let clone = (self: t<'key, 'val>) => {
   ...self,
@@ -85,7 +83,7 @@ module Entity = {
       let fieldValue =
         entity
         ->(Utils.magic: 'entity => dict<TableIndices.FieldValue.t>)
-        ->Js.Dict.get(fieldName)
+        ->Dict.get(fieldName)
         ->Option.getUnsafe
       if !(index->TableIndices.Index.evaluate(~fieldName, ~fieldValue)) {
         entityIndices->Utils.Set.delete(index)->ignore
@@ -93,13 +91,11 @@ module Entity = {
     })
 
     self.fieldNameIndices.dict
-    ->Js.Dict.keys
+    ->Dict.keysToArray
     ->Array.forEach(fieldName => {
       switch (
-        entity
-        ->(Utils.magic: 'entity => dict<TableIndices.FieldValue.t>)
-        ->Js.Dict.get(fieldName),
-        self.fieldNameIndices.dict->Js.Dict.get(fieldName),
+        entity->(Utils.magic: 'entity => dict<TableIndices.FieldValue.t>)->Dict.get(fieldName),
+        self.fieldNameIndices.dict->Dict.get(fieldName),
       ) {
       | (Some(fieldValue), Some(indices)) =>
         indices
@@ -142,7 +138,7 @@ module Entity = {
   ) => {
     let shouldWriteEntity =
       allowOverWriteEntity ||
-      inMemTable.table.dict->Js.Dict.get(key->inMemTable.table.hash)->Option.isNone
+      inMemTable.table.dict->Dict.get(key->inMemTable.table.hash)->Option.isNone
 
     //Only initialize a row in the case where it is none
     //or if allowOverWriteEntity is true (used for mockDb in test helpers)
@@ -155,7 +151,7 @@ module Entity = {
         inMemTable->updateIndices(~entity, ~entityIndices)
       | None => ()
       }
-      inMemTable.table.dict->Js.Dict.set(
+      inMemTable.table.dict->Dict.set(
         key->inMemTable.table.hash,
         {
           latest: entity,
@@ -234,25 +230,23 @@ module Entity = {
   that the entity is not set to the in memory store,
   and the second option means that the entity doesn't esist/deleted.
   It's needed to prevent an additional round trips to the database for deleted entities. */
-  let getUnsafe = (inMemTable: t<'entity>) => (key: string) =>
-    inMemTable.table.dict
-    ->Js.Dict.unsafeGet(key)
-    ->rowToEntity
+  let getUnsafe = (inMemTable: t<'entity>) =>
+    (key: string) =>
+      inMemTable.table.dict
+      ->Dict.getUnsafe(key)
+      ->rowToEntity
 
-  let hasIndex = (
-    inMemTable: t<'entity>,
-    ~fieldName,
-    ~operator: TableIndices.Operator.t,
-  ) => fieldValueHash => {
-    switch inMemTable.fieldNameIndices.dict->Utils.Dict.dangerouslyGetNonOption(fieldName) {
-    | None => false
-    | Some(indicesSerializedToValue) => {
-        // Should match TableIndices.toString logic
-        let key = `${fieldName}:${(operator :> string)}:${fieldValueHash}`
-        indicesSerializedToValue.dict->Utils.Dict.dangerouslyGetNonOption(key) !== None
+  let hasIndex = (inMemTable: t<'entity>, ~fieldName, ~operator: TableIndices.Operator.t) =>
+    fieldValueHash => {
+      switch inMemTable.fieldNameIndices.dict->Utils.Dict.dangerouslyGetNonOption(fieldName) {
+      | None => false
+      | Some(indicesSerializedToValue) => {
+          // Should match TableIndices.toString logic
+          let key = `${fieldName}:${(operator :> string)}:${fieldValueHash}`
+          indicesSerializedToValue.dict->Utils.Dict.dangerouslyGetNonOption(key) !== None
+        }
       }
     }
-  }
 
   let getUnsafeOnIndex = (
     inMemTable: t<'entity>,
@@ -262,20 +256,21 @@ module Entity = {
     let getEntity = inMemTable->getUnsafe
     fieldValueHash => {
       switch inMemTable.fieldNameIndices.dict->Utils.Dict.dangerouslyGetNonOption(fieldName) {
-      | None => Js.Exn.raiseError(`Unexpected error. Must have an index on field ${fieldName}`)
+      | None =>
+        JsError.throwWithMessage(`Unexpected error. Must have an index on field ${fieldName}`)
       | Some(indicesSerializedToValue) => {
           // Should match TableIndices.toString logic
           let key = `${fieldName}:${(operator :> string)}:${fieldValueHash}`
           switch indicesSerializedToValue.dict->Utils.Dict.dangerouslyGetNonOption(key) {
           | None =>
-            Js.Exn.raiseError(
+            JsError.throwWithMessage(
               `Unexpected error. Must have an index for the value ${fieldValueHash} on field ${fieldName}`,
             )
           | Some((_index, relatedEntityIds)) => {
               let res =
                 relatedEntityIds
                 ->Utils.Set.toArray
-                ->Array.keepMap(entityId => {
+                ->Array.filterMap(entityId => {
                   switch hasByHash(inMemTable.table, entityId) {
                   | true => getEntity(entityId)
                   | false => None
@@ -301,7 +296,7 @@ module Entity = {
         let fieldValue =
           entity
           ->(Utils.magic: 'entity => dict<TableIndices.FieldValue.t>)
-          ->Js.Dict.unsafeGet(fieldName)
+          ->Dict.getUnsafe(fieldName)
         if index->TableIndices.Index.evaluate(~fieldName, ~fieldValue) {
           let _ = row.entityIndices->Utils.Set.add(index)
           let _ = relatedEntityIds->Utils.Set.add(entity->getEntityIdUnsafe)
@@ -344,7 +339,7 @@ module Entity = {
   let updates = (inMemTable: t<'entity>) => {
     inMemTable.table
     ->values
-    ->Array.keepMapU(v =>
+    ->Array.filterMap(v =>
       switch v.status {
       | Updated(update) => Some(update)
       | Loaded => None
@@ -355,7 +350,7 @@ module Entity = {
   let values = (inMemTable: t<'entity>) => {
     inMemTable.table
     ->values
-    ->Array.keepMap(rowToEntity)
+    ->Array.filterMap(rowToEntity)
   }
 
   let clone = ({table, fieldNameIndices}: t<'entity>) => {
@@ -363,9 +358,9 @@ module Entity = {
     fieldNameIndices: {
       ...fieldNameIndices,
       dict: fieldNameIndices.dict
-      ->Js.Dict.entries
+      ->Dict.toArray
       ->Array.map(((k, v)) => (k, v->clone))
-      ->Js.Dict.fromArray,
+      ->Dict.fromArray,
     },
   }
 }