@rotorsoft/act 0.25.1 → 0.26.0

package/dist/index.js

@@ -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(
@@ -1673,14 +1713,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 +1738,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) => ({
@@ -1749,10 +1796,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 +1812,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");
@@ -1788,10 +1839,7 @@ 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
-          );
+          const nextBuilder = _projection(target, events);
           return {
             ...nextBuilder,
             to(resolver) {
@@ -1814,11 +1862,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