@zudojs/messaging 0.0.1 → 1.0.0

package/dist/messageBus/messageBusCore.js

@@ -6,12 +6,13 @@
 import { createMessage } from "../message/messageFactory.js";
 import { HandlerRegistryStore } from "../handlerRegistry/handlerRegistryStore.js";
 import { DefaultDispatcher } from "../dispatcher/dispatcherCore.js";
-import { MessageDispatchError } from "@zudojs/errors";
+import { MessageBusDisposedError } from "@zudojs/errors";
 /** Default in-memory message bus. */
 export class InMemoryMessageBus {
     dispatcher;
     registry;
     defaultTimeout;
+    handlerSequence = 0;
     _disposed = false;
     constructor(options = {}) {
         this.registry = new HandlerRegistryStore({
@@ -31,36 +32,27 @@ export class InMemoryMessageBus {
     async dispatch(message, options = {}) {
         this.validateNotDisposed(message);
         const timeout = options.timeout ?? this.defaultTimeout;
-        const dispatchOptions = { ...options, timeout };
-        if (timeout > 0) {
-            return this.dispatchWithTimeout(message, dispatchOptions);
-        }
-        return this.dispatcher.dispatch(message, dispatchOptions);
+        // The timeout is the dispatcher's job. The bus used to race the dispatch
+        // itself and abort on expiry, which produced a generic abort error and
+        // meant the dispatcher's own documented `timeout` option stayed dead.
+        return this.dispatcher.dispatch(message, {
+            ...options,
+            timeout,
+        });
     }
-    validateNotDisposed(message) {
+    validateNotDisposed(_message) {
         if (this._disposed) {
-            throw new MessageDispatchError(message.type, "Message bus has been disposed.");
-        }
-    }
-    async dispatchWithTimeout(message, options) {
-        const controller = new AbortController();
-        const timeoutId = setTimeout(() => controller.abort(), options.timeout ?? 0);
-        try {
-            const result = await this.dispatcher.dispatch(message, {
-                ...options,
-                signal: controller.signal,
-            });
-            return result;
-        }
-        finally {
-            clearTimeout(timeoutId);
+            throw new MessageBusDisposedError();
         }
     }
     async send(input, options = {}) {
         return this.dispatch(createMessage(input), options);
     }
     on(messageType, handler, options = {}) {
-        const id = options.id ?? `handler:${messageType}:${Date.now()}`;
+        // A clock-derived id collided whenever two handlers for the same type
+        // were registered inside one millisecond, which then threw
+        // DuplicateMessageHandlerError from what looked like ordinary setup.
+        const id = options.id ?? `handler:${messageType}:${++this.handlerSequence}`;
         const namedHandler = {
             id,
             name: id,
@@ -77,8 +69,11 @@ export class InMemoryMessageBus {
     off(handlerId) {
         return this.registry.unregister(handlerId);
     }
-    use(middleware) {
-        this.dispatcher.use(middleware);
+    use(middleware, options) {
+        return this.dispatcher.use(middleware, options);
+    }
+    removeMiddleware(middlewareId) {
+        return this.dispatcher.removeMiddleware(middlewareId);
     }
     hasHandlers(messageType) {
         return this.registry.resolve(messageType).length > 0;

package/dist/messageBus/messageBusType.type.d.ts

@@ -8,7 +8,7 @@
  */
 import type { Message, MessageInput } from "../message/messageType.type.js";
 import type { MessageHandler, NamedMessageHandler } from "../messageHandler/messageHandlerType.type.js";
-import type { MessageMiddlewareLike } from "../messageMiddleware/messageMiddlewareType.type.js";
+import type { MessageMiddlewareLike, MessageMiddlewareOptions } from "../messageMiddleware/messageMiddlewareType.type.js";
 import type { DispatchResult, DispatchOptions } from "../dispatcher/dispatcherType.type.js";
 /**
  * Options for creating a message bus.
@@ -59,10 +59,18 @@ export interface MessageBus {
     off(handlerId: string): boolean;
     /**
      * Adds middleware to the bus.
+     *
+     * Middleware runs in ascending `priority` order (default 100).
+     *
+     * @returns The identifier {@link MessageBus.removeMiddleware} takes.
      */
-    use<TMessage extends Message = Message, TResult = unknown>(middleware: MessageMiddlewareLike<TMessage, TResult>, options?: {
-        priority?: number;
-    }): void;
+    use<TMessage extends Message = Message, TResult = unknown>(middleware: MessageMiddlewareLike<TMessage, TResult>, options?: MessageMiddlewareOptions): string;
+    /**
+     * Removes middleware by the id `use` returned.
+     *
+     * @returns Whether a registration was removed.
+     */
+    removeMiddleware(middlewareId: string): boolean;
     /**
      * Checks if handlers are registered for a message type.
      */

package/dist/messageMiddleware/messageMiddlewarePipeline.js

@@ -49,20 +49,31 @@ export async function runMessagePipeline(middlewareList, handler, message, optio
     const metadata = options.metadata ?? {};
     const state = options.state ?? new Map();
     const executions = [];
-    const resolvedMiddleware = middlewareList.map((mw) => {
+    const resolvedMiddleware = middlewareList.map((mw, index) => {
         const resolved = resolveMiddlewareLike(mw);
+        // Each record now names the middleware it belongs to and carries what
+        // that middleware returned. Both used to be wrong: every record was
+        // labelled with the pipeline's own execution id, and `result` was pushed
+        // from a `finally` block that could only ever see `undefined`.
+        const middlewareId = options.middlewareIds?.[index] ?? `${executionId}#${index}`;
         return async (ctx, next) => {
             const mwStart = performance.now();
             try {
-                return await resolved(ctx, next);
+                const result = await resolved(ctx, next);
+                executions.push({
+                    middlewareId,
+                    result,
+                    duration: performance.now() - mwStart,
+                });
+                return result;
             }
-            finally {
-                const duration = performance.now() - mwStart;
+            catch (error) {
                 executions.push({
-                    middlewareId: executionId,
+                    middlewareId,
                     result: undefined,
-                    duration,
+                    duration: performance.now() - mwStart,
                 });
+                throw error;
             }
         };
     });

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

@@ -73,6 +73,7 @@ export interface RegisteredMessageMiddleware<TMessage extends Message = Message,
  * Execution record for a single middleware.
  */
 export interface MessageMiddlewareExecution<TResult = unknown> {
+    /** The id of the middleware this record describes. */
     readonly middlewareId: string;
     readonly result: TResult;
     readonly duration: number;
@@ -92,5 +93,10 @@ export interface MessageMiddlewarePipelineOptions {
     readonly signal?: AbortSignal;
     readonly metadata?: Readonly<Record<string, unknown>>;
     readonly state?: Map<string, unknown>;
+    /**
+     * Identifiers parallel to the middleware list, used to label the execution
+     * records. Positions without an id fall back to a synthesised one.
+     */
+    readonly middlewareIds?: readonly string[];
 }
 //# sourceMappingURL=messageMiddlewareType.type.d.ts.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zudojs/messaging",
-  "version": "0.0.1",
+  "version": "1.0.0",
   "description": "In-process message bus infrastructure with handlers, middleware, and publish/subscribe patterns.",
   "type": "module",
   "main": "./dist/index.js",
@@ -13,16 +13,20 @@
     }
   },
   "files": [
-    "dist"
+    "dist",
+    "!dist/**/*.map",
+    "!dist/**/*.tsbuildinfo",
+    "!dist/.tsbuildinfo"
   ],
   "dependencies": {
-    "@zudojs/errors": "0.0.1",
-    "@zudojs/constants": "0.0.1"
+    "@zudojs/errors": "1.0.0",
+    "@zudojs/constants": "1.0.0"
   },
   "engines": {
     "node": ">=24.0.0"
   },
   "devDependencies": {
+    "typescript": "7.0.2",
     "vitest": "^4.1.11"
   },
   "license": "MIT",
@@ -36,13 +40,17 @@
     "pubsub"
   ],
   "homepage": "https://github.com/oyinlola-tech/zudo#readme",
+  "bugs": {
+    "url": "https://github.com/oyinlola-tech/zudo/issues"
+  },
   "repository": {
     "type": "git",
-    "url": "https://github.com/oyinlola-tech/zudo"
+    "url": "https://github.com/oyinlola-tech/zudo",
+    "directory": "packages/messaging"
   },
   "scripts": {
     "build": "tsc -p tsconfig.json",
-    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "typecheck": "tsc -p tsconfig.json --noEmit && tsc -p tsconfig.test.json --noEmit",
     "test": "vitest run",
     "test:watch": "vitest",
     "clean": "rm -rf dist"