@zudojs/messaging 1.0.0 → 1.0.1

package/README.md

@@ -79,6 +79,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/messageMiddleware/messageMiddlewarePipeline.js

@@ -81,7 +81,7 @@ export async function runMessagePipeline(middlewareList, handler, message, optio
     const composed = compose(resolvedMiddleware, async (ctx) => handler(message, ctx));
     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.1",
   "description": "In-process message bus infrastructure with handlers, middleware, and publish/subscribe patterns.",
   "type": "module",
   "main": "./dist/index.js",
@@ -19,8 +19,8 @@
     "!dist/.tsbuildinfo"
   ],
   "dependencies": {
-    "@zudojs/errors": "1.0.0",
-    "@zudojs/constants": "1.0.0"
+    "@zudojs/errors": "1.0.1",
+    "@zudojs/constants": "1.0.1"
   },
   "engines": {
     "node": ">=24.0.0"
@@ -30,6 +30,10 @@
     "vitest": "^4.1.11"
   },
   "license": "MIT",
+  "author": {
+    "name": "Oluwayemi Oyinlola",
+    "url": "https://github.com/oyinlola-tech"
+  },
   "publishConfig": {
     "access": "public"
   },