@rotorsoft/act 0.29.0 → 0.30.0

package/dist/index.js

@@ -1033,24 +1033,22 @@ var Act = class {
    * }
    * ```
    *
-   * @example Reaction triggering another action
+   * @example Reaction triggering another action (reactingTo auto-injected)
    * ```typescript
    * const app = act()
    *   .withState(Order)
    *   .withState(Inventory)
    *   .on("OrderPlaced")
-   *     .do(async (event, context) => {
-   *       // This action is triggered by an event
-   *       const result = await context.app.do(
+   *     .do(async function reduceInventory(event, _stream, app) {
+   *       // Inside reaction handlers, reactingTo is auto-injected when omitted.
+   *       // The triggering event is used by default, maintaining the correlation chain.
+   *       await app.do(
    *         "reduceStock",
-   *         {
-   *           stream: "inventory-1",
-   *           actor: event.meta.causation.action.actor
-   *         },
-   *         { amount: event.data.items.length },
-   *         event // Pass event for correlation tracking
+   *         { stream: "inventory-1", actor: { id: "sys", name: "system" } },
+   *         { amount: event.data.items.length }
    *       );
-   *       return result;
+   *       // To use a different correlation, pass reactingTo explicitly:
+   *       // await app.do("reduceStock", target, payload, customEvent);
    *     })
    *     .to("inventory-1")
    *   .build();
@@ -1186,6 +1184,11 @@ var Act = class {
    * This is called by the main `drain` loop after fetching new events.
    * It handles reactions, supporting retries, blocking, and error handling.
    *
+   * Each handler receives a scoped `IAct` proxy that auto-injects the
+   * triggering event as `reactingTo` when `do()` is called without it,
+   * maintaining correlation chains by default (#587). Handlers can still
+   * pass an explicit `reactingTo` to override this behavior.
+   *
    * @internal
    * @param lease The lease to handle
    * @param payloads The reactions to handle
@@ -1196,10 +1199,24 @@ var Act = class {
     const stream = lease.stream;
     let at = payloads.at(0).event.id, handled = 0;
     lease.retry > 0 && logger3.warn(`Retrying ${stream}@${at} (${lease.retry}).`);
+    const doAction = this.do.bind(this);
+    const scopedApp = {
+      do: doAction,
+      load: this.load.bind(this),
+      query: this.query.bind(this),
+      query_array: this.query_array.bind(this)
+    };
     for (const payload of payloads) {
       const { event, handler, options } = payload;
+      scopedApp.do = (action2, target, payload2, reactingTo, skipValidation) => doAction(
+        action2,
+        target,
+        payload2,
+        reactingTo ?? event,
+        skipValidation
+      );
       try {
-        await handler(event, stream, this);
+        await handler(event, stream, scopedApp);
         at = event.id;
         handled++;
       } catch (error) {
@@ -1955,7 +1972,6 @@ var _this_ = ({ stream }) => ({
   source: stream,
   target: stream
 });
-var _void_ = () => void 0;
 
 // src/act-builder.ts
 function act(states = /* @__PURE__ */ new Map(), registry = {
@@ -2033,13 +2049,6 @@ function act(states = /* @__PURE__ */ new Map(), registry = {
               resolver: typeof resolver === "string" ? { target: resolver } : resolver
             });
             return builder;
-          },
-          void() {
-            registry.events[event].reactions.set(handler.name, {
-              ...reaction,
-              resolver: _void_
-            });
-            return builder;
           }
         };
       }
@@ -2102,13 +2111,6 @@ function _projection(target, events) {
                 resolver: typeof resolver === "string" ? { target: resolver } : resolver
               });
               return nextBuilder;
-            },
-            void() {
-              register.reactions.set(handler.name, {
-                ...reaction,
-                resolver: _void_
-              });
-              return nextBuilder;
             }
           };
         }
@@ -2184,13 +2186,6 @@ function slice(states = /* @__PURE__ */ new Map(), actions = {}, events = {}, pr
               resolver: typeof resolver === "string" ? { target: resolver } : resolver
             });
             return builder;
-          },
-          void() {
-            events[event].reactions.set(handler.name, {
-              ...reaction,
-              resolver: _void_
-            });
-            return builder;
           }
         };
       }