@rotorsoft/act 0.19.1 → 0.21.0

package/dist/index.js

@@ -1,6 +1,42 @@
 // src/ports.ts
 import { pino } from "pino";
 
+// src/adapters/InMemoryCache.ts
+var InMemoryCache = class {
+  _entries = /* @__PURE__ */ new Map();
+  _maxSize;
+  constructor(options) {
+    this._maxSize = options?.maxSize ?? 1e3;
+  }
+  async get(stream) {
+    const entry = this._entries.get(stream);
+    if (!entry) return void 0;
+    this._entries.delete(stream);
+    this._entries.set(stream, entry);
+    return entry;
+  }
+  async set(stream, entry) {
+    this._entries.delete(stream);
+    if (this._entries.size >= this._maxSize) {
+      const first = this._entries.keys().next().value;
+      this._entries.delete(first);
+    }
+    this._entries.set(stream, entry);
+  }
+  async invalidate(stream) {
+    this._entries.delete(stream);
+  }
+  async clear() {
+    this._entries.clear();
+  }
+  async dispose() {
+    this._entries.clear();
+  }
+  get size() {
+    return this._entries.size;
+  }
+};
+
 // src/types/errors.ts
 var Errors = {
   ValidationError: "ERR_VALIDATION",
@@ -355,41 +391,54 @@ var InMemoryStore = class {
     });
   }
   /**
-   * Polls the store for unblocked streams needing processing, ordered by lease watermark ascending.
-   * @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.
+   * Atomically discovers and leases streams for processing.
+   * Fuses poll + lease into a single operation.
+   * @param lagging - Max streams from lagging frontier.
+   * @param leading - Max streams from leading frontier.
+   * @param by - Lease holder identifier.
+   * @param millis - Lease duration in milliseconds.
+   * @returns Granted leases.
    */
