@rotorsoft/act 0.29.1 → 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) {