envio 3.1.0-rc.1 → 3.1.0

package/src/Throttler.res

@@ -16,7 +16,7 @@ let make = (~intervalMillis: int, ~logger) => {
   logger,
 }
 
-let rec startInternal = async (throttler: t) => {
+let rec startInternal = (throttler: t) => {
   switch throttler {
   | {scheduled: Some(fn), isRunning: false, isAwaitingInterval: false} =>
     let timeSinceLastRun = Date.now() -. throttler.lastRunTimeMillis
@@ -27,25 +27,32 @@ let rec startInternal = async (throttler: t) => {
       throttler.scheduled = None
       throttler.lastRunTimeMillis = Date.now()
 
-      switch await fn() {
-      | exception exn =>
-        throttler.logger->Pino.errorExn(
-          Pino.createPinoMessageWithError(
-            "Scheduled action failed in throttler",
-            exn->Utils.prettifyExn,
-          ),
-        )
-      | _ => ()
-      }
-      throttler.isRunning = false
+      // Defer off the schedule call so work queued before it (e.g. a batch) runs first.
+      NodeJs.setImmediate(() => {
+        (
+          async () => {
+            switch await fn() {
+            | exception exn =>
+              throttler.logger->Pino.errorExn(
+                Pino.createPinoMessageWithError(
+                  "Scheduled action failed in throttler",
+                  exn->Utils.prettifyExn,
+                ),
+              )
+            | _ => ()
+            }
+            throttler.isRunning = false
 
-      await throttler->startInternal
+            throttler->startInternal
+          }
+        )()->ignore
+      })
     } else {
       //Store isAwaitingInterval in state so that timers don't continuously get created
       throttler.isAwaitingInterval = true
       let _ = setTimeout(() => {
         throttler.isAwaitingInterval = false
-        throttler->startInternal->ignore
+        throttler->startInternal
       }, Belt.Int.fromFloat(throttler.intervalMillis -. timeSinceLastRun))
     }
   | _ => ()
@@ -54,5 +61,5 @@ let rec startInternal = async (throttler: t) => {
 
 let schedule = (throttler: t, fn) => {
   throttler.scheduled = Some(fn)
-  throttler->startInternal->ignore
+  throttler->startInternal
 }

package/src/Throttler.res.mjs

@@ -15,7 +15,7 @@ function make(intervalMillis, logger) {
   };
 }
 
-async function startInternal(throttler) {
+function startInternal(throttler) {
   let match = throttler.isRunning;
   if (match) {
     return;
@@ -33,20 +33,25 @@ async function startInternal(throttler) {
     throttler.isRunning = true;
     throttler.scheduled = undefined;
     throttler.lastRunTimeMillis = Date.now();
-    try {
-      await fn();
-    } catch (raw_exn) {
-      let exn = Primitive_exceptions.internalToException(raw_exn);
-      throttler.logger.error(Pino.createPinoMessageWithError("Scheduled action failed in throttler", Utils.prettifyExn(exn)));
-    }
-    throttler.isRunning = false;
-    return await startInternal(throttler);
+    setImmediate(() => {
+      (async () => {
+        try {
+          await fn();
+        } catch (raw_exn) {
+          let exn = Primitive_exceptions.internalToException(raw_exn);
+          throttler.logger.error(Pino.createPinoMessageWithError("Scheduled action failed in throttler", Utils.prettifyExn(exn)));
+        }
+        throttler.isRunning = false;
+        return startInternal(throttler);
+      })();
+    });
+  } else {
+    throttler.isAwaitingInterval = true;
+    setTimeout(() => {
+      throttler.isAwaitingInterval = false;
+      startInternal(throttler);
+    }, throttler.intervalMillis - timeSinceLastRun | 0);
   }
-  throttler.isAwaitingInterval = true;
-  setTimeout(() => {
-    throttler.isAwaitingInterval = false;
-    startInternal(throttler);
-  }, throttler.intervalMillis - timeSinceLastRun | 0);
 }
 
 function schedule(throttler, fn) {

package/src/UserContext.res

@@ -55,6 +55,7 @@ let initEffect = (params: contextParams) => {
       input,
       context: effectContext,
       cacheKey: input->S.reverseConvertOrThrow(effect.input)->Utils.Hash.makeOrThrow,
+      checkpointId: params.checkpointId,
     }
     LoadLayer.loadEffect(
       ~loadManager=params.loadManager,

package/src/UserContext.res.mjs

@@ -39,10 +39,12 @@ function initEffect(params) {
   let callEffect = (effect, input) => {
     let effectContext = new EffectContext(params, effect.defaultShouldCache, callEffect);
     let effectArgs_cacheKey = Utils.Hash.makeOrThrow(S$RescriptSchema.reverseConvertOrThrow(input, effect.input));
+    let effectArgs_checkpointId = params.checkpointId;
     let effectArgs = {
       input: input,
       context: effectContext,
-      cacheKey: effectArgs_cacheKey
+      cacheKey: effectArgs_cacheKey,
+      checkpointId: effectArgs_checkpointId
     };
     return LoadLayer.loadEffect(params.loadManager, params.persistence, effect, effectArgs, params.inMemoryStore, params.isPreload, params.item);
   };

package/src/bindings/NodeJs.res

@@ -8,6 +8,7 @@ type exitCode = | @as(0) Success | @as(1) Failure
 // which exposes named exports (exit, cwd) but not EventEmitter prototype methods (on, off, emit).
 @val external globalProcess: t = "process"
 @send external onUnhandledRejection: (t, @as("unhandledRejection") _, exn => unit) => unit = "on"
+@val external setImmediate: (unit => unit) => unit = "setImmediate"
 
 module Util = {
   @unboxed