@rotorsoft/act 1.18.8 → 1.20.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,
@@ -1555,7 +1556,7 @@ var DEFAULT_BATCH = 500;
 async function snap(snapshot) {
   const { id, stream, name, meta, version } = snapshot.event;
   try {
-    await store().commit(
+    const [committed] = await store().commit(
       stream,
       [{ name: SNAP_EVENT, data: snapshot.state }],
       {
@@ -1565,6 +1566,7 @@ async function snap(snapshot) {
       version
       // IMPORTANT! - state events are committed right after the snapshot event
     );
+    return committed;
   } catch (error) {
     const reason = error instanceof Error ? error.message : String(error);
     log().warn(
@@ -1746,6 +1748,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,
@@ -1776,7 +1779,7 @@ async function action(me, action2, target, payload, options) {
       const snapshot = await load(me, { stream, actor: target.actor });
       if (snapshot.event?.name === TOMBSTONE_EVENT)
         throw new StreamClosedError(stream);
-      const expected = expectedVersion ?? snapshot.event?.version;
+      const expected = expectedVersion ?? (snapshot.version >= 0 ? snapshot.version : void 0);
       if (me.given) {
         const invariants = me.given[action2] || [];
         invariants.forEach(({ valid: valid2, description }) => {
@@ -1858,17 +1861,22 @@ async function action(me, action2, target, payload, options) {
         };
       });
       const last = snapshots.at(-1);
-      const snapped = me.snap?.(last);
+      const contiguous = committed[0].version === snapshot.version + 1;
+      const snapped = contiguous && me.snap?.(last);
+      const snap_event = snapped ? await snap(last) : void 0;
       if (!me.pii_aware) {
-        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
-        }).catch((err) => log().error(err));
+        if (contiguous)
+          cache().set(stream, {
+            stream,
+            state: last.state,
+            version: snap_event?.version ?? last.event.version,
+            event_id: snap_event?.id ?? last.event.id,
+            patches: snap_event ? 0 : last.patches,
+            snaps: snap_event ? last.snaps + 1 : last.snaps
+          }).catch((err) => log().error(err));
+        else
+          cache().invalidate(stream).catch((err) => log().error(err));
       }
-      if (snapped) void snap(last);
       return snapshots;
     } catch (error) {
       if (!(error instanceof ConcurrencyError)) throw error;
@@ -2420,6 +2428,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;
@@ -3654,6 +3745,7 @@ function act() {
     autoclose_archiver: (state_name) => _aa.get(state_name) ?? null
   };
   const pending_projections = [];
+  const fold_projections = [];
   const batch_handlers = /* @__PURE__ */ new Map();
   const lanes = [];
   let _built = false;
@@ -3719,6 +3811,8 @@ function act() {
     withProjection: (proj) => {
       merge_projection(proj, registry.events);
       register_batch_handler(proj, batch_handlers);
+      if (proj.fold)
+        fold_projections.push(proj);
       return builder;
     },
     withActor: () => builder,
@@ -3732,6 +3826,26 @@ function act() {
         for (const proj of pending_projections) {
           merge_projection(proj, registry.events);
           register_batch_handler(proj, batch_handlers);
+          if (proj.fold) fold_projections.push(proj);
+        }
+        for (const proj of fold_projections) {
+          const fold = proj.fold;
+          const merged = states.get(fold.name);
+          if (!merged)
+            throw new Error(
+              `State projection "${proj.target}" folds "${fold.name}", which is not registered \u2014 add it via withState/withSlice before build()`
+            );
+          const missing = Object.keys(merged.events).filter(
+            (event_name) => !(event_name in proj.events)
+          );
+          if (missing.length > 0)
+            throw new Error(
+              `State projection "${proj.target}" of "${fold.name}" is missing events ${missing.join(", ")} \u2014 pass every partial of the state to .of()`
+            );
+          batch_handlers.set(
+            proj.target,
+            make_fold_handler(merged, fold.flush, fold.config)
+          );
         }
         finalize_deprecations();
         validate_lane_references(registry, lanes);
@@ -3873,7 +3987,57 @@ function _projection(target) {
           target,
           batchHandler: handler
         })
-      })
+      }),
+      of: (...args) => {
+        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 is_state = (a) => !!a && typeof a.init === "function";
+        const partials = args.filter(is_state);
+        const options = args.find((a) => !is_state(a)) ?? {};
+        if (partials.length === 0)
+          throw new Error(`Projection "${target}" .of() requires a state`);
+        const name = partials[0].name;
+        for (const partial of partials)
+          if (partial.name !== name)
+            throw new Error(
+              `Projection "${target}" .of() partials must share one state name \u2014 got "${name}" and "${partial.name}"`
+            );
+        const config2 = resolveFoldConfig(options);
+        const fold_events = {};
+        for (const partial of partials)
+          for (const [event_name, schema] of Object.entries(partial.events)) {
+            if (event_name in fold_events) continue;
+            const noop = {
+              [`${target}_fold`]: async () => {
+              }
+            }[`${target}_fold`];
+            fold_events[event_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,
+              fold: { name, flush: handler, config: config2 }
+            })
+          })
+        };
+      }
     });
   }
   return base;