@rotorsoft/act 1.18.7 → 1.19.0

package/dist/index.js

@@ -1242,6 +1242,7 @@ async function truncate_and_warm_cache(guarded, seed_states, guard_events, corre
       const state2 = seed_states.get(stream);
       if (state2 && entry) {
         await cache().set(stream, {
+          stream,
           state: state2,
           version: entry.committed.version,
           event_id: entry.committed.id,
@@ -1746,6 +1747,7 @@ async function load(me, target, callback) {
   );
   if (replayed > 0 && !time_travel && event && !me.pii_aware) {
     await cache().set(stream, {
+      stream,
       state: state2,
       version: event.version,
       event_id: event.id,
@@ -1861,6 +1863,7 @@ async function action(me, action2, target, payload, options) {
       const snapped = me.snap?.(last);
       if (!me.pii_aware) {
         cache().set(stream, {
+          stream,
           state: last.state,
           version: last.event.version,
           event_id: last.event.id,
@@ -2420,6 +2423,89 @@ var SettleLoop = class {
   }
 };
 
+// src/internal/state-fold.ts
+import { patch as patch2 } from "@rotorsoft/act-patch";
+import { z as z5 } from "zod";
+var DEFAULT_FOLD_FLUSH_EVERY = 1e3;
+var DEFAULT_MAX_CACHED_STATES = 1e4;
+var FoldOptionsSchema = z5.object({
+  flushEvery: z5.number().int().min(1).default(DEFAULT_FOLD_FLUSH_EVERY),
+  maxCachedStates: z5.number().int().min(1).default(DEFAULT_MAX_CACHED_STATES)
+});
+function resolveFoldConfig(options) {
+  return FoldOptionsSchema.parse(options);
+}
+function make_fold_handler(me, flush, config2) {
+  const cache2 = /* @__PURE__ */ new Map();
+  const row = ({ dirty: _, ...row2 }) => row2;
+  const flush_dirty = async () => {
+    const rows = [];
+    const flushed = [];
+    for (const f of cache2.values())
+      if (f.dirty) {
+        rows.push(row(f));
+        flushed.push(f);
+      }
+    if (rows.length === 0) return;
+    await flush(rows);
+    for (const f of flushed) f.dirty = false;
+  };
+  return async (events) => {
+    let folded_since_flush = 0;
+    for (const event of events) {
+      const stream = event.stream;
+      let fold = cache2.get(stream);
+      if (fold) {
+        cache2.delete(stream);
+        cache2.set(stream, fold);
+      } else {
+        if (cache2.size >= config2.maxCachedStates) {
+          const oldest = cache2.keys().next().value;
+          const evictee = cache2.get(oldest);
+          if (evictee.dirty) await flush([row(evictee)]);
+          cache2.delete(oldest);
+        }
+        const snapshot = await load(me, { stream });
+        const entry = await cache().get(stream);
+        const frontier = entry ?? {
+          version: snapshot.event.version,
+          event_id: snapshot.event.id,
+          patches: snapshot.patches,
+          snaps: snapshot.snaps
+        };
+        fold = {
+          stream,
+          state: snapshot.state,
+          version: frontier.version,
+          event_id: frontier.event_id,
+          patches: frontier.patches,
+          snaps: frontier.snaps,
+          dirty: true
+        };
+        cache2.set(stream, fold);
+      }
+      if (event.id > fold.event_id) {
+        const reducer = me.patch[event.name];
+        fold.state = patch2(
+          fold.state,
+          reducer(event, fold.state)
+        );
+        fold.version = event.version;
+        fold.event_id = event.id;
+        fold.patches++;
+        fold.dirty = true;
+      } else {
+        fold.dirty = true;
+      }
+      if (++folded_since_flush >= config2.flushEvery) {
+        await flush_dirty();
+        folded_since_flush = 0;
+      }
+    }
+    await flush_dirty();
+  };
+}
+
 // src/act.ts
 var DEFAULT_MAX_SUBSCRIBED_STREAMS = 1e3;
 var DEFAULT_SETTLE_DEBOUNCE_MS = 10;
@@ -3873,7 +3959,44 @@ function _projection(target) {
           target,
           batchHandler: handler
         })
-      })
+      }),
+      of: (state2, options = {}) => {
+        if (Object.keys(events).length > 0)
+          throw new Error(
+            `Projection "${target}" mixes .of() with .on() handlers \u2014 a projection either folds a state or declares handlers, never both`
+          );
+        const config2 = resolveFoldConfig(options);
+        const fold_events = {};
+        for (const [name, schema] of Object.entries(state2.events)) {
+          const noop = {
+            [`${target}_fold`]: async () => {
+            }
+          }[`${target}_fold`];
+          fold_events[name] = {
+            schema,
+            reactions: /* @__PURE__ */ new Map([
+              [
+                `${target}_fold`,
+                {
+                  handler: noop,
+                  resolver: { target },
+                  options: { blockOnError: true, maxRetries: 3 }
+                }
+              ]
+            ])
+          };
+        }
+        return {
+          flush: (handler) => ({
+            build: () => ({
+              _tag: "Projection",
+              events: fold_events,
+              target,
+              batchHandler: make_fold_handler(state2, handler, config2)
+            })
+          })
+        };
+      }
     });
   }
   return base;