@zudojs/messaging 1.0.0 → 1.0.2

package/README.md

@@ -2,6 +2,12 @@
 
 In-process message bus infrastructure with handlers, middleware, and publish/subscribe patterns.
 
+<!-- zudo-docs:start -->
+
+**Documentation:** [zudojs.oyinlola.site/docs/packages-messaging](https://zudojs.oyinlola.site/docs/packages-messaging) · **For AI agents:** [Markdown version](https://zudojs.oyinlola.site/docs/packages-messaging.md), [llms.txt](https://zudojs.oyinlola.site/llms.txt)
+
+<!-- zudo-docs:end -->
+
 ## Installation
 
 ```bash
@@ -79,6 +85,12 @@ const bus = createMessageBus({ allowMultipleHandlers: false });
 `DispatchResult.handlerResults` records every handler that ran, including the
 one that failed, with its real duration.
 
+Handlers receive the dispatch context as their second argument: the
+`headers`, `state` and correlation/causation overrides passed through
+`DispatchOptions.context`, plus anything a middleware stored in
+`context.state`. A dispatch cancelled through its `AbortSignal` between
+handlers fails with `MessageDispatchAbortedError`.
+
 ## Timeouts
 
 `timeout` is honoured by the dispatcher itself, so it applies whether you hold

package/dist/dispatcher/dispatcherCore.js

@@ -33,7 +33,7 @@ export class DefaultDispatcher {
         this.validateNotDisposed(message);
         const timeout = options.timeout ?? 0;
         const controller = new AbortController();
-        const signal = this.resolveSignal(options.signal, controller);
+        const { signal, release } = this.resolveSignal(options.signal, controller);
         const context = createMessageContext(message, {
             ...options.context,
             signal,
@@ -52,11 +52,17 @@ export class DefaultDispatcher {
         const handlerResults = [];
         let timer;
         try {
-            const run = runMessagePipeline(allMiddleware, async (msg, mwCtx) => this.executeHandlers(msg, handlers, handlerResults, mwCtx.signal), message, {
+            const run = runMessagePipeline(allMiddleware, 
+            // Handlers receive the same context the middleware saw: the one
+            // built from `DispatchOptions.context` (headers, state, correlation
+            // overrides) plus anything a middleware put into `state`. A fresh
+            // context per handler used to drop all of that on the floor.
+            async (msg, mwCtx) => this.executeHandlers(msg, handlers, handlerResults, mwCtx.context), message, {
                 signal: context.signal,
-                metadata: options.context?.headers,
-                state: options.context?.state,
+                metadata: context.headers,
+                state: context.state,
                 middlewareIds,
+                context,
             });
             // `DispatchOptions.timeout` was documented on the dispatcher but only
             // ever honoured by the bus wrapper, so anyone holding a dispatcher
@@ -92,6 +98,9 @@ export class DefaultDispatcher {
         finally {
             if (timer !== undefined)
                 clearTimeout(timer);
+            // Detach from the caller's signal, otherwise a long-lived signal
+            // shared across dispatches accumulates one listener per dispatch.
+            release();
         }
     }
     /** A promise that rejects with {@link MessageTimeoutError} and aborts. */
@@ -133,19 +142,30 @@ export class DefaultDispatcher {
     resolveSignal(signal, controller) {
         if (signal?.aborted)
             throw new MessageDispatchAbortedError();
-        if (signal) {
-            signal.addEventListener("abort", () => controller.abort(signal.reason), {
-                once: true,
-            });
+        if (!signal) {
+            return { signal: controller.signal, release: () => { } };
         }
-        return controller.signal;
+        const onAbort = () => controller.abort(signal.reason);
+        signal.addEventListener("abort", onAbort, { once: true });
+        return {
+            signal: controller.signal,
+            release: () => signal.removeEventListener("abort", onAbort),
+        };
     }
-    async executeHandlers(message, handlers, handlerResults, signal) {
+    async executeHandlers(message, handlers, handlerResults, context) {
         const results = [];
         for (const handler of handlers) {
+            // A dispatch cancelled between handlers is reported as an abort, not
+            // as a failure of the handler that never got to run.
+            if (context.signal.aborted) {
+                throw new MessageDispatchAbortedError(undefined, {
+                    messageType: message.type,
+                    messageId: message.id,
+                });
+            }
             const start = performance.now();
             try {
-                const result = await this.executeHandler(handler, message, signal);
+                const result = await this.executeHandler(handler, message, context);
                 results.push(result);
                 handlerResults.push({
                     handlerId: handler.id,
@@ -168,11 +188,8 @@ export class DefaultDispatcher {
         }
         return results.length === 1 ? results[0] : results;
     }
-    async executeHandler(handler, message, signal) {
+    async executeHandler(handler, message, context) {
         try {
-            if (signal.aborted)
-                throw new MessageDispatchAbortedError();
-            const context = createMessageContext(message, { signal });
             return await handler.handler(message, context);
         }
         catch (error) {

package/dist/handlerRegistry/handlerRegistryStore.js

@@ -20,7 +20,19 @@ export class HandlerRegistryStore {
     }
     register(handler) {
         this.validateNotDuplicate(handler.id);
-        this.validateSingleHandlerPerType(handler);
+        // Replacing a handler id must drop the old entry from the type index
+        // first, or the replacement keeps receiving the old handler's types.
+        const previous = this.handlers.get(handler.id);
+        if (previous !== undefined)
+            this.removeHandlerFromTypeIndex(previous);
+        try {
+            this.validateSingleHandlerPerType(handler);
+        }
+        catch (error) {
+            if (previous !== undefined)
+                this.indexHandlerTypes(previous.handler);
+            throw error;
+        }
         const entry = {
             handler,
             registeredAt: new Date(),

package/dist/messageHandler/messageHandlerType.type.js

@@ -13,6 +13,6 @@ export function resolveMessageHandler(handler) {
     if (typeof handler === "function") {
         return handler;
     }
-    return handler.handle;
+    return handler.handle.bind(handler);
 }
 //# sourceMappingURL=messageHandlerType.type.js.map

package/dist/messageMiddleware/messageMiddlewarePipeline.js

@@ -3,32 +3,7 @@
  *
  * @module messageMiddleware/messageMiddlewarePipeline
  */
-/**
- * Compose an array of middleware into a single function.
- *
- * The returned function executes middleware in order.
- * If no middleware is provided, the handler is called directly.
- */
-function compose(middlewareList, handler) {
-    if (middlewareList.length === 0) {
-        return handler;
-    }
-    return async (context) => {
-        let index = -1;
-        async function dispatch(i) {
-            if (i <= index) {
-                throw new Error("next() called multiple times");
-            }
-            index = i;
-            if (i < middlewareList.length) {
-                const mw = middlewareList[i];
-                return mw(context, () => dispatch(i + 1));
-            }
-            return handler(context);
-        }
-        return dispatch(0);
-    };
-}
+import { compose } from "@zudojs/middleware";
 /**
  * Resolves a MessageMiddlewareLike to a plain MessageMiddleware function.
  */
@@ -36,7 +11,7 @@ function resolveMiddlewareLike(mw) {
     if (typeof mw === "function") {
         return mw;
     }
-    return mw.handle;
+    return mw.handle.bind(mw);
 }
 /**
  * Runs a handler through a middleware pipeline and returns the
@@ -78,10 +53,11 @@ export async function runMessagePipeline(middlewareList, handler, message, optio
         };
     });
     const pipelineStart = performance.now();
-    const composed = compose(resolvedMiddleware, async (ctx) => handler(message, ctx));
+    // Unbounded depth: the list length is fixed by the registered middleware.
+    const composed = compose(resolvedMiddleware, async (ctx) => handler(message, ctx), { maxDepth: Number.POSITIVE_INFINITY });
     const context = {
         message,
-        context: {
+        context: options.context ?? {
             message,
             correlationId: message.correlationId ??
                 message.id,

package/dist/messageMiddleware/messageMiddlewareType.type.d.ts

@@ -98,5 +98,10 @@ export interface MessageMiddlewarePipelineOptions {
      * records. Positions without an id fall back to a synthesised one.
      */
     readonly middlewareIds?: readonly string[];
+    /**
+     * Message context to expose as `MessageMiddlewareContext.context`.
+     * When omitted one is derived from the message and the options above.
+     */
+    readonly context?: MessageContext;
 }
 //# sourceMappingURL=messageMiddlewareType.type.d.ts.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zudojs/messaging",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "description": "In-process message bus infrastructure with handlers, middleware, and publish/subscribe patterns.",
   "type": "module",
   "main": "./dist/index.js",
@@ -19,8 +19,9 @@
     "!dist/.tsbuildinfo"
   ],
   "dependencies": {
-    "@zudojs/errors": "1.0.0",
-    "@zudojs/constants": "1.0.0"
+    "@zudojs/constants": "1.1.0",
+    "@zudojs/errors": "1.1.0",
+    "@zudojs/middleware": "1.0.2"
   },
   "engines": {
     "node": ">=24.0.0"
@@ -30,6 +31,10 @@
     "vitest": "^4.1.11"
   },
   "license": "MIT",
+  "author": {
+    "name": "Oluwayemi Oyinlola",
+    "url": "https://github.com/oyinlola-tech"
+  },
   "publishConfig": {
     "access": "public"
   },