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

package/src/LoadLayer.res

@@ -1,5 +1,3 @@
-open Belt
-
 let loadById = (
   ~loadManager,
   ~persistence: Persistence.t,
@@ -13,12 +11,13 @@ let loadById = (
   let inMemTable = inMemoryStore->InMemoryStore.getInMemTable(~entityConfig)
 
   let load = async (idsToLoad, ~onError as _) => {
-    let timerRef = Prometheus.StorageLoad.startOperation(~operation=key)
+    let storage = persistence->Persistence.getInitializedStorageOrThrow
+    let timerRef = Prometheus.StorageLoad.startOperation(~storage=storage.name, ~operation=key)
 
     // Since LoadManager.call prevents registerign entities already existing in the inMemoryStore,
     // we can be sure that we load only the new ones.
     let dbEntities = try {
-      await (persistence->Persistence.getInitializedStorageOrThrow).loadByIdsOrThrow(
+      await storage.loadByIdsOrThrow(
         ~table=entityConfig.table,
         ~rowsSchema=entityConfig.rowsSchema,
         ~ids=idsToLoad,
@@ -28,15 +27,14 @@ let loadById = (
       reason->ErrorHandling.mkLogAndRaise(~logger=item->Logging.getItemLogger, ~msg=message)
     }
 
-    let entitiesMap = Js.Dict.empty()
+    let entitiesMap = Dict.make()
+
+    //Set the entity in the in memory store
     for idx in 0 to dbEntities->Array.length - 1 {
-      let entity = dbEntities->Js.Array2.unsafe_get(idx)
-      entitiesMap->Js.Dict.set(entity.id, entity)
+      let entity = dbEntities->Array.getUnsafe(idx)
+      entitiesMap->Dict.set(entity.id, entity)
     }
-    idsToLoad->Js.Array2.forEach(entityId => {
-      // Set the entity in the in memory store
-      // without overwriting existing values
-      // which might be newer than what we got from db
+    idsToLoad->Array.forEach(entityId => {
       inMemTable->InMemoryTable.Entity.initValue(
         ~allowOverWriteEntity=false,
         ~key=entityId,
@@ -45,6 +43,7 @@ let loadById = (
     })
 
     timerRef->Prometheus.StorageLoad.endOperation(
+      ~storage=storage.name,
       ~operation=key,
       ~whereSize=idsToLoad->Array.length,
       ~size=dbEntities->Array.length,
@@ -90,12 +89,12 @@ let callEffect = (
 
   effect.handler(arg)
   ->Promise.thenResolve(output => {
-    inMemTable.dict->Js.Dict.set(arg.cacheKey, output)
+    inMemTable.dict->Dict.set(arg.cacheKey, output)
     if arg.context.cache {
       inMemTable.idsToStore->Array.push(arg.cacheKey)->ignore
     }
   })
-  ->Promise.catchResolve(exn => {
+  ->Utils.Promise.catchResolve(exn => {
     onError(~inputKey=arg.cacheKey, ~exn)
   })
   ->Promise.finally(() => {
@@ -143,13 +142,13 @@ let rec executeWithRateLimit = (
           ~inMemTable,
           ~timerRef,
           ~onError,
-        )->Promise.ignoreValue,
+        )->Utils.Promise.ignoreValue,
       )
       ->ignore
     }
 
   | Some(state) =>
-    let now = Js.Date.now()
+    let now = Date.now()
 
     // Check if we need to reset the window
     if now >= state.windowStartTime +. state.durationMs->Int.toFloat {
@@ -159,9 +158,9 @@ let rec executeWithRateLimit = (
     }
 
     // Split into immediate and queued
-    let immediateCount = Js.Math.min_int(state.availableCalls, effectArgs->Array.length)
-    let immediateArgs = effectArgs->Array.slice(~offset=0, ~len=immediateCount)
-    let queuedArgs = effectArgs->Array.sliceToEnd(immediateCount)
+    let immediateCount = Math.Int.min(state.availableCalls, effectArgs->Array.length)
+    let immediateArgs = effectArgs->Belt.Array.slice(~offset=0, ~len=immediateCount)
+    let queuedArgs = effectArgs->Belt.Array.sliceToEnd(immediateCount)
 
     // Update available calls
     state.availableCalls = state.availableCalls - immediateCount
@@ -176,7 +175,7 @@ let rec executeWithRateLimit = (
           ~inMemTable,
           ~timerRef,
           ~onError,
-        )->Promise.ignoreValue,
+        )->Utils.Promise.ignoreValue,
       )
       ->ignore
     }
@@ -225,7 +224,7 @@ let rec executeWithRateLimit = (
             ~isFromQueue=true,
           )
         })
-        ->Promise.ignoreValue,
+        ->Utils.Promise.ignoreValue,
       )
       ->ignore
     }
@@ -249,7 +248,7 @@ let loadEffect = (
   let inMemTable = inMemoryStore->InMemoryStore.getEffectInMemTable(~effect)
 
   let load = async (args, ~onError) => {
-    let idsToLoad = args->Js.Array2.map((arg: Internal.effectArgs) => arg.cacheKey)
+    let idsToLoad = args->Array.map((arg: Internal.effectArgs) => arg.cacheKey)
     let idsFromCache = Utils.Set.make()
 
     if (
@@ -258,11 +257,12 @@ let loadEffect = (
       | _ => false
       }
     ) {
-      let timerRef = Prometheus.StorageLoad.startOperation(~operation=key)
+      let storage = persistence->Persistence.getInitializedStorageOrThrow
+      let timerRef = Prometheus.StorageLoad.startOperation(~storage=storage.name, ~operation=key)
       let {table, outputSchema} = effect.storageMeta
 
       let dbEntities = try {
-        await (persistence->Persistence.getInitializedStorageOrThrow).loadByIdsOrThrow(
+        await storage.loadByIdsOrThrow(
           ~table,
           ~rowsSchema=Internal.effectCacheItemRowsSchema,
           ~ids=idsToLoad,
@@ -279,11 +279,11 @@ let loadEffect = (
         []
       }
 
-      dbEntities->Js.Array2.forEach(dbEntity => {
+      dbEntities->Array.forEach(dbEntity => {
         try {
           let output = dbEntity.output->S.parseOrThrow(outputSchema)
           idsFromCache->Utils.Set.add(dbEntity.id)->ignore
-          inMemTable.dict->Js.Dict.set(dbEntity.id, output)
+          inMemTable.dict->Dict.set(dbEntity.id, output)
         } catch {
         | S.Raised(error) =>
           inMemTable.invalidationsCount = inMemTable.invalidationsCount + 1
@@ -300,6 +300,7 @@ let loadEffect = (
       })
 
       timerRef->Prometheus.StorageLoad.endOperation(
+        ~storage=storage.name,
         ~operation=key,
         ~whereSize=idsToLoad->Array.length,
         ~size=dbEntities->Array.length,
@@ -323,7 +324,7 @@ let loadEffect = (
           ~inMemTable,
           ~onError,
           ~isFromQueue=false,
-        )->Promise.ignoreValue
+        )->Utils.Promise.ignoreValue
       }
     }
   }
@@ -333,7 +334,7 @@ let loadEffect = (
     ~load,
     ~shouldGroup,
     ~hasher=args => args.cacheKey,
-    ~getUnsafeInMemory=hash => inMemTable.dict->Js.Dict.unsafeGet(hash),
+    ~getUnsafeInMemory=hash => inMemTable.dict->Dict.getUnsafe(hash),
     ~hasInMemory=hash => inMemTable.dict->Utils.Dict.has(hash),
     ~input=effectArgs,
   )
@@ -360,11 +361,12 @@ let loadByField = (
   let inMemTable = inMemoryStore->InMemoryStore.getInMemTable(~entityConfig)
 
   let load = async (fieldValues: array<'fieldValue>, ~onError as _) => {
-    let timerRef = Prometheus.StorageLoad.startOperation(~operation=key)
+    let storage = persistence->Persistence.getInitializedStorageOrThrow
+    let timerRef = Prometheus.StorageLoad.startOperation(~storage=storage.name, ~operation=key)
 
     let size = ref(0)
 
-    let indiciesToLoad = fieldValues->Js.Array2.map((fieldValue): TableIndices.Index.t => {
+    let indiciesToLoad = fieldValues->Array.map((fieldValue): TableIndices.Index.t => {
       Single({
         fieldName,
         fieldValue: TableIndices.FieldValue.castFrom(fieldValue),
@@ -372,59 +374,56 @@ let loadByField = (
       })
     })
 
-    let _ =
-      await indiciesToLoad
-      ->Js.Array2.map(async index => {
-        inMemTable->InMemoryTable.Entity.addEmptyIndex(~index)
-        try {
-          let entities = await (
-            persistence->Persistence.getInitializedStorageOrThrow
-          ).loadByFieldOrThrow(
-            ~operator=switch index {
-            | Single({operator: Gt}) => #">"
-            | Single({operator: Eq}) => #"="
-            | Single({operator: Lt}) => #"<"
-            },
-            ~table=entityConfig.table,
-            ~rowsSchema=entityConfig.rowsSchema,
-            ~fieldName=index->TableIndices.Index.getFieldName,
-            ~fieldValue=switch index {
-            | Single({fieldValue}) => fieldValue
-            },
-            ~fieldSchema=fieldValueSchema->(
-              Utils.magic: S.t<'fieldValue> => S.t<TableIndices.FieldValue.t>
-            ),
-          )
-
-          entities->Array.forEach(entity => {
-            //Set the entity in the in memory store
-            inMemTable->InMemoryTable.Entity.initValue(
-              ~allowOverWriteEntity=false,
-              ~key=entity.id,
-              ~entity=Some(entity),
-            )
-          })
+    let _ = await indiciesToLoad
+    ->Array.map(async index => {
+      inMemTable->InMemoryTable.Entity.addEmptyIndex(~index)
+      try {
+        let entities = await storage.loadByFieldOrThrow(
+          ~operator=switch index {
+          | Single({operator: Gt}) => #">"
+          | Single({operator: Eq}) => #"="
+          | Single({operator: Lt}) => #"<"
+          },
+          ~table=entityConfig.table,
+          ~rowsSchema=entityConfig.rowsSchema,
+          ~fieldName=index->TableIndices.Index.getFieldName,
+          ~fieldValue=switch index {
+          | Single({fieldValue}) => fieldValue
+          },
+          ~fieldSchema=fieldValueSchema->(
+            Utils.magic: S.t<'fieldValue> => S.t<TableIndices.FieldValue.t>
+          ),
+        )
 
-          size := size.contents + entities->Array.length
-        } catch {
-        | Persistence.StorageError({message, reason}) =>
-          reason->ErrorHandling.mkLogAndRaise(
-            ~logger=Logging.createChildFrom(
-              ~logger=item->Logging.getItemLogger,
-              ~params={
-                "operator": operatorCallName,
-                "tableName": entityConfig.table.tableName,
-                "fieldName": fieldName,
-                "fieldValue": fieldValue,
-              },
-            ),
-            ~msg=message,
+        entities->Array.forEach(entity => {
+          inMemTable->InMemoryTable.Entity.initValue(
+            ~allowOverWriteEntity=false,
+            ~key=entity.id,
+            ~entity=Some(entity),
           )
-        }
-      })
-      ->Promise.all
+        })
+
+        size := size.contents + entities->Array.length
+      } catch {
+      | Persistence.StorageError({message, reason}) =>
+        reason->ErrorHandling.mkLogAndRaise(
+          ~logger=Logging.createChildFrom(
+            ~logger=item->Logging.getItemLogger,
+            ~params={
+              "operator": operatorCallName,
+              "tableName": entityConfig.table.tableName,
+              "fieldName": fieldName,
+              "fieldValue": fieldValue,
+            },
+          ),
+          ~msg=message,
+        )
+      }
+    })
+    ->Promise.all
 
     timerRef->Prometheus.StorageLoad.endOperation(
+      ~storage=storage.name,
       ~operation=key,
       ~whereSize=fieldValues->Array.length,
       ~size=size.contents,