@rotorsoft/act 0.6.0 → 0.6.2

package/dist/index.js

@@ -197,21 +197,21 @@ async function sleep(ms) {
 
 // src/adapters/InMemoryStore.ts
 var InMemoryStream = class {
-  stream;
-  source;
-  at = -1;
-  retry = -1;
-  blocked = false;
-  error = "";
-  leased_at = void 0;
-  leased_by = void 0;
-  leased_until = void 0;
   constructor(stream, source) {
     this.stream = stream;
     this.source = source;
   }
+  _at = -1;
+  _retry = -1;
+  _blocked = false;
+  _error = "";
+  _leased_by = void 0;
+  _leased_until = void 0;
   get is_avaliable() {
-    return !this.blocked && (!this.leased_until || this.leased_until <= /* @__PURE__ */ new Date());
+    return !this._blocked && (!this._leased_until || this._leased_until <= /* @__PURE__ */ new Date());
+  }
+  get at() {
+    return this._at;
   }
   /**
    * Attempt to lease this stream for processing.
@@ -221,17 +221,18 @@ var InMemoryStream = class {
    * @returns The granted lease or undefined if blocked.
    */
   lease(at, by, millis) {
-    if (this.is_avaliable && at > this.at) {
-      this.leased_at = at;
-      this.leased_by = by;
-      this.leased_until = new Date(Date.now() + millis);
-      millis > 0 && (this.retry = this.retry + 1);
+    if (this.is_avaliable) {
+      if (millis > 0) {
+        this._leased_by = 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
+        retry: this._retry
       };
     }
   }
@@ -241,27 +242,37 @@ var InMemoryStream = class {
    * @param by - Lease holder that processed the watermark.
    */
   ack(at, by) {
-    if (this.leased_by === by && at >= this.at) {
-      this.leased_at = void 0;
-      this.leased_by = void 0;
-      this.leased_until = void 0;
-      this.at = at;
-      this.retry = -1;
-      return true;
+    if (this._leased_by === by) {
+      this._leased_by = void 0;
+      this._leased_until = void 0;
+      this._at = at;
+      this._retry = -1;
+      return {
+        stream: this.stream,
+        source: this.source,
+        at: this._at,
+        by,
+        retry: this._retry
+      };
     }
-    return false;
   }
   /**
    * Block a stream for processing after failing to process and reaching max retries with blocking enabled.
    * @param error Blocked error message.
    */
   block(by, error) {
-    if (this.leased_by === by) {
-      this.blocked = true;
-      this.error = error;
-      return true;
+    if (this._leased_by === by) {
+      this._blocked = true;
+      this._error = error;
+      return {
+        stream: this.stream,
+        source: this.source,
+        at: this._at,
+        by: this._leased_by,
+        retry: this._retry,
+        error: this._error
+      };
     }
-    return false;
   }
 };
 var InMemoryStore = class {
@@ -293,6 +304,15 @@ var InMemoryStore = class {
     this._events.length = 0;
     this._streams = /* @__PURE__ */ new Map();
   }
+  in_query(query, e) {
+    if (query.stream && !RegExp(`^${query.stream}$`).test(e.stream))
+      return false;
+    if (query.names && !query.names.includes(e.name)) return false;
+    if (query.correlation && e.meta?.correlation !== query.correlation)
+      return false;
+    if (e.name === SNAP_EVENT && !query.with_snaps) return false;
+    return true;
+  }
   /**
    * Query events in the store, optionally filtered by query options.
    * @param callback - Function to call for each event.
@@ -301,30 +321,32 @@ var InMemoryStore = class {
    */
   async query(callback, query) {
     await sleep();
-    const {
-      stream,
-      names,
-      before,
-      after = -1,
-      limit,
-      created_before,
-      created_after,
-      correlation,
-      with_snaps = false
-    } = query || {};
-    let i = after + 1, count = 0;
-    while (i < this._events.length) {
-      const e = this._events[i++];
-      if (stream && !RegExp(`^${stream}$`).test(e.stream)) continue;
-      if (names && !names.includes(e.name)) continue;
-      if (correlation && e.meta?.correlation !== correlation) continue;
-      if (created_after && e.created <= created_after) continue;
-      if (e.name === SNAP_EVENT && !with_snaps) continue;
-      if (before && e.id >= before) break;
-      if (created_before && e.created >= created_before) break;
-      callback(e);
-      count++;
-      if (limit && count >= limit) break;
+    let count = 0;
+    if (query?.backward) {
+      let i = (query?.before || this._events.length) - 1;
+      while (i >= 0) {
+        const e = this._events[i--];
+        if (query && !this.in_query(query, e)) continue;
+        if (query?.created_before && e.created >= query.created_before)
+          continue;
+        if (query.after && e.id <= query.after) break;
+        if (query.created_after && e.created <= query.created_after) break;
+        callback(e);
+        count++;
+        if (query?.limit && count >= query.limit) break;
+      }
+    } else {
+      let i = (query?.after ?? -1) + 1;
+      while (i < this._events.length) {
+        const e = this._events[i++];
+        if (query && !this.in_query(query, e)) continue;
+        if (query?.created_after && e.created <= query.created_after) continue;
+        if (query?.before && e.id >= query.before) break;
+        if (query?.created_before && e.created >= query.created_before) break;
+        callback(e);
+        count++;
+        if (query?.limit && count >= query.limit) break;
+      }
     }
     return count;
   }
@@ -366,12 +388,15 @@ var InMemoryStore = class {
   }
   /**
    * Polls the store for unblocked streams needing processing, ordered by lease watermark ascending.
-   * @param limit - Maximum number of streams to poll.
+   * @param lagging - Max number of streams to poll in ascending order.
+   * @param leading - Max number of streams to poll in descending order.
    * @returns The polled streams.
    */
-  async poll(limit) {
+  async poll(lagging, leading) {
     await sleep();
-    return [...this._streams.values()].filter((s) => s.is_avaliable).sort((a, b) => a.at - b.at).slice(0, limit).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 }));
+    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 }));
+    return [...a, ...b];
   }
   /**
    * Lease streams for processing (e.g., for distributed consumers).
@@ -381,10 +406,11 @@ var InMemoryStore = class {
    */
   async lease(leases, millis) {
     await sleep();
-    return leases.map(({ stream, at, by, source }) => {
-      const found = this._streams.get(stream) || // store new correlations
-      this._streams.set(stream, new InMemoryStream(stream, source)).get(stream);
-      return found.lease(at, by, millis);
+    return leases.map((l) => {
+      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);
     }).filter((l) => !!l);
   }
   /**
@@ -393,9 +419,7 @@ var InMemoryStore = class {
    */
   async ack(leases) {
     await sleep();
-    return leases.filter(
-      (lease) => this._streams.get(lease.stream)?.ack(lease.at, lease.by)
-    );
+    return leases.map((l) => this._streams.get(l.stream)?.ack(l.at, l.by)).filter((l) => !!l);
   }
   /**
    * Block a stream for processing after failing to process and reaching max retries with blocking enabled.
@@ -404,9 +428,7 @@ var InMemoryStore = class {
    */
   async block(leases) {
     await sleep();
-    return leases.filter(
-      (lease) => this._streams.get(lease.stream)?.block(lease.by, lease.error)
-    );
+    return leases.map((l) => this._streams.get(l.stream)?.block(l.by, l.error)).filter((l) => !!l);
   }
 };
 
@@ -455,6 +477,62 @@ var SNAP_EVENT = "__snapshot__";
 var store = port(function store2(adapter) {
   return adapter || new InMemoryStore();
 });
+function build_tracer(logLevel2) {
+  if (logLevel2 === "trace") {
+    return {
+      fetched: (fetched) => {
+        const data = Object.fromEntries(
+          fetched.map(({ stream, source, events }) => {
+            const key = source ? `${stream}<-${source}` : stream;
+            const value = Object.fromEntries(
+              events.map(({ id, stream: stream2, name }) => [id, { [stream2]: name }])
+            );
+            return [key, value];
+          })
+        );
+        logger.trace(data, "\u26A1\uFE0F fetch");
+      },
+      correlated: (leases) => {
+        const data = leases.map(({ stream }) => stream).join(" ");
+        logger.trace(`\u26A1\uFE0F correlate ${data}`);
+      },
+      leased: (leases) => {
+        const data = Object.fromEntries(
+          leases.map(({ stream, at, retry }) => [stream, { at, retry }])
+        );
+        logger.trace(data, "\u26A1\uFE0F lease");
+      },
+      acked: (leases) => {
+        const data = Object.fromEntries(
+          leases.map(({ stream, at, retry }) => [stream, { at, retry }])
+        );
+        logger.trace(data, "\u26A1\uFE0F ack");
+      },
+      blocked: (leases) => {
+        const data = Object.fromEntries(
+          leases.map(({ stream, at, retry, error }) => [
+            stream,
+            { at, retry, error }
+          ])
+        );
+        logger.trace(data, "\u26A1\uFE0F block");
+      }
+    };
+  } else {
+    return {
+      fetched: () => {
+      },
+      correlated: () => {
+      },
+      leased: () => {
+      },
+      acked: () => {
+      },
+      blocked: () => {
+      }
+    };
+  }
+}
 
 // src/signals.ts
 process.once("SIGINT", async (arg) => {
@@ -593,40 +671,7 @@ async function action(me, action2, target, payload, reactingTo, skipValidation =
 }
 
 // src/act.ts
-function traceFetch(fetch) {
-  const data = Object.fromEntries(
-    fetch.map(({ stream, source, events }) => {
-      const key = source ? `${stream}<-${source}` : stream;
-      const value = Object.fromEntries(
-        events.map(({ id, stream: stream2, name }) => [id, { [stream2]: name }])
-      );
-      return [key, value];
-    })
-  );
-  logger.trace(data, "\u26A1\uFE0F fetch");
-}
-function traceCorrelated(leases) {
-  const data = leases.map(({ stream }) => stream).join(" ");
-  logger.trace(`\u26A1\uFE0F correlate ${data}`);
-}
-function traceLeased(leases) {
-  const data = Object.fromEntries(
-    leases.map(({ stream, at, retry }) => [stream, { at, retry }])
-  );
-  logger.trace(data, "\u26A1\uFE0F lease");
-}
-function traceAcked(leases) {
-  const data = Object.fromEntries(
-    leases.map(({ stream, at, retry }) => [stream, { at, retry }])
-  );
-  logger.trace(data, "\u26A1\uFE0F ack");
-}
-function traceBlocked(leases) {
-  const data = Object.fromEntries(
-    leases.map(({ stream, at, retry, error }) => [stream, { at, retry, error }])
-  );
-  logger.trace(data, "\u26A1\uFE0F block");
-}
+var tracer = build_tracer(config().logLevel);
 var Act = class {
   /**
    * Create a new Act orchestrator.
@@ -770,24 +815,6 @@ var Act = class {
     }
     return { lease, at };
   }
-  /**
-   * Fetches new events from store according to the fetch options.
-   * @param options - Fetch options.
-   * @returns Fetched streams with next events to process.
-   */
-  async fetch({ streamLimit = 10, eventLimit = 10 }) {
-    const polled = await store().poll(streamLimit);
-    return Promise.all(
-      polled.map(async ({ stream, source, at }) => {
-        const events = await this.query_array({
-          stream: source,
-          after: at,
-          limit: eventLimit
-        });
-        return { stream, source, events };
-      })
-    );
-  }
   /**
    * Drains and processes events from the store, triggering reactions and updating state.
    *
@@ -806,26 +833,31 @@ var Act = class {
     if (!this._drain_locked) {
       try {
         this._drain_locked = true;
-        const fetch = await this.fetch({ streamLimit, eventLimit });
-        fetch.length && traceFetch(fetch);
-        const [last_at, count] = fetch.reduce(
-          ([last_at2, count2], { events }) => [
-            Math.max(last_at2, events.at(-1)?.id || 0),
-            count2 + events.length
-          ],
-          [0, 0]
+        const lagging = Math.ceil(streamLimit * 2 / 3);
+        const leading = streamLimit - lagging;
+        const polled = await store().poll(lagging, leading);
+        const fetched = await Promise.all(
+          polled.map(async ({ stream, source, at }) => {
+            const events = await this.query_array({
+              stream: source,
+              after: at,
+              limit: eventLimit
+            });
+            return { stream, source, at, events };
+          })
         );
-        if (count > 0) {
+        if (fetched.length) {
+          tracer.fetched(fetched);
           const leases = /* @__PURE__ */ new Map();
-          fetch.forEach(({ stream, events }) => {
+          const last_window_at = fetched.reduce(
+            (max, { at, events }) => Math.max(max, events.at(-1)?.id || at),
+            0
+          );
+          fetched.forEach(({ stream, events }) => {
             const payloads = events.flatMap((event) => {
-              const register = this.registry.events[event.name];
-              if (!register) return [];
+              const register = this.registry.events[event.name] || [];
               return [...register.reactions.values()].filter((reaction) => {
-                const resolved = typeof reaction.resolver === "function" ? (
-                  // @ts-expect-error index by key
-                  reaction.resolver(event)
-                ) : reaction.resolver;
+                const resolved = typeof reaction.resolver === "function" ? reaction.resolver(event) : reaction.resolver;
                 return resolved && resolved.target === stream;
               }).map((reaction) => ({ ...reaction, event }));
             });
@@ -833,43 +865,39 @@ var Act = class {
               lease: {
                 stream,
                 by: randomUUID2(),
-                at: events.at(-1)?.id || last_at,
-                // move the lease watermark forward when no events found in window
+                at: events.at(-1)?.id || last_window_at,
+                // ff when no matching events
                 retry: 0
               },
               // @ts-expect-error indexed by key
               payloads
             });
           });
-          if (leases.size) {
-            const leased = await store().lease(
-              [...leases.values()].map((l) => l.lease),
-              leaseMillis
-            );
-            if (leased.length) {
-              traceLeased(leased);
-              const handled = await Promise.all(
-                leased.map(
-                  (lease) => this.handle(lease, leases.get(lease.stream).payloads)
-                )
-              );
-              const acked = await store().ack(
-                handled.filter(({ error }) => !error).map(({ at, lease }) => ({ ...lease, at }))
-              );
-              if (acked.length) {
-                traceAcked(acked);
-                this.emit("acked", acked);
-              }
-              const blocked = await store().block(
-                handled.filter(({ block }) => block).map(({ lease, error }) => ({ ...lease, error }))
-              );
-              if (blocked.length) {
-                traceBlocked(blocked);
-                this.emit("blocked", blocked);
-              }
-              return { leased, acked, blocked };
-            }
+          const leased = await store().lease(
+            [...leases.values()].map((l) => l.lease),
+            leaseMillis
+          );
+          tracer.leased(leased);
+          const handled = await Promise.all(
+            leased.map(
+              (lease) => this.handle(lease, leases.get(lease.stream).payloads)
+            )
+          );
+          const acked = await store().ack(
+            handled.filter(({ error }) => !error).map(({ at, lease }) => ({ ...lease, at }))
+          );
+          if (acked.length) {
+            tracer.acked(acked);
+            this.emit("acked", acked);
+          }
+          const blocked = await store().block(
+            handled.filter(({ block }) => block).map(({ lease, error }) => ({ ...lease, error }))
+          );
+          if (blocked.length) {
+            tracer.blocked(blocked);
+            this.emit("blocked", blocked);
           }
+          return { fetched, leased, acked, blocked };
         }
       } catch (error) {
         logger.error(error);
@@ -877,7 +905,7 @@ var Act = class {
         this._drain_locked = false;
       }
     }
-    return { leased: [], acked: [], blocked: [] };
+    return { fetched: [], leased: [], acked: [], blocked: [] };
   }
   /**
    * Correlates streams using reaction resolvers.
@@ -908,7 +936,7 @@ var Act = class {
         payloads
       }));
       const leased = await store().lease(leases, 0);
-      leased.length && traceCorrelated(leased);
+      leased.length && tracer.correlated(leased);
       return { leased, last_id };
     }
     return { leased: [], last_id };
@@ -1108,6 +1136,7 @@ export {
   ValidationError,
   ZodEmpty,
   act,
+  build_tracer,
   config,
   dispose,
   disposeAndExit,