@rotorsoft/act 0.6.2 → 0.6.4

package/dist/index.js

@@ -215,53 +215,54 @@ var InMemoryStream = class {
   }
   /**
    * Attempt to lease this stream for processing.
-   * @param at - The end-of-lease watermark.
-   * @param by - The lease holder.
+   * @param lease - The lease request.
    * @param millis - Lease duration in milliseconds.
    * @returns The granted lease or undefined if blocked.
    */
-  lease(at, by, millis) {
+  lease(lease, millis) {
     if (this.is_avaliable) {
       if (millis > 0) {
-        this._leased_by = by;
+        this._leased_by = lease.by;
         this._leased_until = new Date(Date.now() + millis);
         this._retry = this._retry + 1;
       }
       return {
         stream: this.stream,
         source: this.source,
-        at,
-        by,
-        retry: this._retry
+        at: lease.at,
+        by: lease.by,
+        retry: this._retry,
+        lagging: lease.lagging
       };
     }
   }
   /**
    * Acknowledge completion of processing for this stream.
-   * @param at - Last processed watermark.
-   * @param by - Lease holder that processed the watermark.
+   * @param lease - The lease request.
    */
-  ack(at, by) {
-    if (this._leased_by === by) {
+  ack(lease) {
+    if (this._leased_by === lease.by) {
       this._leased_by = void 0;
       this._leased_until = void 0;
-      this._at = at;
+      this._at = lease.at;
       this._retry = -1;
       return {
         stream: this.stream,
         source: this.source,
         at: this._at,
-        by,
-        retry: this._retry
+        by: lease.by,
+        retry: this._retry,
+        lagging: lease.lagging
       };
     }
   }
   /**
    * Block a stream for processing after failing to process and reaching max retries with blocking enabled.
+   * @param lease - The lease request.
    * @param error Blocked error message.
    */
-  block(by, error) {
-    if (this._leased_by === by) {
+  block(lease, error) {
+    if (this._leased_by === lease.by) {
       this._blocked = true;
       this._error = error;
       return {
@@ -270,7 +271,8 @@ var InMemoryStream = class {
         at: this._at,
         by: this._leased_by,
         retry: this._retry,
-        error: this._error
+        error: this._error,
+        lagging: lease.lagging
       };
     }
   }
@@ -394,8 +396,18 @@ var InMemoryStore = class {
    */
   async poll(lagging, leading) {
     await sleep();
-    const a = [...this._streams.values()].filter((s) => s.is_avaliable).sort((a2, b2) => a2.at - b2.at).slice(0, lagging).map(({ stream, source, at }) => ({ stream, source, at }));
-    const b = [...this._streams.values()].filter((s) => s.is_avaliable).sort((a2, b2) => b2.at - a2.at).slice(0, leading).map(({ stream, source, at }) => ({ stream, source, at }));
+    const a = [...this._streams.values()].filter((s) => s.is_avaliable).sort((a2, b2) => a2.at - b2.at).slice(0, lagging).map(({ stream, source, at }) => ({
+      stream,
+      source,
+      at,
+      lagging: true
+    }));
+    const b = [...this._streams.values()].filter((s) => s.is_avaliable).sort((a2, b2) => b2.at - a2.at).slice(0, leading).map(({ stream, source, at }) => ({
+      stream,
+      source,
+      at,
+      lagging: false
+    }));
     return [...a, ...b];
   }
   /**
@@ -410,7 +422,7 @@ var InMemoryStore = class {
       if (!this._streams.has(l.stream)) {
         this._streams.set(l.stream, new InMemoryStream(l.stream, l.source));
       }
-      return this._streams.get(l.stream)?.lease(l.at, l.by, millis);
+      return this._streams.get(l.stream)?.lease(l, millis);
     }).filter((l) => !!l);
   }
   /**
@@ -419,7 +431,7 @@ var InMemoryStore = class {
    */
   async ack(leases) {
     await sleep();
-    return leases.map((l) => this._streams.get(l.stream)?.ack(l.at, l.by)).filter((l) => !!l);
+    return leases.map((l) => this._streams.get(l.stream)?.ack(l)).filter((l) => !!l);
   }
   /**
    * Block a stream for processing after failing to process and reaching max retries with blocking enabled.
@@ -428,7 +440,7 @@ var InMemoryStore = class {
    */
   async block(leases) {
     await sleep();
-    return leases.map((l) => this._streams.get(l.stream)?.block(l.by, l.error)).filter((l) => !!l);
+    return leases.map((l) => this._streams.get(l.stream)?.block(l, l.error)).filter((l) => !!l);
   }
 };
 
@@ -688,6 +700,7 @@ var Act = class {
   }
   _emitter = new EventEmitter();
   _drain_locked = false;
+  _drain_lag2lead_ratio = 0.5;
   _correlation_interval = void 0;
   emit(event, args) {
     return this._emitter.emit(event, args);
@@ -790,7 +803,7 @@ var Act = class {
    * @returns The lease with results
    */
   async handle(lease, payloads) {
-    if (payloads.length === 0) return { lease, at: lease.at };
+    if (payloads.length === 0) return { lease, handled: 0, at: lease.at };
     const stream = lease.stream;
     let at = payloads.at(0).event.id, handled = 0;
     lease.retry > 0 && logger.warn(`Retrying ${stream}@${at} (${lease.retry}).`);
@@ -806,6 +819,7 @@ var Act = class {
         block && logger.error(`Blocking ${stream} after ${lease.retry} retries.`);
         return {
           lease,
+          handled,
           at,
           // only report error when nothing was handled
           error: handled === 0 ? error.message : void 0,
@@ -813,7 +827,7 @@ var Act = class {
         };
       }
     }
-    return { lease, at };
+    return { lease, handled, at };
   }
   /**
    * Drains and processes events from the store, triggering reactions and updating state.
@@ -833,27 +847,27 @@ var Act = class {
     if (!this._drain_locked) {
       try {
         this._drain_locked = true;
-        const lagging = Math.ceil(streamLimit * 2 / 3);
+        const lagging = Math.ceil(streamLimit * this._drain_lag2lead_ratio);
         const leading = streamLimit - lagging;
         const polled = await store().poll(lagging, leading);
         const fetched = await Promise.all(
-          polled.map(async ({ stream, source, at }) => {
+          polled.map(async ({ stream, source, at, lagging: lagging2 }) => {
             const events = await this.query_array({
               stream: source,
               after: at,
               limit: eventLimit
             });
-            return { stream, source, at, events };
+            return { stream, source, at, lagging: lagging2, events };
           })
         );
         if (fetched.length) {
           tracer.fetched(fetched);
           const leases = /* @__PURE__ */ new Map();
-          const last_window_at = fetched.reduce(
+          const fetch_window_at = fetched.reduce(
             (max, { at, events }) => Math.max(max, events.at(-1)?.id || at),
             0
           );
-          fetched.forEach(({ stream, events }) => {
+          fetched.forEach(({ stream, lagging: lagging2, events }) => {
             const payloads = events.flatMap((event) => {
               const register = this.registry.events[event.name] || [];
               return [...register.reactions.values()].filter((reaction) => {
@@ -865,16 +879,17 @@ var Act = class {
               lease: {
                 stream,
                 by: randomUUID2(),
-                at: events.at(-1)?.id || last_window_at,
+                at: events.at(-1)?.id || fetch_window_at,
                 // ff when no matching events
-                retry: 0
+                retry: 0,
+                lagging: lagging2
               },
               // @ts-expect-error indexed by key
               payloads
             });
           });
           const leased = await store().lease(
-            [...leases.values()].map((l) => l.lease),
+            [...leases.values()].map(({ lease }) => lease),
             leaseMillis
           );
           tracer.leased(leased);
@@ -883,6 +898,17 @@ var Act = class {
               (lease) => this.handle(lease, leases.get(lease.stream).payloads)
             )
           );
+          const [lagging_handled, leading_handled] = handled.reduce(
+            ([lagging_handled2, leading_handled2], { lease, handled: handled2 }) => [
+              lagging_handled2 + (lease.lagging ? handled2 : 0),
+              leading_handled2 + (lease.lagging ? 0 : handled2)
+            ],
+            [0, 0]
+          );
+          const lagging_avg = lagging > 0 ? lagging_handled / lagging : 0;
+          const leading_avg = leading > 0 ? leading_handled / leading : 0;
+          const total = lagging_avg + leading_avg;
+          this._drain_lag2lead_ratio = total > 0 ? Math.max(0.2, Math.min(0.8, lagging_avg / total)) : 0.5;
           const acked = await store().ack(
             handled.filter(({ error }) => !error).map(({ at, lease }) => ({ ...lease, at }))
           );
@@ -933,6 +959,7 @@ var Act = class {
         by: randomUUID2(),
         at: 0,
         retry: 0,
+        lagging: true,
         payloads
       }));
       const leased = await store().lease(leases, 0);