envio 3.0.0-alpha.21 → 3.0.0-alpha.22

package/src/LoadLayer.res.mjs

@@ -4,9 +4,8 @@ import * as Utils from "./Utils.res.mjs";
 import * as Hrtime from "./bindings/Hrtime.res.mjs";
 import * as Logging from "./Logging.res.mjs";
 import * as Internal from "./Internal.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 Caml_option from "rescript/lib/es6/caml_option.js";
 import * as LoadManager from "./LoadManager.res.mjs";
 import * as Persistence from "./Persistence.res.mjs";
 import * as TableIndices from "./TableIndices.res.mjs";
@@ -14,90 +13,82 @@ import * as ErrorHandling from "./ErrorHandling.res.mjs";
 import * as InMemoryStore from "./InMemoryStore.res.mjs";
 import * as InMemoryTable from "./InMemoryTable.res.mjs";
 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";
 
 function loadById(loadManager, persistence, entityConfig, inMemoryStore, shouldGroup, item, entityId) {
-  var key = entityConfig.name + ".get";
-  var inMemTable = InMemoryStore.getInMemTable(inMemoryStore, entityConfig);
-  var load = async function (idsToLoad, param) {
-    var timerRef = Prometheus.StorageLoad.startOperation(key);
-    var dbEntities;
+  let key = entityConfig.name + `.get`;
+  let inMemTable = InMemoryStore.getInMemTable(inMemoryStore, entityConfig);
+  let load = async (idsToLoad, param) => {
+    let storage = Persistence.getInitializedStorageOrThrow(persistence);
+    let timerRef = Prometheus.StorageLoad.startOperation(storage.name, key);
+    let dbEntities;
     try {
-      dbEntities = await Persistence.getInitializedStorageOrThrow(persistence).loadByIdsOrThrow(idsToLoad, entityConfig.table, entityConfig.rowsSchema);
-    }
-    catch (raw_exn){
-      var exn = Caml_js_exceptions.internalToOCamlException(raw_exn);
+      dbEntities = await storage.loadByIdsOrThrow(idsToLoad, entityConfig.table, entityConfig.rowsSchema);
+    } catch (raw_exn) {
+      let exn = Primitive_exceptions.internalToException(raw_exn);
       if (exn.RE_EXN_ID === Persistence.StorageError) {
         dbEntities = ErrorHandling.mkLogAndRaise(Logging.getItemLogger(item), exn.message, exn.reason);
       } else {
         throw exn;
       }
     }
-    var entitiesMap = {};
-    for(var idx = 0 ,idx_finish = dbEntities.length; idx < idx_finish; ++idx){
-      var entity = dbEntities[idx];
+    let entitiesMap = {};
+    for (let idx = 0, idx_finish = dbEntities.length; idx < idx_finish; ++idx) {
+      let entity = dbEntities[idx];
       entitiesMap[entity.id] = entity;
     }
-    idsToLoad.forEach(function (entityId) {
-          InMemoryTable.Entity.initValue(inMemTable, entityId, entitiesMap[entityId], false);
-        });
-    return Prometheus.StorageLoad.endOperation(timerRef, key, idsToLoad.length, dbEntities.length);
+    idsToLoad.forEach(entityId => InMemoryTable.Entity.initValue(inMemTable, entityId, entitiesMap[entityId], false));
+    return Prometheus.StorageLoad.endOperation(timerRef, storage.name, key, idsToLoad.length, dbEntities.length);
   };
-  return LoadManager.call(loadManager, entityId, key, load, LoadManager.noopHasher, shouldGroup, (function (hash) {
-                return InMemoryTable.hasByHash(inMemTable.table, hash);
-              }), InMemoryTable.Entity.getUnsafe(inMemTable));
+  return LoadManager.call(loadManager, entityId, key, load, LoadManager.noopHasher, shouldGroup, hash => InMemoryTable.hasByHash(inMemTable.table, hash), InMemoryTable.Entity.getUnsafe(inMemTable));
 }
 
 function callEffect(effect, arg, inMemTable, timerRef, onError) {
-  var effectName = effect.name;
-  var hadActiveCalls = effect.activeCallsCount > 0;
+  let effectName = effect.name;
+  let hadActiveCalls = effect.activeCallsCount > 0;
   effect.activeCallsCount = effect.activeCallsCount + 1 | 0;
   Prometheus.SafeGauge.handleInt(Prometheus.EffectCalls.activeCallsCount, effectName, effect.activeCallsCount);
   if (hadActiveCalls) {
-    var elapsed = Hrtime.secondsBetween(effect.prevCallStartTimerRef, timerRef);
+    let elapsed = Hrtime.secondsBetween(effect.prevCallStartTimerRef, timerRef);
     if (elapsed > 0) {
       Prometheus.SafeCounter.handleFloat(Prometheus.EffectCalls.timeCounter, effectName, elapsed);
     }
-    
   }
   effect.prevCallStartTimerRef = timerRef;
-  return effect.handler(arg).then(function (output) {
-                  inMemTable.dict[arg.cacheKey] = output;
-                  if (arg.context.cache) {
-                    inMemTable.idsToStore.push(arg.cacheKey);
-                    return ;
-                  }
-                  
-                }).catch(function (exn) {
-                onError(arg.cacheKey, exn);
-              }).finally(function () {
-              effect.activeCallsCount = effect.activeCallsCount - 1 | 0;
-              Prometheus.SafeGauge.handleInt(Prometheus.EffectCalls.activeCallsCount, effectName, effect.activeCallsCount);
-              var newTimer = Hrtime.makeTimer();
-              Prometheus.SafeCounter.handleFloat(Prometheus.EffectCalls.timeCounter, effectName, Hrtime.secondsBetween(effect.prevCallStartTimerRef, newTimer));
-              effect.prevCallStartTimerRef = newTimer;
-              Prometheus.SafeCounter.increment(Prometheus.EffectCalls.totalCallsCount, effectName);
-              Prometheus.SafeCounter.handleFloat(Prometheus.EffectCalls.sumTimeCounter, effectName, Hrtime.toSecondsFloat(Hrtime.timeSince(timerRef)));
-            });
+  return effect.handler(arg).then(output => {
+    inMemTable.dict[arg.cacheKey] = output;
+    if (arg.context.cache) {
+      inMemTable.idsToStore.push(arg.cacheKey);
+      return;
+    }
+  }).catch(exn => onError(arg.cacheKey, exn)).finally(() => {
+    effect.activeCallsCount = effect.activeCallsCount - 1 | 0;
+    Prometheus.SafeGauge.handleInt(Prometheus.EffectCalls.activeCallsCount, effectName, effect.activeCallsCount);
+    let newTimer = Hrtime.makeTimer();
+    Prometheus.SafeCounter.handleFloat(Prometheus.EffectCalls.timeCounter, effectName, Hrtime.secondsBetween(effect.prevCallStartTimerRef, newTimer));
+    effect.prevCallStartTimerRef = newTimer;
+    Prometheus.SafeCounter.increment(Prometheus.EffectCalls.totalCallsCount, effectName);
+    Prometheus.SafeCounter.handleFloat(Prometheus.EffectCalls.sumTimeCounter, effectName, Hrtime.toSecondsFloat(Hrtime.timeSince(timerRef)));
+  });
 }
 
 function executeWithRateLimit(effect, effectArgs, inMemTable, onError, isFromQueue) {
-  var effectName = effect.name;
-  var timerRef = Hrtime.makeTimer();
-  var promises = [];
-  var state = effect.rateLimit;
+  let effectName = effect.name;
+  let timerRef = Hrtime.makeTimer();
+  let promises = [];
+  let state = effect.rateLimit;
   if (state !== undefined) {
-    var now = Date.now();
+    let now = Date.now();
     if (now >= state.windowStartTime + state.durationMs) {
       state.availableCalls = state.callsPerDuration;
       state.windowStartTime = now;
       state.nextWindowPromise = undefined;
     }
-    var immediateCount = Math.min(state.availableCalls, effectArgs.length);
-    var immediateArgs = Belt_Array.slice(effectArgs, 0, immediateCount);
-    var queuedArgs = Belt_Array.sliceToEnd(effectArgs, immediateCount);
+    let immediateCount = Math.min(state.availableCalls, effectArgs.length);
+    let immediateArgs = Belt_Array.slice(effectArgs, 0, immediateCount);
+    let queuedArgs = Belt_Array.sliceToEnd(effectArgs, immediateCount);
     state.availableCalls = state.availableCalls - immediateCount | 0;
-    for(var idx = 0 ,idx_finish = immediateArgs.length; idx < idx_finish; ++idx){
+    for (let idx = 0, idx_finish = immediateArgs.length; idx < idx_finish; ++idx) {
       promises.push(callEffect(effect, immediateArgs[idx], inMemTable, timerRef, onError));
     }
     if (immediateCount > 0 && isFromQueue) {
@@ -109,29 +100,28 @@ function executeWithRateLimit(effect, effectArgs, inMemTable, onError, isFromQue
         state.queueCount = state.queueCount + queuedArgs.length | 0;
         Prometheus.EffectQueueCount.set(state.queueCount, effectName);
       }
-      var millisUntilReset = {
+      let millisUntilReset = {
         contents: 0
       };
-      var p = state.nextWindowPromise;
-      var nextWindowPromise;
+      let p = state.nextWindowPromise;
+      let nextWindowPromise;
       if (p !== undefined) {
-        nextWindowPromise = Caml_option.valFromOption(p);
+        nextWindowPromise = p;
       } else {
         millisUntilReset.contents = state.windowStartTime + state.durationMs - now | 0;
-        var p$1 = Utils.delay(millisUntilReset.contents);
-        state.nextWindowPromise = Caml_option.some(p$1);
+        let p$1 = Utils.delay(millisUntilReset.contents);
+        state.nextWindowPromise = p$1;
         nextWindowPromise = p$1;
       }
-      promises.push(nextWindowPromise.then(function () {
-                if (millisUntilReset.contents > 0) {
-                  Prometheus.SafeCounter.handleFloat(Prometheus.EffectQueueCount.timeCounter, effectName, millisUntilReset.contents / 1000);
-                }
-                return executeWithRateLimit(effect, queuedArgs, inMemTable, onError, true);
-              }));
+      promises.push(nextWindowPromise.then(() => {
+        if (millisUntilReset.contents > 0) {
+          Prometheus.SafeCounter.handleFloat(Prometheus.EffectQueueCount.timeCounter, effectName, millisUntilReset.contents / 1000);
+        }
+        return executeWithRateLimit(effect, queuedArgs, inMemTable, onError, true);
+      }));
     }
-    
   } else {
-    for(var idx$1 = 0 ,idx_finish$1 = effectArgs.length; idx$1 < idx_finish$1; ++idx$1){
+    for (let idx$1 = 0, idx_finish$1 = effectArgs.length; idx$1 < idx_finish$1; ++idx$1) {
       promises.push(callEffect(effect, effectArgs[idx$1], inMemTable, timerRef, onError));
     }
   }
@@ -139,158 +129,139 @@ function executeWithRateLimit(effect, effectArgs, inMemTable, onError, isFromQue
 }
 
 function loadEffect(loadManager, persistence, effect, effectArgs, inMemoryStore, shouldGroup, item) {
-  var effectName = effect.name;
-  var key = effectName + ".effect";
-  var inMemTable = InMemoryStore.getEffectInMemTable(inMemoryStore, effect);
-  var load = async function (args, onError) {
-    var idsToLoad = args.map(function (arg) {
-          return arg.cacheKey;
-        });
-    var idsFromCache = new Set();
-    var match = persistence.storageStatus;
-    var tmp;
+  let effectName = effect.name;
+  let key = effectName + `.effect`;
+  let inMemTable = InMemoryStore.getEffectInMemTable(inMemoryStore, effect);
+  let load = async (args, onError) => {
+    let idsToLoad = args.map(arg => arg.cacheKey);
+    let idsFromCache = new Set();
+    let match = persistence.storageStatus;
+    let tmp;
     tmp = typeof match !== "object" || match.TAG === "Initializing" ? false : Utils.Dict.has(match._0.cache, effectName);
     if (tmp) {
-      var timerRef = Prometheus.StorageLoad.startOperation(key);
-      var match$1 = effect.storageMeta;
-      var outputSchema = match$1.outputSchema;
-      var dbEntities;
+      let storage = Persistence.getInitializedStorageOrThrow(persistence);
+      let timerRef = Prometheus.StorageLoad.startOperation(storage.name, key);
+      let match$1 = effect.storageMeta;
+      let outputSchema = match$1.outputSchema;
+      let dbEntities;
       try {
-        dbEntities = await Persistence.getInitializedStorageOrThrow(persistence).loadByIdsOrThrow(idsToLoad, match$1.table, Internal.effectCacheItemRowsSchema);
-      }
-      catch (raw_exn){
-        var exn = Caml_js_exceptions.internalToOCamlException(raw_exn);
+        dbEntities = await storage.loadByIdsOrThrow(idsToLoad, match$1.table, Internal.effectCacheItemRowsSchema);
+      } catch (raw_exn) {
+        let exn = Primitive_exceptions.internalToException(raw_exn);
         Logging.childWarn(Logging.getItemLogger(item), {
-              msg: "Failed to load cache effect cache. The indexer will continue working, but the effect will not be able to use the cache.",
-              err: Utils.prettifyExn(exn),
-              effect: effectName
-            });
+          msg: `Failed to load cache effect cache. The indexer will continue working, but the effect will not be able to use the cache.`,
+          err: Utils.prettifyExn(exn),
+          effect: effectName
+        });
         dbEntities = [];
       }
-      dbEntities.forEach(function (dbEntity) {
-            try {
-              var output = S$RescriptSchema.parseOrThrow(dbEntity.output, outputSchema);
-              idsFromCache.add(dbEntity.id);
-              inMemTable.dict[dbEntity.id] = output;
-              return ;
-            }
-            catch (raw_error){
-              var error = Caml_js_exceptions.internalToOCamlException(raw_error);
-              if (error.RE_EXN_ID === S$RescriptSchema.Raised) {
-                inMemTable.invalidationsCount = inMemTable.invalidationsCount + 1 | 0;
-                Prometheus.EffectCacheInvalidationsCount.increment(effectName);
-                return Logging.childTrace(Logging.getItemLogger(item), {
-                            msg: "Invalidated effect cache",
-                            input: dbEntity.id,
-                            effect: effectName,
-                            err: S$RescriptSchema.$$Error.message(error._1)
-                          });
-              }
-              throw error;
-            }
-          });
-      Prometheus.StorageLoad.endOperation(timerRef, key, idsToLoad.length, dbEntities.length);
+      dbEntities.forEach(dbEntity => {
+        try {
+          let output = S$RescriptSchema.parseOrThrow(dbEntity.output, outputSchema);
+          idsFromCache.add(dbEntity.id);
+          inMemTable.dict[dbEntity.id] = output;
+          return;
+        } catch (raw_error) {
+          let error = Primitive_exceptions.internalToException(raw_error);
+          if (error.RE_EXN_ID === S$RescriptSchema.Raised) {
+            inMemTable.invalidationsCount = inMemTable.invalidationsCount + 1 | 0;
+            Prometheus.EffectCacheInvalidationsCount.increment(effectName);
+            return Logging.childTrace(Logging.getItemLogger(item), {
+              msg: "Invalidated effect cache",
+              input: dbEntity.id,
+              effect: effectName,
+              err: S$RescriptSchema.$$Error.message(error._1)
+            });
+          }
+          throw error;
+        }
+      });
+      Prometheus.StorageLoad.endOperation(timerRef, storage.name, key, idsToLoad.length, dbEntities.length);
     }
-    var remainingCallsCount = idsToLoad.length - idsFromCache.size | 0;
+    let remainingCallsCount = idsToLoad.length - idsFromCache.size | 0;
     if (remainingCallsCount <= 0) {
-      return ;
+      return;
     }
-    var argsToCall = [];
-    for(var idx = 0 ,idx_finish = args.length; idx < idx_finish; ++idx){
-      var arg = args[idx];
+    let argsToCall = [];
+    for (let idx = 0, idx_finish = args.length; idx < idx_finish; ++idx) {
+      let arg = args[idx];
       if (!idsFromCache.has(arg.cacheKey)) {
         argsToCall.push(arg);
       }
-      
     }
     if (Utils.$$Array.notEmpty(argsToCall)) {
       return await executeWithRateLimit(effect, argsToCall, inMemTable, onError, false);
     }
-    
   };
-  return LoadManager.call(loadManager, effectArgs, key, load, (function (args) {
-                return args.cacheKey;
-              }), shouldGroup, (function (hash) {
-                return Utils.Dict.has(inMemTable.dict, hash);
-              }), (function (hash) {
-                return inMemTable.dict[hash];
-              }));
+  return LoadManager.call(loadManager, effectArgs, key, load, args => args.cacheKey, shouldGroup, hash => Utils.Dict.has(inMemTable.dict, hash), hash => inMemTable.dict[hash]);
 }
 
 function loadByField(loadManager, persistence, operator, entityConfig, inMemoryStore, fieldName, fieldValueSchema, shouldGroup, item, fieldValue) {
-  var operatorCallName;
+  let operatorCallName;
   switch (operator) {
     case "Eq" :
-        operatorCallName = "eq";
-        break;
+      operatorCallName = "eq";
+      break;
     case "Gt" :
-        operatorCallName = "gt";
-        break;
+      operatorCallName = "gt";
+      break;
     case "Lt" :
-        operatorCallName = "lt";
-        break;
-    
+      operatorCallName = "lt";
+      break;
   }
-  var key = entityConfig.name + ".getWhere." + fieldName + "." + operatorCallName;
-  var inMemTable = InMemoryStore.getInMemTable(inMemoryStore, entityConfig);
-  var load = async function (fieldValues, param) {
-    var timerRef = Prometheus.StorageLoad.startOperation(key);
-    var size = {
+  let key = entityConfig.name + `.getWhere.` + fieldName + `.` + operatorCallName;
+  let inMemTable = InMemoryStore.getInMemTable(inMemoryStore, entityConfig);
+  let load = async (fieldValues, param) => {
+    let storage = Persistence.getInitializedStorageOrThrow(persistence);
+    let timerRef = Prometheus.StorageLoad.startOperation(storage.name, key);
+    let size = {
       contents: 0
     };
-    var indiciesToLoad = fieldValues.map(function (fieldValue) {
-          return {
-                  fieldName: fieldName,
-                  fieldValue: fieldValue,
-                  operator: operator
-                };
-        });
-    await Promise.all(indiciesToLoad.map(async function (index) {
-              InMemoryTable.Entity.addEmptyIndex(inMemTable, index);
-              try {
-                var tmp;
-                switch (index.operator) {
-                  case "Eq" :
-                      tmp = "=";
-                      break;
-                  case "Gt" :
-                      tmp = ">";
-                      break;
-                  case "Lt" :
-                      tmp = "<";
-                      break;
-                  
-                }
-                var entities = await Persistence.getInitializedStorageOrThrow(persistence).loadByFieldOrThrow(TableIndices.Index.getFieldName(index), fieldValueSchema, index.fieldValue, tmp, entityConfig.table, entityConfig.rowsSchema);
-                Belt_Array.forEach(entities, (function (entity) {
-                        InMemoryTable.Entity.initValue(inMemTable, entity.id, entity, false);
-                      }));
-                size.contents = size.contents + entities.length | 0;
-                return ;
-              }
-              catch (raw_exn){
-                var exn = Caml_js_exceptions.internalToOCamlException(raw_exn);
-                if (exn.RE_EXN_ID === Persistence.StorageError) {
-                  return ErrorHandling.mkLogAndRaise(Logging.createChildFrom(Logging.getItemLogger(item), {
-                                  operator: operatorCallName,
-                                  tableName: entityConfig.table.tableName,
-                                  fieldName: fieldName,
-                                  fieldValue: fieldValue
-                                }), exn.message, exn.reason);
-                }
-                throw exn;
-              }
-            }));
-    return Prometheus.StorageLoad.endOperation(timerRef, key, fieldValues.length, size.contents);
+    let indiciesToLoad = fieldValues.map(fieldValue => ({
+      fieldName: fieldName,
+      fieldValue: fieldValue,
+      operator: operator
+    }));
+    await Promise.all(indiciesToLoad.map(async index => {
+      InMemoryTable.Entity.addEmptyIndex(inMemTable, index);
+      try {
+        let tmp;
+        switch (index.operator) {
+          case "Eq" :
+            tmp = "=";
+            break;
+          case "Gt" :
+            tmp = ">";
+            break;
+          case "Lt" :
+            tmp = "<";
+            break;
+        }
+        let entities = await storage.loadByFieldOrThrow(TableIndices.Index.getFieldName(index), fieldValueSchema, index.fieldValue, tmp, entityConfig.table, entityConfig.rowsSchema);
+        entities.forEach(entity => InMemoryTable.Entity.initValue(inMemTable, entity.id, entity, false));
+        size.contents = size.contents + entities.length | 0;
+        return;
+      } catch (raw_exn) {
+        let exn = Primitive_exceptions.internalToException(raw_exn);
+        if (exn.RE_EXN_ID === Persistence.StorageError) {
+          return ErrorHandling.mkLogAndRaise(Logging.createChildFrom(Logging.getItemLogger(item), {
+            operator: operatorCallName,
+            tableName: entityConfig.table.tableName,
+            fieldName: fieldName,
+            fieldValue: fieldValue
+          }), exn.message, exn.reason);
+        }
+        throw exn;
+      }
+    }));
+    return Prometheus.StorageLoad.endOperation(timerRef, storage.name, key, fieldValues.length, size.contents);
   };
-  return LoadManager.call(loadManager, fieldValue, key, load, (function (fieldValue) {
-                return TableIndices.FieldValue.toString(fieldValue);
-              }), shouldGroup, InMemoryTable.Entity.hasIndex(inMemTable, fieldName, operator), InMemoryTable.Entity.getUnsafeOnIndex(inMemTable, fieldName, operator));
+  return LoadManager.call(loadManager, fieldValue, key, load, fieldValue => TableIndices.FieldValue.toString(fieldValue), shouldGroup, InMemoryTable.Entity.hasIndex(inMemTable, fieldName, operator), InMemoryTable.Entity.getUnsafeOnIndex(inMemTable, fieldName, operator));
 }
 
 export {
-  loadById ,
-  loadByField ,
-  loadEffect ,
+  loadById,
+  loadByField,
+  loadEffect,
 }
 /* Utils Not a pure module */

package/src/LoadManager.res

@@ -1,5 +1,3 @@
-open Belt
-
 module Call = {
   type input
   type output
@@ -31,7 +29,7 @@ type t = {
 }
 
 let make = () => {
-  groups: Js.Dict.empty(),
+  groups: Dict.make(),
   isCollecting: false,
 }
 
@@ -47,22 +45,19 @@ let schedule = async loadManager => {
 
   let groups = loadManager.groups
   groups
-  ->Js.Dict.keys
+  ->Dict.keysToArray
   ->Utils.Array.forEachAsync(async key => {
-    let group = groups->Js.Dict.unsafeGet(key)
+    let group = groups->Dict.getUnsafe(key)
     let calls = group.calls
 
     let inputsToLoad = []
     let currentInputKeys = []
-    calls
-    ->Js.Dict.keys
-    ->Js.Array2.forEach(inputKey => {
-      let call = calls->Js.Dict.unsafeGet(inputKey)
+    calls->Utils.Dict.forEachWithKey((call, inputKey) => {
       if !call.isLoading {
         call.isLoading = true
-        currentInputKeys->Js.Array2.push(inputKey)->ignore
+        currentInputKeys->Array.push(inputKey)->ignore
         if group.hasInMemory(inputKey)->not {
-          inputsToLoad->Js.Array2.push(call.input)->ignore
+          inputsToLoad->Array.push(call.input)->ignore
         }
       }
     })
@@ -70,14 +65,14 @@ let schedule = async loadManager => {
     if inputsToLoad->Utils.Array.isEmpty->not {
       try {
         await group.load(inputsToLoad, ~onError=(~inputKey, ~exn) => {
-          let call = calls->Js.Dict.unsafeGet(inputKey)
+          let call = calls->Dict.getUnsafe(inputKey)
           call.exn = Some(exn)
         })
       } catch {
       | exn => {
           let exn = exn->Utils.prettifyExn
           currentInputKeys->Array.forEach(inputKey => {
-            let call = calls->Js.Dict.unsafeGet(inputKey)
+            let call = calls->Dict.getUnsafe(inputKey)
             call.exn = Some(exn)
           })
         }
@@ -85,8 +80,8 @@ let schedule = async loadManager => {
     }
 
     if currentInputKeys->Utils.Array.isEmpty->not {
-      currentInputKeys->Js.Array2.forEach(inputKey => {
-        let call = calls->Js.Dict.unsafeGet(inputKey)
+      currentInputKeys->Array.forEach(inputKey => {
+        let call = calls->Dict.getUnsafe(inputKey)
         calls->Utils.Dict.deleteInPlace(inputKey)
         switch call.exn {
         | Some(exn) => call.reject(exn->Utils.prettifyExn)
@@ -97,8 +92,8 @@ let schedule = async loadManager => {
       // Clean up executed batch to reset
       // provided load function which
       // might have an outdated function context
-      let latestGroup = groups->Js.Dict.unsafeGet(key)
-      if latestGroup.calls->Js.Dict.keys->Utils.Array.isEmpty {
+      let latestGroup = groups->Dict.getUnsafe(key)
+      if latestGroup.calls->Utils.Dict.isEmpty {
         groups->Utils.Dict.deleteInPlace(key)
       }
     }
@@ -144,7 +139,7 @@ let call = (
     | Some(group) => group
     | None => {
         let g: Group.t = {
-          calls: Js.Dict.empty(),
+          calls: Dict.make(),
           load: load->(
             Utils.magic: (
               (array<'input>, ~onError: (~inputKey: string, ~exn: exn) => unit) => promise<unit>
@@ -158,7 +153,7 @@ let call = (
           ),
           hasInMemory: hasInMemory->(Utils.magic: (string => bool) => string => bool),
         }
-        loadManager.groups->Js.Dict.set(key, g)
+        loadManager.groups->Dict.set(key, g)
         g
       }
     }
@@ -175,11 +170,11 @@ let call = (
             exn: None,
             isLoading: false,
           }
-          group.calls->Js.Dict.set(inputKey, call)
+          group.calls->Dict.set(inputKey, call)
         })
 
         // Don't use ref since it'll allocate an object to store .contents
-        (group.calls->Js.Dict.unsafeGet(inputKey)).promise = promise
+        (group.calls->Dict.getUnsafe(inputKey)).promise = promise
 
         if !loadManager.isCollecting {
           let _: promise<unit> = loadManager->schedule