-  async poll(lagging, leading) {
+  async claim(lagging, leading, by, millis) {
     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 available = [...this._streams.values()].filter((s) => s.is_avaliable);
+    const lag = available.sort((a, b) => a.at - b.at).slice(0, lagging).map((s) => ({
+      stream: s.stream,
+      source: s.source,
+      at: s.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,
+    const lead = available.sort((a, b) => b.at - a.at).slice(0, leading).map((s) => ({
+      stream: s.stream,
+      source: s.source,
+      at: s.at,
       lagging: false
     }));
-    return [...a, ...b];
+    const seen = /* @__PURE__ */ new Set();
+    const combined = [...lag, ...lead].filter((p) => {
+      if (seen.has(p.stream)) return false;
+      seen.add(p.stream);
+      return true;
+    });
+    return combined.map(
+      (p) => this._streams.get(p.stream)?.lease({ ...p, by, retry: 0 }, millis)
+    ).filter((l) => !!l);
   }
   /**
-   * Lease streams for processing (e.g., for distributed consumers).
-   * @param leases - Lease requests for streams, including end-of-lease watermark, lease holder, and source stream.
-   * @param leaseMilis - Lease duration in milliseconds.
-   * @returns Granted leases.
+   * Registers streams for event processing.
+   * @param streams - Streams to register with optional source.
+   * @returns Number of newly registered streams.
    */
-  async lease(leases, millis) {
+  async subscribe(streams) {
     await sleep();
-    return leases.map((l) => {
-      if (!this._streams.has(l.stream)) {
-        this._streams.set(l.stream, new InMemoryStream(l.stream, l.source));
+    let count = 0;
+    for (const { stream, source } of streams) {
+      if (!this._streams.has(stream)) {
+        this._streams.set(stream, new InMemoryStream(stream, source));
+        count++;
       }
-      return this._streams.get(l.stream)?.lease(l, millis);
-    }).filter((l) => !!l);
+    }
+    return count;
   }
   /**
    * Acknowledge completion of processing for leased streams.
@@ -455,6 +504,9 @@ var SNAP_EVENT = "__snapshot__";
 var store = port(function store2(adapter) {
   return adapter || new InMemoryStore();
 });
+var cache = port(function cache2(adapter) {
+  return adapter || new InMemoryCache();
+});
 function build_tracer(logLevel2) {
   if (logLevel2 === "trace") {
     return {
@@ -470,8 +522,8 @@ function build_tracer(logLevel2) {
         );
         logger.trace(data, "\u26A1\uFE0F fetch");
       },
-      correlated: (leases) => {
-        const data = leases.map(({ stream }) => stream).join(" ");
+      correlated: (streams) => {
+        const data = streams.map(({ stream }) => stream).join(" ");
         logger.trace(`\u26A1\uFE0F correlate ${data}`);
       },
       leased: (leases) => {
@@ -556,11 +608,12 @@ async function snap(snapshot) {
   }
 }
 async function load(me, stream, callback) {
-  let state2 = me.init ? me.init() : {};
-  let patches = 0;
-  let snaps = 0;
+  const cached = await cache().get(stream);
+  let state2 = cached?.state ?? (me.init ? me.init() : {});
+  let patches = cached?.patches ?? 0;
+  let snaps = cached?.snaps ?? 0;
   let event;
-  await store().query(
+  const count = await store().query(
     (e) => {
       event = e;
       if (e.name === SNAP_EVENT) {
@@ -573,9 +626,12 @@ async function load(me, stream, callback) {
       }
       callback && callback({ event, state: state2, patches, snaps });
     },
-    { stream, with_snaps: true }
+    { stream, with_snaps: !cached, after: cached?.event_id }
+  );
+  logger.trace(
+    state2,
+    `\u{1F7E2} load ${stream}${cached && count === 0 ? " (cached)" : ""}`
   );
-  logger.trace(state2, `\u{1F7E2} load ${stream}`);
   return { event, state: state2, patches, snaps };
 }
 async function action(me, action2, target, payload, reactingTo, skipValidation = false) {
@@ -631,13 +687,21 @@ async function action(me, action2, target, payload, reactingTo, skipValidation =
     emitted.map((e) => e.data),
     `\u{1F534} commit ${stream}.${emitted.map((e) => e.name).join(", ")}`
   );
-  const committed = await store().commit(
-    stream,
-    emitted,
-    meta,
-    // TODO: review reactions not enforcing expected version
-    reactingTo ? void 0 : expected
-  );
+  let committed;
+  try {
+    committed = await store().commit(
+      stream,
+      emitted,
+      meta,
+      // TODO: review reactions not enforcing expected version
+      reactingTo ? void 0 : expected
+    );
+  } catch (error) {
+    if (error.name === "ERR_CONCURRENCY") {
+      void cache().invalidate(stream);
+    }
+    throw error;
+  }
   let { state: state2, patches } = snapshot;
   const snapshots = committed.map((event) => {
     const p = me.patch[event.name](event, state2);
@@ -646,7 +710,15 @@ async function action(me, action2, target, payload, reactingTo, skipValidation =
     return { event, state: state2, patches, snaps: snapshot.snaps, patch: p };
   });
   const last = snapshots.at(-1);
-  me.snap && me.snap(last) && void snap(last);
+  const snapped = me.snap && me.snap(last);
+  void cache().set(stream, {
+    state: last.state,
+    version: last.event.version,
+    event_id: last.event.id,
+    patches: snapped ? 0 : last.patches,
+    snaps: snapped ? last.snaps + 1 : last.snaps
+  });
+  if (snapped) void snap(last);
   return snapshots;
 }
 
@@ -970,9 +1042,16 @@ var Act = class {
         this._drain_locked = true;
         const lagging = Math.ceil(streamLimit * this._drain_lag2lead_ratio);
         const leading = streamLimit - lagging;
-        const polled = await store().poll(lagging, leading);
+        const leased = await store().claim(
+          lagging,
+          leading,
+          randomUUID2(),
+          leaseMillis
+        );
+        if (!leased.length)
+          return { fetched: [], leased: [], acked: [], blocked: [] };
         const fetched = await Promise.all(
-          polled.map(async ({ stream, source, at, lagging: lagging2 }) => {
+          leased.map(async ({ stream, source, at, lagging: lagging2 }) => {
             const events = await this.query_array({
               stream: source,
               after: at,
@@ -981,71 +1060,60 @@ var Act = class {
             return { stream, source, at, lagging: lagging2, events };
           })
         );
-        if (fetched.length) {
-          tracer.fetched(fetched);
-          const leases = /* @__PURE__ */ new Map();
-          const fetch_window_at = fetched.reduce(
-            (max, { at, events }) => Math.max(max, events.at(-1)?.id || at),
-            0
-          );
-          fetched.forEach(({ stream, lagging: lagging2, events }) => {
-            const payloads = events.flatMap((event) => {
-              const register = this.registry.events[event.name];
-              if (!register) return [];
-              return [...register.reactions.values()].filter((reaction) => {
-                const resolved = typeof reaction.resolver === "function" ? reaction.resolver(event) : reaction.resolver;
-                return resolved && resolved.target === stream;
-              }).map((reaction) => ({ ...reaction, event }));
-            });
-            leases.set(stream, {
-              lease: {
-                stream,
-                by: randomUUID2(),
-                at: events.at(-1)?.id || fetch_window_at,
-                // ff when no matching events
-                retry: 0,
-                lagging: lagging2
-              },
-              payloads
-            });
+        tracer.fetched(fetched);
+        const payloadsMap = /* @__PURE__ */ new Map();
+        const fetch_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 [];
+            return [...register.reactions.values()].filter((reaction) => {
+              const resolved = typeof reaction.resolver === "function" ? reaction.resolver(event) : reaction.resolver;
+              return resolved && resolved.target === stream;
+            }).map((reaction) => ({ ...reaction, event }));
           });
-          const leased = await store().lease(
-            [...leases.values()].map(({ lease }) => lease),
-            leaseMillis
-          );
-          tracer.leased(leased);
-          const handled = await Promise.all(
-            leased.map(
-              (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 }))
-          );
-          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 };
+          payloadsMap.set(stream, payloads);
+        });
+        tracer.leased(leased);
+        const handled = await Promise.all(
+          leased.map((lease) => {
+            const streamFetch = fetched.find((f) => f.stream === lease.stream);
+            const at = streamFetch?.events.at(-1)?.id || fetch_window_at;
+            return this.handle(
+              { ...lease, at },
+              payloadsMap.get(lease.stream) || []
+            );
+          })
+        );
+        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 }))
+        );
+        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);
       } finally {
@@ -1108,26 +1176,31 @@ var Act = class {
       if (register) {
         for (const reaction of register.reactions.values()) {
           const resolved = typeof reaction.resolver === "function" ? reaction.resolver(event) : reaction.resolver;
-          resolved && (correlated.get(resolved.target) || correlated.set(resolved.target, []).get(resolved.target)).push({ ...reaction, source: resolved.source, event });
+          if (resolved) {
+            const entry = correlated.get(resolved.target) || {
+              source: resolved.source,
+              payloads: []
+            };
+            entry.payloads.push({
+              ...reaction,
+              source: resolved.source,
+              event
+            });
+            correlated.set(resolved.target, entry);
+          }
         }
       }
     }, query);
     if (correlated.size) {
-      const leases = [...correlated.entries()].map(([stream, payloads]) => ({
+      const streams = [...correlated.entries()].map(([stream, { source }]) => ({
         stream,
-        // TODO: by convention, the first defined source wins (this can be tricky)
-        source: payloads.find((p) => p.source)?.source || void 0,
-        by: randomUUID2(),
-        at: 0,
-        retry: 0,
-        lagging: true,
-        payloads
+        source
       }));
-      const leased = await store().lease(leases, 0);
-      leased.length && tracer.correlated(leased);
-      return { leased, last_id };
+      const subscribed = await store().subscribe(streams);
+      subscribed && tracer.correlated(streams);
+      return { subscribed, last_id };
     }
-    return { leased: [], last_id };
+    return { subscribed: 0, last_id };
   }
   /**
    * Starts automatic periodic correlation worker for discovering new streams.
@@ -1191,7 +1264,7 @@ var Act = class {
     this._correlation_timer = setInterval(
       () => this.correlate({ ...query, after, limit }).then((result) => {
         after = result.last_id;
-        if (callback && result.leased.length) callback(result.leased);
+        if (callback && result.subscribed) callback(result.subscribed);
       }).catch(console.error),
       frequency
     );
@@ -1275,8 +1348,8 @@ var Act = class {
       (async () => {
         let lastDrain;
         for (let i = 0; i < maxPasses; i++) {
-          const { leased } = await this.correlate(correlateQuery);
-          if (leased.length === 0 && i > 0) break;
+          const { subscribed } = await this.correlate(correlateQuery);
+          if (subscribed === 0 && i > 0) break;
           lastDrain = await this.drain(drainOptions);
           if (!lastDrain.acked.length && !lastDrain.blocked.length) break;
         }
@@ -1705,6 +1778,8 @@ export {
   Errors,
   EventMetaSchema,
   ExitCodes,
+  InMemoryCache,
+  InMemoryStore,
   InvariantError,
   LogLevels,
   PackageSchema,
@@ -1715,6 +1790,7 @@ export {
   ZodEmpty,
   act,
   build_tracer,
+  cache,
   config,
   dispose,
   disposeAndExit,