@rotorsoft/act 1.19.0 → 1.20.0

package/dist/index.js

@@ -1556,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 }],
       {
@@ -1566,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(
@@ -1778,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 }) => {
@@ -1860,18 +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, {
-          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;
@@ -3740,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;
@@ -3805,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,
@@ -3818,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);
@@ -3960,39 +3988,52 @@ function _projection(target) {
           batchHandler: handler
         })
       }),
-      of: (state2, options = {}) => {
+      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 [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 }
-                }
-              ]
-            ])
-          };
-        }
+        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,
-              batchHandler: make_fold_handler(state2, handler, config2)
+              fold: { name, flush: handler, config: config2 }
             })
           })
         };