@rotorsoft/act 0.6.0 → 0.6.1

package/dist/index.js

@@ -367,11 +367,12 @@ 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 descending - Whether to poll streams in descending order (aka poll the most advanced first).
    * @returns The polled streams.
    */
-  async poll(limit) {
+  async poll(limit, descending = false) {
     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 }));
+    return [...this._streams.values()].filter((s) => s.is_avaliable).sort((a, b) => descending ? b.at - a.at : a.at - b.at).slice(0, limit).map(({ stream, source, at }) => ({ stream, source, at }));
   }
   /**
    * Lease streams for processing (e.g., for distributed consumers).
@@ -455,6 +456,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 +650,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 +794,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.
    *
@@ -801,14 +807,25 @@ var Act = class {
   async drain({
     streamLimit = 10,
     eventLimit = 10,
-    leaseMillis = 1e4
+    leaseMillis = 1e4,
+    descending = false
   } = {}) {
     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(
+        const polled = await store().poll(streamLimit, descending);
+        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, events };
+          })
+        );
+        fetched.length && tracer.fetched(fetched);
+        const [last_at, count] = fetched.reduce(
           ([last_at2, count2], { events }) => [
             Math.max(last_at2, events.at(-1)?.id || 0),
             count2 + events.length
@@ -817,7 +834,7 @@ var Act = class {
         );
         if (count > 0) {
           const leases = /* @__PURE__ */ new Map();
-          fetch.forEach(({ stream, events }) => {
+          fetched.forEach(({ stream, events }) => {
             const payloads = events.flatMap((event) => {
               const register = this.registry.events[event.name];
               if (!register) return [];
@@ -847,7 +864,7 @@ var Act = class {
               leaseMillis
             );
             if (leased.length) {
-              traceLeased(leased);
+              tracer.leased(leased);
               const handled = await Promise.all(
                 leased.map(
                   (lease) => this.handle(lease, leases.get(lease.stream).payloads)
@@ -857,14 +874,14 @@ var Act = class {
                 handled.filter(({ error }) => !error).map(({ at, lease }) => ({ ...lease, at }))
               );
               if (acked.length) {
-                traceAcked(acked);
+                tracer.acked(acked);
                 this.emit("acked", acked);
               }
               const blocked = await store().block(
                 handled.filter(({ block }) => block).map(({ lease, error }) => ({ ...lease, error }))
               );
               if (blocked.length) {
-                traceBlocked(blocked);
+                tracer.blocked(blocked);
                 this.emit("blocked", blocked);
               }
               return { leased, acked, blocked };
@@ -908,7 +925,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 +1125,7 @@ export {
   ValidationError,
   ZodEmpty,
   act,
+  build_tracer,
   config,
   dispose,
   disposeAndExit,