@rotorsoft/act 0.25.2 → 0.26.1

package/dist/index.js

@@ -309,7 +309,7 @@ var InMemoryStream = class {
   _error = "";
   _leased_by = void 0;
   _leased_until = void 0;
-  get is_avaliable() {
+  get is_available() {
     return !this._blocked && (!this._leased_until || this._leased_until <= /* @__PURE__ */ new Date());
   }
   get at() {
@@ -503,7 +503,7 @@ var InMemoryStore = class {
   async claim(lagging, leading, by, millis) {
     await sleep();
     const available = [...this._streams.values()].filter(
-      (s) => s.is_avaliable && (s.at < 0 || this._events.some(
+      (s) => s.is_available && (s.at < 0 || this._events.some(
         (e) => e.id > s.at && e.name !== SNAP_EVENT && (!s.source || RegExp(s.source).test(e.stream))
       ))
     );
@@ -747,7 +747,7 @@ async function action(me, action2, target, payload, reactingTo, skipValidation =
   if (!stream) throw new Error("Missing target stream");
   payload = skipValidation ? payload : validate(action2, payload, me.actions[action2]);
   const snapshot = await load(me, stream);
-  const expected = expectedVersion || snapshot.event?.version;
+  const expected = expectedVersion ?? snapshot.event?.version;
   logger2.trace(
     payload,
     `\u{1F535} ${stream}.${action2}${typeof expected === "number" ? `.${expected}` : ""}`
@@ -806,7 +806,7 @@ async function action(me, action2, target, payload, reactingTo, skipValidation =
     );
   } catch (error) {
     if (error.name === "ERR_CONCURRENCY") {
-      void cache().invalidate(stream);
+      await cache().invalidate(stream);
     }
     throw error;
   }
@@ -834,9 +834,10 @@ async function action(me, action2, target, payload, reactingTo, skipValidation =
 var logger3 = log();
 var tracer = build_tracer(config().logLevel);
 var Act = class {
-  constructor(registry, _states = /* @__PURE__ */ new Map()) {
+  constructor(registry, _states = /* @__PURE__ */ new Map(), batchHandlers = /* @__PURE__ */ new Map()) {
     this.registry = registry;
     this._states = _states;
+    this._batch_handlers = batchHandlers;
     const statics = [];
     for (const [name, register] of Object.entries(this.registry.events)) {
       if (register.reactions.size > 0) {
@@ -894,6 +895,8 @@ var Act = class {
    */
   /** Static resolver targets collected at build time */
   _static_targets;
+  /** Batch handlers for static-target projections (target → handler) */
+  _batch_handlers;
   /**
    * Executes an action on a state instance, committing resulting events.
    *
@@ -1135,6 +1138,41 @@ var Act = class {
     }
     return { lease, handled, at };
   }
+  /**
+   * Handles a batch of events for a projection with a batch handler.
+   *
+   * Called by `drain()` when a leased stream is a static-target projection
+   * with a registered batch handler. All events are passed to the handler
+   * in a single call, enabling bulk DB operations.
+   *
+   * @internal
+   * @param lease The lease to handle
+   * @param payloads The reactions to handle
+   * @param batchHandler The batch handler for this projection
+   * @returns The lease with results
+   */
+  async handleBatch(lease, payloads, batchHandler) {
+    const stream = lease.stream;
+    const events = payloads.map((p) => p.event);
+    const at = events.at(-1).id;
+    lease.retry > 0 && logger3.warn(`Retrying batch ${stream}@${events[0].id} (${lease.retry}).`);
+    try {
+      await batchHandler(events, stream);
+      return { lease, handled: events.length, at };
+    } catch (error) {
+      logger3.error(error);
+      const { options } = payloads[0];
+      const block = lease.retry >= options.maxRetries && options.blockOnError;
+      block && logger3.error(`Blocking ${stream} after ${lease.retry} retries.`);
+      return {
+        lease,
+        handled: 0,
+        at: lease.at,
+        error: error.message,
+        block
+      };
+    }
+  }
   /**
    * Processes pending reactions by draining uncommitted events from the event store.
    *
@@ -1229,10 +1267,12 @@ var Act = class {
           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 payloads = payloadsMap.get(lease.stream);
+            const batchHandler = this._batch_handlers.get(lease.stream);
+            if (batchHandler && payloads.length > 0) {
+              return this.handleBatch({ ...lease, at }, payloads, batchHandler);
+            }
+            return this.handle({ ...lease, at }, payloads);
           })
         );
         const [lagging_handled, leading_handled] = handled.reduce(
@@ -1617,7 +1657,11 @@ function registerState(state2, states, actions, events) {
       patch: mergedPatch,
       on: { ...existing.on, ...state2.on },
       given: { ...existing.given, ...state2.given },
-      snap: state2.snap || existing.snap
+      snap: state2.snap && existing.snap && state2.snap !== existing.snap ? (() => {
+        throw new Error(
+          `Duplicate snap strategy for state "${state2.name}"`
+        );
+      })() : state2.snap || existing.snap
     };
     states.set(state2.name, merged);
     for (const name of Object.keys(merged.actions)) {
@@ -1673,14 +1717,15 @@ var _void_ = () => void 0;
 function act(states = /* @__PURE__ */ new Map(), registry = {
   actions: {},
   events: {}
-}, pendingProjections = []) {
+}, pendingProjections = [], batchHandlers = /* @__PURE__ */ new Map()) {
   const builder = {
     withState: (state2) => {
       registerState(state2, states, registry.actions, registry.events);
       return act(
         states,
         registry,
-        pendingProjections
+        pendingProjections,
+        batchHandlers
       );
     },
     withSlice: (input) => {
@@ -1697,22 +1742,28 @@ function act(states = /* @__PURE__ */ new Map(), registry = {
       return act(
         states,
         registry,
-        pendingProjections
+        pendingProjections,
+        batchHandlers
       );
     },
     withProjection: (proj) => {
       mergeProjection(proj, registry.events);
+      if (proj.batchHandler && proj.target) {
+        batchHandlers.set(proj.target, proj.batchHandler);
+      }
       return act(
         states,
         registry,
-        pendingProjections
+        pendingProjections,
+        batchHandlers
       );
     },
     withActor: () => {
       return act(
         states,
         registry,
-        pendingProjections
+        pendingProjections,
+        batchHandlers
       );
     },
     on: (event) => ({
@@ -1725,19 +1776,22 @@ function act(states = /* @__PURE__ */ new Map(), registry = {
             maxRetries: options?.maxRetries ?? 3
           }
         };
-        const name = handler.name || `${String(event)}_${registry.events[event].reactions.size}`;
-        registry.events[event].reactions.set(name, reaction);
+        if (!handler.name)
+          throw new Error(
+            `Reaction handler for "${String(event)}" must be a named function`
+          );
+        registry.events[event].reactions.set(handler.name, reaction);
         return {
           ...builder,
           to(resolver) {
-            registry.events[event].reactions.set(name, {
+            registry.events[event].reactions.set(handler.name, {
               ...reaction,
               resolver: typeof resolver === "string" ? { target: resolver } : resolver
             });
             return builder;
           },
           void() {
-            registry.events[event].reactions.set(name, {
+            registry.events[event].reactions.set(handler.name, {
               ...reaction,
               resolver: _void_
             });
@@ -1749,10 +1803,14 @@ function act(states = /* @__PURE__ */ new Map(), registry = {
     build: () => {
       for (const proj of pendingProjections) {
         mergeProjection(proj, registry.events);
+        if (proj.batchHandler && proj.target) {
+          batchHandlers.set(proj.target, proj.batchHandler);
+        }
       }
       return new Act(
         registry,
-        states
+        states,
+        batchHandlers
       );
     },
     events: registry.events
@@ -1761,9 +1819,9 @@ function act(states = /* @__PURE__ */ new Map(), registry = {
 }
 
 // src/projection-builder.ts
-function projection(target, events = {}) {
-  const defaultResolver = target ? { target } : void 0;
-  const builder = {
+function _projection(target, events) {
+  const defaultResolver = typeof target === "string" ? { target } : void 0;
+  const base = {
     on: (entry) => {
       const keys = Object.keys(entry);
       if (keys.length !== 1) throw new Error(".on() requires exactly one key");
@@ -1786,23 +1844,23 @@ function projection(target, events = {}) {
             }
           };
           const register = events[event];
-          const name = handler.name || `${event}_${register.reactions.size}`;
-          register.reactions.set(name, reaction);
-          const nextBuilder = projection(
-            target,
-            events
-          );
+          if (!handler.name)
+            throw new Error(
+              `Projection handler for "${event}" must be a named function`
+            );
+          register.reactions.set(handler.name, reaction);
+          const nextBuilder = _projection(target, events);
           return {
             ...nextBuilder,
             to(resolver) {
-              register.reactions.set(name, {
+              register.reactions.set(handler.name, {
                 ...reaction,
                 resolver: typeof resolver === "string" ? { target: resolver } : resolver
               });
               return nextBuilder;
             },
             void() {
-              register.reactions.set(name, {
+              register.reactions.set(handler.name, {
                 ...reaction,
                 resolver: _void_
               });
@@ -1814,11 +1872,28 @@ function projection(target, events = {}) {
     },
     build: () => ({
       _tag: "Projection",
-      events
+      events,
+      ...target !== void 0 && { target }
     }),
     events
   };
-  return builder;
+  if (typeof target === "string") {
+    return {
+      ...base,
+      batch: (handler) => ({
+        build: () => ({
+          _tag: "Projection",
+          events,
+          target,
+          batchHandler: handler
+        })
+      })
+    };
+  }
+  return base;
+}
+function projection(target, events = {}) {
+  return _projection(target, events);
 }
 
 // src/slice-builder.ts
@@ -1852,19 +1927,22 @@ function slice(states = /* @__PURE__ */ new Map(), actions = {}, events = {}, pr
             maxRetries: options?.maxRetries ?? 3
           }
         };
-        const name = handler.name || `${String(event)}_${events[event].reactions.size}`;
-        events[event].reactions.set(name, reaction);
+        if (!handler.name)
+          throw new Error(
+            `Reaction handler for "${String(event)}" must be a named function`
+          );
+        events[event].reactions.set(handler.name, reaction);
         return {
           ...builder,
           to(resolver) {
-            events[event].reactions.set(name, {
+            events[event].reactions.set(handler.name, {
               ...reaction,
               resolver: typeof resolver === "string" ? { target: resolver } : resolver
             });
             return builder;
           },
           void() {
-            events[event].reactions.set(name, {
+            events[event].reactions.set(handler.name, {
               ...reaction,
               resolver: _void_
             });